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

叁歲伎倆 2022-08-26 15:22 172阅读 0赞

#### 类，字段和方法 ####

类是对象的蓝图，可以通过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)