7.3 类的继承和多态

类的继承

继承是一种描述类与类之间的关系，反映的是“is a”这种关系。子类通过关键字extends继承了父类的字段和方法，同时可以自定义相应的字段和方法。

需要注意的是，如果父类中的成员，包括父类被final关键字修饰了，则无法被继承和覆盖。同样的，如果父类成员被private关键字修饰之后，子类也无法继承或是覆盖。

当有继承体系的时候，在用子类构造器创建对象的时候，先调用父类的构造器。

子类调用父类成员，如果子类没有重名的，直接成员名，如果有重名的，需要使用super来调用。也就是说，在父类中定义方法，通过“super.方法名”调用即可。

Scala中是无法直接调用父类构造器，是间接调用父类构造器，只能是主构造器调用父类的构造器，辅助构造器是不能直接调用父类的构造器。

// 基类
class Vehicle(speed: Int) {
  def race() = println("赛车")
}
​
// 派生类:只有主构造函数可以将参数传递给基构造函数
class RacingCar(speed: Int, color: String) extends Vehicle(speed) {
  override def race() = println("Racing Car")
  
  def info = println(s"速度:$speed, 颜色:$color")
}
​
// 另一个子类
class Bike(speed:Int, model:String) extends Vehicle(speed) {
  override def race() = println("Racing Bike")  
  def detail = println(s"速度:$speed, 品牌:$model")
}
​
object Demo3 {
  def main(args: Array[String]) {
    // 对象
    val vehicle1 = new RacingCar(200,"red")
    vehicle1.race
    vehicle1.info
​
    println("-----------------------")
    
    val vehicle2 = new Bike(100,"绿佳")
    vehicle2.race
    vehicle2.detail
​
    println("-----------------------")
    // 多态
    var veh: Vehicle = new RacingCar(250,"blue")
    println(veh.kph)
    veh.race
​
    veh = new Bike(150,"爱玛")
    println(veh.kph)
    veh.race
  }
}

在处理类和对象层次结构时，通常会有一个封装公共行为的基类。例如，让我们创建一个抽象类名Donut，它为printName定义了一个方法签名。

abstract class Donut(name: String) {
   def printName: Unit
}

任何扩展abstract类Donut的类都必须提供printName方法的实现。

要创建抽象Donut类的子类，必须使用extends关键字、传递name构造函数参数并为printName方法提供实现。如下面的示例所示，类VanillaDonut扩展了抽象类Donut，并提供了printName方法的实现。

// 伴生类
class VanillaDonut(name: String) extends Donut(name) {
   override def printName: Unit = println(name)
 }
​
// 伴生对象
object VanillaDonut {
   def apply(name: String): Donut = {
     new VanillaDonut(name)
   }
​
}

定义另一个子类GlazedDonut，从抽象类Donut继承。

class GlazedDonut(name: String) extends Donut(name) {
  override def printName: Unit = println(name)
}
​
object GlazedDonut {
  def apply(name: String): Donut = {
    new GlazedDonut(name)
  }
}

让我们创建两个Donut对象，一个使用VanillaDonut类，另一个使用GlazedDonut类。请注意，我们将vanillaDonut和glazedDonut的类型指定为基本类型Donut。

object InheritanceDemo {
  def main(args: Array[String]): Unit = {
​
    val vanillaDonut: Donut = VanillaDonut("Vanilla Donut")
    vanillaDonut.printName
​
    val glazedDonut: Donut = GlazedDonut("Glazed Donut")
    glazedDonut.printName
  }
}

case类继承

创建抽象Donut类的子类，必须使用extends关键字、传递name构造函数参数并为printName方法提供实现。

如下面的示例所示，case类VanillaDonut2扩展了抽象类Donut，并提供了printName方法的实现。

case class VanillaDonut2(name: String) extends Donut(name) {
  override def printName: Unit = println(name)
}

与之前的类继承不同，我们不需要为VanillaDonut2 case类创建一个伴生对象，因为case类将自动提供一个伴生对象。 创建另一个case类GlazedDonut2，它扩展了抽象Donut类。

case class GlazedDonut2(name: String) extends Donut(name) {
   override def printName: Unit = println(name)
}

同样，我们不需要为VanillaDonut2 case类创建一个伴生对象，因为case类将自动提供一个伴生对象。

让我们创建两个Donut对象，一个使用VanillaDonut2类，另一个使用GlazedDonut2类。请注意，我们将vanillaDonut2和glazedDonut2的类型指定为基本类型Donut。

object InheritanceDemo {
  def main(args: Array[String]): Unit = {
​
    val vanillaDonut2: Donut = VanillaDonut2("Vanilla Donut")
    vanillaDonut2.printName
​
    val glazedDonut2: Donut = GlazedDonut2("Glazed Donut")
    glazedDonut2.printName
  }
}

多态

在Scala继承中，Scala向父类的构造器传递参数。

Java中多态，父类引用指向子类对象，例如：

Fu zi = new zi();

Scala中多态的体现：

val zi:Fu = new zi()

多态类型，编译时看=的左边，运行要看=的右侧。

class Worker(name:String, age:Int) {
​
  var language:String = _
​
  def show(): Unit = {
    println(s"name is $name,, and age is $age")
  }
​
}
​
class Coder(name:String, age:Int, language:String) extends Worker(name, age) {
​
  def this() {
    this("程序员", 18, "Java")
  }
​
  override def show(): Unit = {
    println(s"name is $name, and age is $age, language is $language")
  }
​
}
​
val coder:Worker = new Coder("xpleaf", 23, "scala")
coder.show()