1 面向物件特點

• 封裝：屬性、方法封裝到類中；
• 繼承
• 多型：父類引用指向子類物件，開發框架的基石

package com.scalatest.scala.oop

object SimpleObjectApp {
    def main(args: Array[String]): Unit = {
        val person = new People()
        person.name = "Mike"
        println(person.name + "-" + person.age)
        println(
 
"eat:" + person.eat)

        person.play("Beijing")

        person.printInfo()
    }
}

class People {

    //定義屬性
    var name: String = _
    val age: Int = 20

    //只能在 class 內部訪問
    private [this] val gender = "male"

    def printInfo(): Unit ={
        println("gender: " + gender)
    }

    def
 
 eat(): String = {
        name + " eating.."
    }

    def play(loc: String): Unit = {
        println(name + " is at " + loc)
    }
}

1.1 佔位符 _

2 Scala 構造器

package com.scalatest.scala.oop


object ConstructorApp {
    def main(args: Array[String]): Unit = {
        val person = new Person(
 
"Mike", 20)
    }
}

//主構造器
class Person(val name: String, val age: Int) {
    println(" enter Person constructor ..")

    val school = "AAA"

    var gender: String = _

    //附屬構造器
    def this(name: String, age: Int, gender: String) {
        this(name,age)// 附屬構造器的第一行必須呼叫主構造器或者其他附屬構造器

        this.gender = gender
    }

    println(" leave Person constructor ..")
}

3 繼承

子類繼承父類的時候，如果父類有的屬性，不用寫 val,var，如果是子類所特有的，要加，否則在外面訪問不到。

package com.scalatest.scala.oop


object ConstructorApp {
    def main(args: Array[String]): Unit = {
        //val person = new Person("Mike", 20)

        val student = new Student("John", 24, "Math")
        println(student.name + "-" + student.major)
    }
}

//主構造器
class Person(val name: String, val age: Int) {
    println(" enter Person constructor ..")

    val school = "AAA"

    var gender: String = _

    //附屬構造器
    def this(name: String, age: Int, gender: String) {
        this(name, age) // 附屬構造器的第一行必須呼叫主構造器或者其他附屬構造器

        this.gender = gender
    }

    println(" leave Person constructor ..")
}

class Student(name: String, age: Int, var major: String) extends Person(name, age) {
    println(" enter Student constructor ..")


    println(" leave Student constructor ..")
}

4 重寫

package com.scalatest.scala.oop


object ConstructorApp {
    def main(args: Array[String]): Unit = {
        //val person = new Person("Mike", 20)

        val student = new Student("John", 24, "Math")
        println(student.name + "-" + student.major)
        println(student)
    }
}

//主構造器
class Person(val name: String, val age: Int) {
    println(" enter Person constructor ..")

    val school = "AAA"

    var gender: String = _

    //附屬構造器
    def this(name: String, age: Int, gender: String) {
        this(name, age) // 附屬構造器的第一行必須呼叫主構造器或者其他附屬構造器

        this.gender = gender
    }

    println(" leave Person constructor ..")
}

class Student(name: String, age: Int, var major: String) extends Person(name, age) {
    println(" enter Student constructor ..")

    override val school = "SSS"
    override def toString: String = "Person: override def toString " + school

    println(" leave Student constructor ..")
}

5 抽象類

package com.scalatest.scala.oop

object AbstractApp {
    def main(args: Array[String]): Unit = {
        val student = new Student2()
        println(student.name)
        student.speak
    }
}

/*
* 類的一個或者多個方法沒有完整的實現
* */
abstract class Person2 {
    def speak

    val name: String
    val age: Int
}

class Student2 extends Person2 {
    override def speak: Unit = {
        println("speak")
    }

    override val name: String = "Mike"
    override val age: Int = 18
}

6 伴生類和伴生物件

package com.scalatest.scala.oop

object ApplyApp {

}


/*
* 伴生類和伴生物件
* 如果有一個 class,還有一個與 class同名的 object
* 這個 object 是 class 的伴生物件，class 是 object 的伴生類
* */
class ApplyTest{

}

object ApplyTest{

}

6.1 apply 方法

• 類名() ⇒ 呼叫 Object.apply
• 物件() => 呼叫 Class.apply

package com.scalatest.scala.oop

object ApplyApp {
    def main(args: Array[String]): Unit = {
//        for (i <- 1 to 10) {
//            ApplyTest.incr
//        }
//
//        println(ApplyTest.count) // 10,說明 object 本身就是一個單例物件

        /*
        * 這裡不需要 new，new的操作已經在 Object 中 apply中
        * */
        val b = ApplyTest(); // => Object.apply

        println("========================================")
        val c = new ApplyTest()
        println(c)
        c()


    }
}


/*
* 伴生類和伴生物件
* 如果有一個 class,還有一個與 class同名的 object
* 這個 object 是 class 的伴生物件，class 是 object 的伴生類
* */
class ApplyTest {
    def apply()={
        println("class ApplyTest apply...")

    }
}

object ApplyTest {

    println("Object ApplyTest enter...")

    var count = 0

    def incr = {
        count = count + 1
    }


    /*
    * 最佳實踐：在 Object 的apply 方法中 new Class
    * */
    def apply()={
        println("Object ApplyTest apply...")

        // 在 object 中的 apply 中 new class
        new ApplyTest
    }


    println("Object ApplyTest leave...")
}