继承函数（class子类和extends 父类）

继承

1.多个类

class子类 extends 父类

好处，不劳而获。子类可以直接使用父类的属性和方法

eg:

/*多个类
*继承
*class子类 extends 父类
*
*/

object class08 {
  def main(args: Array[String]): Unit = {
    //动物
    class Animal() {
      def eat(): Unit = {
        println("animal eat......")
      }
    }
    class Dog() extends Animal {

    }
    def main(args: Array[String]): Unit = {
      val dog = new Dog()
      dog.eat()
    }
  }
}

2.子类对父类的方法——重写

eg:

object class09 {
  class Parent {
    def run(): Unit = {
      println("run.....")
    }
  }
  class Son extends Parent {
    //如果希望对父亲的方法进行更改： 觉得不好
    def run1 ():Unit = {}

    override def run(): Unit = {
      println("开自动驾驶的车 run...")
    }
  }
  def main(args: Array[String]): Unit = {
    val s1 = new Son()
    s1.run()
  }
}

3.super 在子类中访问父亲

eg:

object class09 {
  class Parent() {
    val name:String = ""
    def run(): Unit = {
      println("run.....")
    }
  }
  class Son extends Parent {
    //如果希望对父亲的方法进行更改： 觉得不好
    def run1 ():Unit = {}

    override def run(): Unit = {
      super.run()//super.run 在子类中，调用父亲的方法
      println("开自动驾驶的车 run...")
    }
  }
  def main(args: Array[String]): Unit = {
    val s1 = new Son()
    s1.run()
  }
}

4.面向对象编程的三大特征

封装，继承，多态

object class10 {
  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)
  }
}

5.构造器的调用顺序

先调用父类，后调用子类

eg1:

object class11 {
  class Father {
    println("Father 的构造器....")
  }

  class Son extends Father {
    println("Son 的构造器....")
  }

  def main(args: Array[String]): Unit = {
    //创建一个子类对象时，
    //先调用父类的构造器→子类的构造器
    new Son()
  }
}

eg2:

object class12 {
  //父亲
  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 = {
      println(s"狗狗.....,我的颜色是${color}")
    }
  }

  def main(args: Array[String]): Unit = {
    val d1 = new Dog("旺财", 1, "黑色")
    d1.say()
  }
/*
父亲的构造器被调用....旺财，1
子类的构造器被调用....旺财，1，黑色
Animal 旺财，1
狗狗...... ,我的颜色是黑色

 */

}