类的继承（二）

继承与多态

特点

面向对象的三个特点：封装，继承，多态 。

多态性

同一操作作用于不同的对象， 可以有不同的解释，产生不同的执行结果，这就是多态性。

通过代码来理解多态-写一个函数，它的参数类型是父类。

 object class11 {
  class  Fruit() {
    def eat(): Unit={
      println("eat...")
    }
  }

  class Apple extends Fruit {
    override def eat(): Unit = {
      println("吃掉果皮，中间的不能吃")
    }
  }
  
  class Watermelon extends Fruit {
    override def eat(): Unit = {
      println("削皮，中间最好吃")
    }
  }
  
  def main(args: Array[String]): Unit = {
    // 参数类型：父类
    def test(fruit: Fruit): Unit = {
      fruit.eat()
    }
    
    val a1 = new Apple()
    test(a1) // 传入子类
    
    val w1 = new Watermelon()
    test(w1)
  }
}

传入一个子类对象之后，还是可以正常工作。

处理构造器的调用顺序

当我们实例化子类的对象时，是否需要调用父类的构造器？ 是否需要调用子类的构造器？

代码验证调用顺序：父类的主构造器->子类主构造器->子类的辅助构造器

package zys

/**
 *  构造器的调用顺序： 先调用父类的，再调用子类的
 *  当父类，子类都存在带参数的构造器的时候，如何进行参数传递？
 */
object class13 {
  class Animal(var name:String, var age:Int) {
    println(s"父类的构造器被调用....${name}, ${age}")
    def say(): Unit = {
      println(s"Animal ${name}, ${age}")
    }
  }

  // 子类
  class Dog(name:String,age:Int, var color:String) extends Animal(name, age){
    println(s"子类的构造器被调用....${name}, ${age}, ${color}")
    override def say(): Unit = {
      super.say()
      println(s"狗狗.... , 我的颜色是${color}")
    }
  }

  def main(args: Array[String]): Unit = {
    val d1 = new Dog("旺财", 1, "黑色")
    d1.say()
  }
}