Scala Learn 02 Class/Object

Myth丶恋晨 2022-02-16 07:51 217阅读 0赞

## Chapter 5 Class ##

**focus on:**

1.  var foo: Scala自动合成 getter 和 setter
2.  val foo: Scala 自动合成 getter
3.  由你定义 foo and foo\_= 方法
4.  由你定义 foo 方法

### 5.1 简单类 ###

class Demo {
      def doStart(name: java.lang.String) =
        println("hello Scala " + name)
    }

### 5.2 带 getter 和 setter 属性 ###

class Cat {
      var age = 0
    }

class Person1 {
      private var privateAge = 0
    
      def age = privateAge
      def age_=(newValue: Int): Unit = {
        if (newValue > privateAge) { // can't become young
          privateAge = newValue
        }
      }
    }

### 5.3 只带 getter 属性 ###

class Message {
      val timeStamp = new java.util.Date // Scala 会生成一个 final 字段 和 一个 getter function
    
    }

### 5.4 对象私有字段 ###

class Counter {
    
      private var value = 0 // private[this] var value = 0 这是对象私有字段 某个对象.value 不允许
    
      def increment() { value += 1 } // function default is public
    
      def current = value  // 取值器
    
      def isLess(other: Counter) = value < other.value
    
    }

### 5.5 主/辅 构造器 ###

class Person2 {
      private var name = ""
      private var age = 0
    
      def this(name: String) { // auxiliary comstructor
        this()
        this.name = name
      }
    
      def this(name: String, age: Int) { // Another auxiliary constructor
        this(name)
        this.age = age
      }
    }

#### 主构造器的几种形式 ####

主构造器 与 类定义 交织在一起, 主构造器不以 this 来命名

class Person(val name: String, val age: Int) {
      println("Just constructed another person")
      def description = name + " is " + age + " years old"
    }
    
    /** 多样化的声明 **/
    class Person(val name: String, private var age: Int) {
      println("Just constructed another person")
      def description = name + " is " + age + " years old"
    }
    
    /** private[this]val 对象私有效果 **/
    class Person(name: String, age: Int) {
      println("Just constructed another person")
      def description = name + " is " + age + " years old"
    }
    
    /** 主 构造器 私有 **/
    class Person private(val id: Int) {
        ...
    }

### 5.6 MainTest ###

package com.x.mainTest
    
    import com.x.p5class._
    
    /**
      * Date : 2016-04-05
      */
    object SampleDemo {
      // Single Object
    
      def main(args: Array[String]) = {
    
        /** Demo **/
        val demo = new Demo
        demo doStart "my first program with scala"
    
        /** chapter 5 **/
    
        println("chap 5")
        // 5.1  sample class
        val counter1 = new Counter
        val counter2 = new Counter
        counter2.increment()
        println(counter1.current)
        println(counter1.isLess(counter2))
    
        // 5.2 getter and setter
        val cat = new Cat
        cat.age = 9
    
        val fred = new Person1
        fred.age = 9
        println(fred.age)
        fred.age = 7
        println(fred.age)
    
        // 5.3 only getter
        val message = new Message
        println(message.timeStamp)
    
    
        // 5.6 auxiliary constructor
        val p1 = new Person2 // primary constructor
        var p2 = new Person2("Fred")
        var p3 = new Person2("Fred", 42)
    
      }
    }

**Output**

com.intellij.rt.execution.application.AppMain com.x.mainTest.SampleDemo
    hello Scala my first program with scala
    chap 5
    0
    true
    9
    9
    Tue Apr 05 11:11:39 CST 2016
    
    Process finished with exit code 0

## Chapter 6 Object ##

**focus on:**

1.  用对象作为单例或存放工具方法
2.  类可以拥有一个同名的伴生对象
3.  对象可以扩展类或特质
4.  对象的 apply 方法通常来构造伴生类的新实例
5.  如果不想显式定义 main 方法， 可以用扩展 App 特质的对象
6.  你可以通过扩展 Enumeration对象 来实现枚举

1. 单例对象、伴生对象
     2. 扩展类或特质的对象
     3. apply 方法、应用程序对象
     4. 枚举

### 6.1 对象 ###

object Accounts {
      private var lastNumber = 0
      def newUniqeNumber() = {
        lastNumber += 1;
        lastNumber
      }
    
    }
    
    /**
      * Scala 中 Object 可作为存放 工具函数 或 常量, 高效地共享 单个不可变实例
      */

### 6.2 伴生对象 ###

/**
      * Date : 2016-04-05
      */
    class Account {
      val id = Account.newUniqueNumber() // Scala getter
      private var balance = 0.0          // Scala getter and setter
      def deposit(amount: Double): Unit = {
        balance += amount
      }
    }
    object Account { // 伴生对象
      private var lastNumber = 0
    
      private def newUniqueNumber() = {
        lastNumber += 1
        lastNumber
      }
    }
    
    /**
      * Account.newUniqueNumber() 非 newUniqueNumber()
      *
      * 它们必须在同一个源文件中
      */

### 6.3 扩展类或特质的object ###

abstract class UndoableAction(val desc: String) {
      def undo(): Unit
      def redo(): Unit
    }

/**
      * Date : 2016-04-05
      * Desc : 一个 object 可以扩展类以及一个或多个特质 , 结果是 同时 拥有在对象定义中给出的所有特性
      *
      * DoNothing 对象可以被所有需要这个缺省行为的地方共用
      */
    object DoNothingAction extends UndoableAction("Do nothing"){
      override def undo() {}
      override def redo() {}
    
      def main(args: Array[String]): Unit = {
        val actions = Map("open"-> DoNothingAction, "save"->DoNothingAction)
    
        println("open and save function is not implement.")
      }
    }

### 6.4 apply 方法 ###

class Acc private (val id: Int, initialBalance: Double) {
      private var balance = initialBalance
    }
    
    object Acc {
      private var lastNumber = 0
    
      private def newUniqueNumber() = {
        lastNumber += 1
        lastNumber
      }
    
      def apply(initialBalance: Double) =
        new Acc(newUniqueNumber(), initialBalance)
    }

### 6.5 应用程序对象 ###

object HelloWorld {
      def main(args: Array[String]) {
        println("Hello, World, Scala, main")
      }
    }

/**
      * Date : 2016-04-05
      *
      * 扩展 App 特性, 相当于一样可以完成 main 的功能, -Dscala.time
      */
    object Hello extends App {
      if (args.length > 0) {
        println("Hello, " + args(0))
      }
      else {
        println("Hello, World2")
      }
    
      println(TrafficLightColor.Red)
    
      println(TrafficLightColor.Green)
    
      println(TrafficLightColor.Yellow)
    
      println(TrafficLightColor.Blue)
    
      println(TrafficLightColor.values)
    
      println(TrafficLightColor.withName("Blue"))
    
      println(TrafficLightColor(10))
    
    }

### 6.4 枚举 ###

object TrafficLightColor extends Enumeration {
    
      type TrafficLightColor = Value // 你可以 增加了一个类型别名 TrafficLightColor.TrafficLightColor 等价 TrafficLightColor.Value
    
      val Blue, Green = Value  // 缺省名称为 字段名
    
    //  val Red = Value
    //  val Yellow = Value
    //  val Green = Value
      val Red = Value(10)
    
      val Yellow = Value
    }

## Chapter 7 包和引入 ##

**focus on:**

1.  包可以像 内部类 那样嵌套
2.  位于文件顶部不带花括号的包声明在整个文件范围内有效
3.  包对象可以持有函数和变量
4.  引入语句可以引入 包、类 和 对象
5.  java.lang、scala、Predef 总是被引入

7.1 包 7.2 作用域规则 7.3 串联式包语句
     7.4 文件顶部标记法 7.5 包对象 7.6 包可见性
     7.7 引入 7.8 声明引入 7.9 重命名和隐藏方法 7.10 隐式引入

## Chapter 8 继 承 ##

**focus on:**

1.  extends、final 关键字和 Java 中相同
2.  重写方法时必须用 override
3.  主构造器 可以调用 超类 的 主构造器
4.  你可以重写字段

### 8.1 扩展类 ###

class Employee extends Person2 {
      var salary = 0.0
    
      // 重写方法
      override def toString = super.toString + "[salary=" + salary + "]"
    }

### 8.2 重写方法 ###

scala 中重写一个非抽象方法必须使用 override 修饰符。

class Employee extends Person2 {
      var salary = 0.0
    
      // 重写方法
      override def toString = super.toString + "[salary=" + salary + "]"
    }

### 8.3 类型检查和转换 ###

object HelloP8 extends App {
    
      println(new Employee().toString)
    
      // 类型检查和转换
    
      val employee = new Employee();
    
      if (employee.isInstanceOf[Employee]) {
        val s = employee.asInstanceOf[Employee] // s 的类型为 Employee
        println("is Employee, true")
      }
      // 8.4 受保护字段和方法, protected 成员对于 所属的包而言,是不可见的
    }

### 8.4 受保护字段和方法 ###

受保护字段和方法, protected 成员对于 所属的包而言,是不可见的

### 8.5 超类的构造 ###

/**
      * Date : 2016-04-05
      *
      * 超类的构造
      *
      * 辅构造器 只能 调用 辅/主 构造器, 但不能调用 超构造器, 主构造器 可以 调用 超构造器
      */
    class Employee02(name: String, age: Int, val salary: Double) extends Person2(name, age){
      // 重写方法
      override def toString = super.toString + "[salary=" + salary + "]"
    }

### 8.6 重写字段 ###

可以用 另一个 同名的 val 字段 重写一个 val (或不带参数的 def)。

子类有一个私有字段和一个公有的getter方法, 而这个 getter 方法重写了超类的 getter 方法

abstract class Person { // 关于抽象类的内容
      def id: Int  // 每个人都有一个以某种方式计算出来的 ID
    }
    class Student(override val id: Int) extends person

### 8.7 匿名子类 ###

Person {def greeting: String}

### 8.8 抽象类 ###

abstract class Person(val name: String) {
      def id: Int // 没有方法体，这是一个抽象方法
    }

子类重写超类的抽象方法， 不需要使用 override 关键字

class Employee(name: String) extends Person(name) {
      def id = name.hashcode // 不需要 override 关键字
    }

### 8.9 抽象字段 ###

除了抽象方法，类还可以具有**抽象字段**

abstract class Person {
      val id: Int
        // 没有初始化--带有抽象的 getter 方法的抽象字段
      var name: String
        // 抽象字段 -- 带有抽象的 getter， setter 方法的抽象字段

class Employee(val id: Int) extends Person { // 子类有具体的 id 属性
      var name = "" // 和具体的 name 属性
    }

val fred = new Person {
      val id = 1729
      var name = "Fred"
    }

### 8.11 Scala 继承层级 ###

AnyRef 相当于 Java 的 Object  
AnyVal 和 AnyRef 都扩展自 Any, 而 Any 是整个继承层级的根节点  
Any 类定义了 isInstanceOf、asInstanceOf 方法， 以及用于相等性判断和哈希吗的方法  
AnyRef 类追加了来自 Object 类的监视方法 wait 和 notify / notify All. 同时提供了一个带函数参数的方法 synchronized. 这个方法等同于 Java 的 synchronized 的块。

![图片描述][887650354-57037fc62a8fe_articlex]

[887650354-57037fc62a8fe_articlex]: /images/20220216/03568641aa884ffb99df5124032517e7.png