類和對象（十五）

類

簡介

  類是對象的抽象，而對象是類的具體實例。類是抽象的，不佔用內存，而對象是具體的，佔用存儲空間。類是用於創建對象的藍圖，它是一個定義包括在特定類型的對象中的方法和變量的軟件模板。

  Scala中的類不聲明爲public，一個Scala源文件中可以有多個類。

簡單實例

import java.io._

class Point(xc: Int, yc: Int) {
   var x: Int = xc
   var y: Int = yc

   def move(dx: Int, dy: Int) {
      x = x + dx
      y = y + dy
      println ("x 的座標點: " + x);
      println ("y 的座標點: " + y);
   }
}

object Test {
   def main(args: Array[String]) {
      val pt = new Point(10, 20);

      // 移到一個新的位置
      pt.move(10, 10);
   }
}

抽象類

  抽象類是一種不能被實例化的類，抽象類中包括了若干不能完整定義的方法，這些方法由子類去擴展定義自己的實現。

abstract class Animal {
  //抽象字段(域）
  //前面我們提到，一般類中定義字段的話必須初始化，而抽象類中則沒有這要求
  var height:Int
  //抽象方法
  def eat:Unit
}

//Person繼承Animal，對eat方法進行了實現
//通過主構造器對height參數進行了初始化
class Person(var height:Int) extends Animal{
  //對父類中的方法進行實現，注意這裏面可以不加override關鍵字
  def eat()={
    println("eat by mouth")
  }

}

//通過擴展App創建程序的入口
//App其實是一種trait，它幫助我們定義了main方法。
object Person extends App{
  new Person(10).eat()
}

繼承

簡介

• 重寫一個非抽象方法必須使用override修飾符。
• 重寫超類的抽象方法時，不需要使用override關鍵字。
• 只有主構造函數纔可以往基類的構造函數裏寫參數。
• 繼承會繼承父類的所有屬性和方法，Scala 只允許繼承一個父類。

簡單實例

class Point(xc: Int, yc: Int) {
   var x: Int = xc
   var y: Int = yc

   def move(dx: Int, dy: Int) {
      x = x + dx
      y = y + dy
      println ("x 的座標點: " + x)
      println ("y 的座標點: " + y)
   }
}

class Location(override val xc: Int, override val yc: Int,
   val zc :Int) extends Point(xc, yc){
   var z: Int = zc

   override def move(dx: Int, dy: Int) {
       x = x - dx
       y = y - dy
       println ("x 的座標點: " + x)
       println ("y 的座標點: " + y)
   }

   def move(dx: Int, dy: Int, dz: Int) {
      x = x + dx
      y = y + dy
      z = z + dz
      println ("x 的座標點 : " + x)
      println ("y 的座標點 : " + y)
      println ("z 的座標點 : " + z)
   }
}

object Test {
   def main(args: Array[String]) {
      val loc = new Location(10, 20, 15);

      // 移到一個新的位置
      loc.move(10, 10);
      loc.move(10, 10, 5);
   }
}

單例對象

簡介

  在Scala中，是沒有static的，但是提供了單例模式的實現方法，那就是使用關鍵字object。

  Scala中使用單例模式時，除了定義的類之外，還要定義一個同名的 object對象，它和類的區別是，object對象不能帶參數。

簡單實例

object Student {
  private var studentNo:Int=0;
  def uniqueStudentNo()={
    studentNo+=1
    studentNo
  }
  def main(args: Array[String]): Unit = {
    println(Student.uniqueStudentNo())
  }
}

伴生類與伴生對象

簡介

  當單例對象與某個類是同一個名稱時，單例對象被稱作是這個類的伴生對象，類被稱爲是這個單例對象的伴生類。必須在同一個源文件裏定義伴生類和伴生對象。它們可以互相訪問其私有成員。

簡單實例

class Student(var name:String,var age:Int){
  private var sex:Int=0
  //直接訪問伴生對象的私有成員
  def printCompanionObject()=println(Student.studentNo)
}

object Student {
  private var studentNo:Int=0;
  def uniqueStudentNo()={
    studentNo+=1
    studentNo
  }
  def main(args: Array[String]): Unit = {
    println(Student.uniqueStudentNo())
    val s=new Student("john",29)
    //直接訪問伴生類Student中的私有成員
    println(s.sex)
  }
}

匿名類

  當某個類在程序中只使用一次時，可以將類定義爲匿名類。

//抽象的Person類
abstract class Person(name:String,age:Int){ 
  def walk():Unit
}


object demo{
  def main(args: Array[String]): Unit = {
     //下面的代碼定義了一個匿名類，並且進行了實例化
     //直接new Person("john",18)，後面跟的是類的內容
     //我們知道，Person是一個抽象類，它是不能被實例化的
     //這裏能夠直接new操作是因爲我們擴展了Person類，只不
     //過這個類是匿名的，只能使用一次而已
     val s=new Person("john",18){
       override def walk()={
         println("Walk like a normal Person")
       }
     }
     s.walk()   
  }
}

多態與動態綁定

簡介

  多態(Polymorphic)也叫動態綁定(Dynamic Binding)、遲綁定(Late Binding)，指在執行期間（而非編譯期間）判斷所引用對象的實際類型，根據其實際類型調用其相應的方法。子類的引用可以賦給父類。

簡單實例

//抽象Person類
abstract class Person(var name:String,var age:Int){

  def walk():Unit
  //talkTo方法，參數爲Person類型
  def talkTo(p:Person):Unit
}

class Student(name:String,age:Int) extends Person(name,age){
  private var studentNo:Int=0
  def walk()=println("walk like a elegant swan")
  //重寫父類的talkTo方法
  def talkTo(p:Person)={
    println("talkTo() method in Student")
    println(this.name+" is talking to "+p.name)
  }
}

class Teacher(name:String,age:Int) extends Person(name,age){
  private var teacherNo:Int=0

  def walk()=println("walk like a elegant swan")

   //重寫父類的talkTo方法
  def talkTo(p:Person)={
    println("talkTo() method in Teacher")
    println(this.name+" is talking to "+p.name)
  }
}

object demo{
  def main(args: Array[String]): Unit = {

     //下面的兩行代碼演示了多態的使用
     //Person類的引用可以指向Person類的任何子類
     val p1:Person=new Teacher("albert",38)
     val p2:Person=new Student("john",38)

     //下面的兩行代碼演示了動態綁定
     //talkTo方法參數類型爲Person類型
     //p1.talkTo(p2)傳入的實際類型是Student
     //p2.talkTo(p1)傳入的實際類型是Teacher
     //程序會根據實際類型調用對應的不同子類中的talkTo()方法
     p1.talkTo(p2)
     p2.talkTo(p1)
  }
}

---

忠於技術，熱愛分享。歡迎關注公衆號：java大數據編程，瞭解更多技術內容。