Scala 學習之面向對象（3）

==> 類

        ---> 類的定義

class Student{
    // 定義屬性
    private var stuName:String = "Tom"
    private vat stuAge:Int = 18
    
    // 定義方法
    def getStuName():String = stuName
    def setStuName(newName:String) = {
        this.stuName = newName
    }
    
    
}

        ---> 伴生類和伴生對象    object 相當于 Java 中的 static

            ---- object 對象可以跟類名不一樣，如果跟類名一樣，這個對象就是該類的伴生對象，反之，這個類就是這個伴生對象的伴生類

        ---> set 和 get 方法  

            ---- Scala 中，會自動給 private 定義的屬性生成get和set 方法，使用 val 可以使其只生成 get 方法，而不會生成set 方法

            ---- 在定義變量時使用 this 關鍵字，可以使其成為此類的私有屬性，不會生成 get 和 set 方法，如：

 // 定義正常的屬性，可自動生成get 和 set  方法
 private var aaa:String = "hello"
 
 // 定義只可自動生成 get 方法的屬性
 private val aaa:String = "hello"
 
 // 使用this 關鍵字，使其定義的屬性成為此類的私有屬性，不允許外界訪問
 private[this] var aaa:String = "hello"

        ---> 嵌套類（內部類）

            ---- 內部類中的參數可以當做類的參數傳遞

        ---> 類的構造器

            ---- 主構造器 和類的聲明在一起，只能有一個主構造器

class Student(val stuName: String, val stuAge: Int){

}

object Student{
    def main(args: Array[String]): Unit = {
        var stu = new Student("Tom", 20)
        println(stu.stuName + "\t" + stu.stuAge)
    }
}

            ---- 輔助構造器  可以有多個輔助構造器，使用 this 關鍵字

class Student(val stuName:String, val stuAge:Int){
    // 定義一個輔助構造器
    def this(age:Int){
    // 調用主構造器
    this("No Name", age)
    }
}

object Student{  // 
    var stu = new Student(22)
    println(stu.stuName + "\t" + stu.stuAge)
}    // 輸出結果為 NoName   22

        ---> Object 對象： 相當于 Java 中的 static 關鍵字

            ---- 單例模式： 一個類只有一個對象

// 生成信用卡的卡號
object CreditCard{
    // 定義變量： 保存信用卡的卡號
    // 該屬性只屬于該對象 
    private[this] var creditCardNumbe:Long = 0
    
    // 產生卡號
    def generateNewCCNumber():Long = {
        creditCardNumbe += 1
        creditCardNumber
    }
    
    // 測試程序
    def main(args:Array[String]): Unit = {
    // 得到新的卡號
        println(CreditCard.generateNewCCNumber)
        println(CreditCard.generateNewCCNumber)
        println(CreditCard.generateNewCCNumber)
        println(CreditCard.generateNewCCNumber)
    }
}

            ---- 應用程序對象： App   ----- 可以省略 main 方法

object testApp extends App {
    // 省略了 main 方法，可以直接將結果輸出
    println("hello")
}

        ---> 類的 apply 方法

            ---- 作用： 創建對象時，省略 new 關鍵字，需要定義在類的伴生對象中

class Student(stuName:String){

}

object Student{
    // 定義 apply 方法，必須定義在類的伴生對象中
    def apply(stuName: String) = {
        // 調用主構造器
        new Student(stuName)
    }
    def main(args: Array[String]): Unit = {
        var stu = Student("Tom")
    }
}

==> 繼承

        ---> 簡單繼承

// 測試
object DemoExtends{
  def main(args: Array[String]): Unit = {
    // 創建一個 Person 對象
    val p1:Person = new Person("Tom", 20)
    println(p1.sayHello())            // My name is Tom，age is 20

    // 創建一個子類
    val p2:Person = new Employee("Marry", 32, 1233)
    println(p2.sayHello())            // 子類中的 sayHello

    // 創建一個匿名子類
    val p3:Person = new Person("Jerry", 33){
      override def sayHello(): String = "匿名函數中的 sayHello 方法"
    }
    println(p3.sayHello())            // 匿名函數中的 sayHello 方法
  }
}
// 父類
class Person(val name:String, val age:Int){
  def sayHello():String = "My name is " + name + "，age is " + age
}

// 子類    如果需要子類的值覆蓋父類的值，需要加上 override 參數
class Employee(override val name:String, override val age:Int, val salary:Int) extends Person(name, age){
  override def sayHello(): String = "子類中的 sayHello"
}

        ---> 繼承抽象類和抽象字段

object TestExtendsDemo {
  def main(args: Array[String]): Unit = {
    var apple:Fruit = new Apple()
    var orange:Fruit = new Orange()

    println(apple.name())        // 結果為 apple
    println(orange.name())        // 結果為 orange

  }
}

abstract class Fruit{
  var id:Int
  def name():String
  
}

class Apple extends Fruit{
   // 實現抽象字段
   var id:Int = 1
  // 實現抽象方法
  def name():String = {
    "apple"
  }

}

// 可以通過構造方法對抽象字段進行處理
class Orange() extends Fruit{
  def name:String = {
    "orange"
  }

}

        ---> 特質trait: 有點像接口，也有點像抽象類    支持多重繼承，可以定義抽象方和字段，也可以定義完整的方法和字段

object Demo1 {

  def main(args: Array[String]): Unit = {
    var com:Computer = new Computer(1)
    println(com.run())
    println(com.movedown())
  }

}

class Computer(var monitorid:Int) extends Monitor with Mouse with Keyboard {
  def run():String = {
    "running"
  }

  def moveup(): String = {
    "moveup"
  }

  override def movedown(): String = {
    "movedown"
  }

  override def press(): String = {
    "press"
  }

}

trait Monitor{
  var monitorid:Int
  def run():String

}

trait Mouse{
  def moveup():String
  def movedown():String
}

trait Keyboard{
  def press():String
}

==> 包的定義和使用

        ---> 包的定義：

// 定義格式一
package com.mytest
class Demo{}

// 定義格式二
package com.mytest{
    class Demo{}
}

        ---> 包的使用(引入)：

import com.mytest.Demo        // 可以不寫Demo 的全路徑
import com.mytest._            // 引入mytest 包下所有的屬性
import com.mytest.Demo._        // 引入 Demo 類中所有的屬性

==> 包對象

package object MyPackageDemo{
    // 常量
    val a:Int = 1
    // 變量
    var a:String = "hello"
    // 方法
    def Demo():String = {
        "Demo"
    }
    // 類
    class Demo{
        
    }
    // 對象 object
    object Demo{
    
    }
    // trait(特質)
    trait Demo{
    
    }
}