主要內容

類的繼承

構造函數執行順序

方法重寫

匿名類

多態與動態綁定

組合與繼承的使用

1 類的繼承

下類的代碼演示了Scala類的繼承

//Person類 class Person(name:String,age:Int){}//Student繼承Person類 class Student(name:String,age:Int,var studentNo:String) extends Person(name,age){}object demo{def main(args: Array[String]): Unit = {val student=new Student("john",18,"1024")} }

代碼

//Person類 class Person(name:String,age:Int){}//Student繼承Person類 class Student(name:String,age:Int,var studentNo:String) extends Person(name,age){}

等同于下面的Java代碼

//Person類 class Person{private String name;private int age;public Person(String name,int age){this.name=name;this.age=age;} }//Student繼承Person類 class Student extends Person{private String studentNo;public Student(string name,int age,String studentNo){super(name,age);this.sutdentNo=studentNo;} }

2. 構造函數執行順序

下面的代碼演示scala在繼承的時候，構造函數的執行順序

//Person類 class Person(name:String,age:Int){println("Constructing Person") }//Student繼承Person類 class Student(name:String,age:Int,var studentNo:String) extends Person(name,age){println("Constructing Student") }object demo{def main(args: Array[String]): Unit = {//下面的語句執行時會打印下列內容//Constructing Person//Constructing Student//也就是說，構造Student這前，首先會調用Person的主構造方法val student=new Student("john",18,"1024")} }

下面這段代碼

//Person類 class Person(name:String,age:Int){println("Constructing Person") }//Student繼承Person類 class Student(name:String,age:Int,var studentNo:String) extends Person(name,age){println("Constructing Student") }

等同于下面的java代碼

//Person類 class Person{private String name;private int age;public Person(String name,int age){this.name=name;this.age=age;System.out.println("Constructing Person");} }//Student繼承Person類 class Student extends Person{private String studentNo;public Student(string name,int age,String studentNo){super(name,age);this.sutdentNo=studentNo;System.out.println("Constructing Student");} }

3. 方法重寫

方法重寫指的是當子類繼承父類的時候，從父類繼承過來的方法不能滿足子類的需要，子類希望有自己的實現，這時需要對父類的方法進行重寫，方法重寫是實現多態和動態綁定的關鍵。
scala中的方法重寫同java一樣，也是利用override關鍵字標識重寫父類的算法。
下面的代碼演示了方法重寫如何實現

class Person(name:String,age:Int){//println("Constructing Person")def walk():Unit=println("walk like a normal person") }//Student繼承Person類 class Student(name:String,age:Int,var studentNo:String) extends Person(name,age){//println("Constructing Student")override def walk():Unit={super.walk()//調用父類的walk方法println("walk like a elegant swan")//增加了自己的實現} }object demo{def main(args: Array[String]): Unit = {val s=new Student("john",18,"1024")s.walk()} }//代碼運行輸出內容 walk like a normal person walk like a elegant swan

不得不提的是，如果父類是抽象類，則不override關鍵字可以不加，這是因為如果繼承的父類是抽象類（假設抽象類為AbstractClass，子類為SubClass），在SubClass類中，AbstractClass對應的抽象方法如果沒有實現的話，那SubClass也必須定義為抽象類，否則的話必須要有方法的實現，這樣的話，加不加override關鍵字都是可以的。下面是一個實例代碼：

//抽象的Person類 abstract class Person(name:String,age:Int){def walk():Unit }//Student繼承抽象Person類 class Student(name:String,age:Int,var studentNo:String) extends Person(name,age){//重寫抽象類中的walk方法，可以不加override關鍵字def walk():Unit={println("walk like a elegant swan")} }object demo{def main(args: Array[String]): Unit = {val s=new Student("john",18,"1024")s.walk()} }

4. 匿名類

當某個類在程序中只使用一次時，可以將類定義為匿名類，匿名類的定義如下：

//抽象的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() } }

5 多態與動態綁定

“多態”(Polymorphic)也叫“動態綁定”(Dynamic Binding)、“遲綁定”(Late Binding)，指“在執行期間（而非編譯期間）判斷所引用對象的實際類型，根據其實際類型調用其相應的方法。”即指子類的引用可以賦給父類，程序在運行時根據實際類型調用對應的方法
下面的代碼演示了scala中的多態與動態綁定：

//抽象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=0def 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=0def 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)} }

6. 組合與繼承的使用

繼承可以重用父類的代碼，從而簡化程序設計，繼承是is-a的關系，apple is a kind of fruit（蘋果是一種水果）。還有一種代碼重用的方式是組合，組合是has-a的關系（one person has a head）。繼承在前面已經講了，這邊只給出組合的使用代碼：

class Head class Body class Hand //....//Person類 abstract class Person(var name:String,var age:Int){//各類的實例作為該類對象的一部分，通過各類的實例方法實現代碼重用val head:Head=null val body:Body=nullval hadn:Hand=nulll//.... }

繼承與組合使用總結：

一 繼承

　　繼承是Is a 的關系，比如說Student繼承Person,則說明Student is a Person。繼承的優點是子類可以重寫父類的方法來方便地實現對父類的擴展。
　　繼承的缺點有以下幾點：
　　1 父類的內部細節對子類是可見的。
　　2 子類從父類繼承的方法在編譯時就確定下來了，所以無法在運行期間改變從父類繼承的方法的行為。
3 如果對父類的方法做了修改的話（比如增加了一個參數），則子類的方法必須做出相應的修改。所以說子類與父類是一種高耦合，違背了面向對象思想。

二 組合

　　組合也就是設計類的時候把要組合的類的對象加入到該類中作為自己的成員變量。組合的優點：
　　 1 當前對象只能通過所包含的那個對象去調用其方法，所以所包含的對象的內部細節對當前對象時不可見的。
　　2 當前對象與包含的對象是一個低耦合關系，如果修改包含對象的類中代碼不需要修改當前對象類的代碼。
　　3 當前對象可以在運行時動態的綁定所包含的對象。可以通過set方法給所包含對象賦值。
　　組合的缺點：
　　1 容易產生過多的對象。
　　2 為了能組合多個對象，必須仔細對接口進行定義。
由此可見，組合比繼承更具靈活性和穩定性，所以在設計的時候優先使用組合。只有當下列條件滿足時才考慮使用繼承：
1 子類是一種特殊的類型，而不只是父類的一個角色
2 子類的實例不需要變成另一個類的對象
3 子類擴展，而不是覆蓋或者使父類的功能失效

總結

以上是生活随笔為你收集整理的Scala入门到精通——第九节 继承与组合的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。