类的继承

（一）继承的概念和基本语法

定义:在原有类的基础上定义一个新类，原有类称为父类，新类称为子类。

class 子类名 extends 父类名 { 类体 }

好处:复用代码和实现多态。

1.复用代码：子类可以继承父类的特性。

2.多态：子类可以在自己内部实现父类没有的特性。

语法(): 假设定义Parents为父类，C1为子类，通过关键字extends子类便可以继承父类的特性。

package level02

import java.io.FileWriter

object M04 {
  /*
   * 继承
   * extends
   * 好处: 不劳而获
   */

  class Animal() {
    def eating(): Unit = {
      println("Animal eating")
    }
  }

  // Dog 继承了 Animal
  class Dog extends Animal() {
  }

  def main(args: Array[String]): Unit = {
    val dog1 = new Dog()
    dog1.eating() // 直接可以使用父类的方法
  }
}

（二）继承的好处之复用代码

问：那一个类继承了另一个类之后，有什么好处呢？

一旦我们完成了继承，就可以直接在子类的对象中调用父类的方法。

object M05 {
  /*
   * 继承
   * extends
   * 好处: 不劳而获
   * 
   * 问题:
   * 如果子类觉得父类的方法并不是自己要的，如何定义自己的方法呢?
   */
  class Animal() {
    def eating(): Unit = {
      println("Animal eating")
    }
  }

  // Dog 继承了 Animal
  class Dog extends Animal() {
    // 在子类中重写(覆盖)父类的方法
    override def eating(): Unit = {
      println("我是狗，我有自己的吃饭的方式！")
    }
  }

  def main(args: Array[String]): Unit = {
    val dog1 = new Dog()
    dog1.eating() // 调用自己的eating方法
  }
}

（三）继承的方法重写

当子类从父类继承的方法不能满足需要时，子类需要有自己的行为，怎么办？此时使用使用 override 可以重写父类的方法。

object M06 {
  /*
   * 继承
   * extends
   * 好处: 不劳而获
   *
   * 问题:
   * 如果子类觉得父类的方法并不是自己要的，如何定义自己的方法呢?
   *  1.override 重写
   *  2.super  在子类内部，通过super来访问父类
   */
  class Animal() {
    def eating(): Unit = {
      println("Animal eating")
    }
  }

  // Dog 继承了 Animal
  class Dog extends Animal() {
    // 在子类中重写(覆盖)父类的方法
    override def eating(): Unit = {
      // 调用父类的方法？
      // 在子类内部，通过super来访问父类
      println("我是狗，我有自己的吃饭的方式！")
    }
  }

  def main(args: Array[String]): Unit = {
    val dog1 = new Dog()
    dog1.eating() // 调用自己的eating方法
  }
}

（四）继承与多态

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

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

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

package level02

object M07 {

  /*
   * 面向对象的编程语言有三大特性:封装，继承，多态
   *
   * 多态：同一个操作，作用于不同的对象，有不同的执行结果
   *
   */

  class Animal() {
    def eating(): Unit = {
      println("Animal eating")
    }
  }

  // Dog 继承了 Animal
  class Dog extends Animal() {
    override def eating(): Unit = {
      println("我是狗，我吃骨头大口咀嚼")
    }
  }

  // Cat 继承了 Animal
  class Cat extends Animal() {
    override def eating(): Unit = {
      println("我是猫，我吃小鱼小口口吃")
    }
  }

  // 测试函数
  // 它的参数类型是 父类
  def test(animal: Animal): Unit = {
    animal.eating()
  }

  def main(args: Array[String]): Unit = {
    val cat = new Cat()
    val dog = new Dog()

    test(cat)
    test(dog)
  }
}

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

（五）处理构造器的调用顺序

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

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

package level02

object M08 {
  /*
   * 存在继承关系的时候，构造器的调用顺序？
   * 父类构造器 → 子类构造器
   */
  class Animal() {
    println("父类构造器调用......")
  }

  // Dog 继承了 Animal
  class Dog extends Animal() {
    println("子类:Dog 构造器调用......")
  }

  // Puppy 继承了 Dog
  class Puppy extends Dog() {
    println("子类:Puppy 构造器调用......")
  }

  def main(args: Array[String]): Unit = {
    new Puppy(); // new会自动调用构造器去生成对象
  }
}