3、Scala 繼承 

3.1、擴充套件類 

在 Scala 中擴充套件類的方式和 Java 一樣都是使用 extends 關鍵字

1、Scala 中，讓子類繼承父類，與 Java 一樣，也是使用 extends 關鍵字

2、繼承就代表，子類可以從父類繼承父類的 field 和 method；然後子類可以在自己內部放 入父類所沒有，子類特有的 field 和 method；使用繼承可以有效複用程式碼

3、子類可以覆蓋父類的 field 和 method；但是如果父類用 final 修飾，field 和 method 用 final 修飾，則該類是無法被繼承的，field 和 method 是無法被覆蓋的 

package com.mazh.scala.day2.oop 
 
/** 
  * 作者： 李濤 https://blog.csdn.net/qq_42246689 
  * 描述： 繼承 測試
   */ 
object ExtendsDemo{ 
  def main(args: Array[String]): Unit = {
     val student=new Student ("黃渤",33,"1024") 
    println(student.studentNo) 
  } 
} 
 
//Person 類 
class Person (name:String,age:Int){ 
  println("Person : "+ name + "\t" + age) 
} 
 
//Student繼承 Person 類 
class Student(name:String,age:Int,var studentNo:String) extends Person(name,age){ 
 println("Student : "+ name + "\t" + age + "\t" + studentNo) 
} 
 

3.2、重寫方法（Override 和 Super） 

1、Scala 中，如果子類要重寫一個父類中的非抽象方法，則必須使用 override 關鍵字

2、override 關鍵字可以幫助我們儘早地發現程式碼裡的錯誤，比如：override 修飾的父類方法 的方法名我們拼寫錯了；比如要覆蓋的父類方法的引數我們寫錯了；等等

3、此外，在子類覆蓋父類方法之後，如果我們在子類中就是要呼叫父類的被覆蓋的方法呢？ 那就可以使用 super 關鍵字，顯式地指定要呼叫父類的方法 

object OverrideDemo { 
  def main(args: Array[String]): Unit = { 
    val student = new Student222 
    student.eat() 
  } 
} 
 
abstract class Person222{ 
  def eat() 
} 
 
class Student222 extends Person222{ 
  // 因為父類是抽象類，所以 override可以加可以不加 
  override def eat(): Unit = {
     println("我要吃成金三胖") 
  } 
} 
 

3.3、型別檢查和轉換 

型別檢查測試程式碼： 

object TypeCheckDemo { 
 
  def main(args: Array[String]): Unit = { 
 
    val p = new Student_11() 
    val p1 = new People_11() 
 
    println(p.isInstanceOf[Student_11]) 
    println(p1.isInstanceOf[Student_11]) 
    println(classOf[Student_11]) 
    println(p.asInstanceOf[Student_11]) 
  } 
} 
 
class People_11{ 
} 
 
class Student_11 extends People_11{ 
} 

3.4、超類的構造 

object ClazzDemo { 
  def main(args: Array[String]) { 
    val h = new Human 
    println(h.fight) 
  } 
} 
 
trait Flyable{ 
 def fly(): Unit ={ 
    println("I can fly") 
  } 
 
  def fight(): String 
} 
 
abstract class Animal1 { 
  def run(): Int 
  val name: String 
} 
 
class Human extends Animal1 with Flyable{ 
 
  val name = "abc" 
 
  // 五個變數分別都賦值一次，那麼 {} 也就相當於要執行五次
   val t1,t2,(a, b, c),t3,t4 = { 
    println("ABC") 
    (1,2,3) 
  } 
 
  println(a) 
  println(t1._1) 
  println(t1.hashCode() + "\t" + t2.hashCode()) 
 
  // 在 Scala中重寫一個非抽象方法必須用 override修飾 
  def fight(): String = {     "fight with 棒子" 
  } 
  // 在子類中重寫超類的抽象方法時，不需要使用 override關鍵字，寫了也可以 
  def run(): Int = { 
    1 
  } 
}