继承与多态

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

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

*  继承
*  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() // 直接可以使用父类的方法

问题

问题：
*    如果子类觉得父亲的方法并不是自己要的，如何定义自己的方法呢？
*    1.override 重写
*    2.supeer 在子类内部，通过super来访问父亲
 */
class Animal() {
  def run(): Unit = {
  }

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

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

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

多态

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

*  面向对象的编程语言有三大特性： 封装，继承，多态
*
*  多态：同一个操作，作用于不同的对象，有不同的执行结果
 */
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)

存在继承时的关系

class Animal() {
  println("父亲构造器被调用.....")

}

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


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

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