scala编程笔记（三）类，字段和方法

类，字段和方法

类是对象的蓝图，能够通过new来创建对象。在类的定义里能够有字段和方法。统称member

val还是var都是指向对象的变量（var定义的字段可又一次赋值），def定义方法，包括可运行代码

class ScalaSingleton {
    var sum = 0;
}

这里定义类之后创建对象使用了。虽然这里是val，可是对象的变量是能够又一次赋值的

def main(args: Array[String]) {
        val singleton = new ScalaSingleton()
        println(singleton.sum)
        singleton.sum = 5;
        println(singleton.sum)
    }

1，scala默认是public级别

2，scala的參数都是val类型，因此不可再方法体内又一次赋值

3。简洁性

先来个计算的 V1.0版的代码

class ScalaSingleton {
    private var sum = 0;

    def add(b: Byte): Unit = {
      sum += b
    }

    def checksum(): Int = {
      return ~(sum &0xff) + 1
    }
}

1，在scala中假设没有不论什么显示的返回语句。将返回方法中最后一次计算得到的值

2，假如某个方法仅计算单个结果表达式，能够去掉花括号，如是scala代码就变成了这样

class ScalaSingleton {
    private var sum = 0;
    def add(b: Byte): Unit = sum += b
    def checksum(): Int = return ~(sum &0xff) + 1
}

看起来仅占用了一行。另外

def add(b: Byte): Unit = sum += b

事实上能够去掉返回类型Unit 与等号 写成

def add(b: Byte) { sum += b}

这里来看看以下几个写法

def gUnit():Unit = {"Unit"}
println("gUnit():Unit = {\"Unit\"}:"+gUnit)
def gUnit1() {"Unit1"}
println("gUnit1() {\"Unit1\"}: " + gUnit1)
def gStr() = {"String"}
println("gStr() = {\"String\"}: "+gStr)

执行后返回值是这样子的

gUnit():Unit = {"Unit"}:()
gUnit1() {"Unit1"}: ()
gStr() = {"String"}: String

这里有一点就是：带有花括号的，可是无等号的会被专程Unit类型，从而得不到我们想要的返回类型，因此想要得到想要的返回 类型“=”等号是不能少的

分号判断

多行语句中，分毫是必须的，通常行尾能够觉得是一个分号，操作符通常应该是在行尾，而不能是行头

singleton

Scala中不能定义静态成员。取而代之定义单例对象

class 定义,注意包名差别

package com.luyee.scala.classpkg
class ScalaSingleton {
    private var sum = 0;
    def add(b: Byte): Unit = sum += b
    def checksum(): Int = return ~(sum &0xff) + 1
}

Obj定义

package com.luyee.scala

import scala.collection.mutable.Map

object ScalaSingleton {

  private val cache = Map[String, Int]()
    def calculate(s: String):Int =
    if(cache.contains(s)){
      cache(s)
      println("contains"+ cache)
      cache(s)
    }else{
      println("else"+ cache)
      val singleton = new com.luyee.scala.classpkg.ScalaSingleton()
      for(c  <- s)
        singleton.add(c.toByte)
      val cs = singleton.checksum()
      cache += (s -> cs)
      cs
    }

    def main(args: Array[String]) {
    ScalaSingleton.calculate("2")
    ScalaSingleton.calculate("2")
    ScalaSingleton.calculate("2")
    ScalaSingleton.calculate("2")
}
}

最后的输出结果：

not contains: Map()
contains: Map(2 -> -50)
contains: Map(2 -> -50)
contains: Map(2 -> -50)