（一）、继承的概念和基本语法
定义:在原有类的基础上定义一个新类，原有类称为父类，新类称为子类。class 子类名 extends 父类名 { 类体 }
好处:复用代码和实现多态。复用代码：子类可以继承父类的特性。多态 ： 子类可以在自己内部实现父类没有的特性。
（二）、继承的好处之复用代码
/** *
* 1.多个类
* 2.继承
* class 子类 extends 父亲
* 3.好处：不劳而获。子类可以直接使用父类的属性和方法
*/
object class09 {
//动物
class Aniaml(var name:String="动物") {
val age: Int = 10;
def eat(): Unit = {
println("animal eat......")
}
def run(): Unit = {
println("animal run......")
}
}
//狗
class Dog() extends Aniaml(){
}
def main(args: Array[String]): Unit = {
val d1 = new Dog()
d1.run()
d1.eat()
}
}
继承的特点：Dog就直接具备了animal的功能eating。
（三）、继承的方法重写
当子类从父类继承的方法不能满足需要时，子类需要有自己的行为，怎么办？此时使用使用 override 可以重写父类的方法。
/** *
* 1.多个类
* 2.继承
* class 子类 extends 父亲
* 3.好处：不劳而获。子类可以直接使用父类的属性和方法
* 4.子类对父亲的方法的 重写
* 在子类中，通过override 覆盖（重写）父亲的同名方法
* 5.super. 在子类中访问父亲
*/
object class10 {
class Parent(){
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()
}
}
代码说明：在子类的内部，使用super来访问父类
（四）、继承与多态
面向对象的三个特点：封装 继承 多态 。同一操作作用于不同的对象， 可以有不同的解释，产生不同的执行结果，这就是多态性。
/** *
* 1.多个类
* 2.继承
* class 子类 extends 父亲
* 3.好处：不劳而获。子类可以直接使用父类的属性和方法
* 4.子类对父亲的方法的 重写
* 在子类中，通过override 覆盖（重写）父亲的同名方法
* 5.super. 在子类中访问父亲
* 6.面向对象编程的三大特征：封装，继承，多态
*/
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)
}
}
（五）、处理构造器的调用顺序
代码验证调用顺序：父类的主构造器->子类主构造器->子类的辅助构造器
/** *
* 1.多个类
* 2.继承
* class 子类 extends 父亲
* 3.好处：不劳而获。子类可以直接使用父类的属性和方法
* 4.子类对父亲的方法的 重写
* 在子类中，通过override 覆盖（重写）父亲的同名方法
* 5.super. 在子类中访问父亲
* 6.面向对象编程的三大特征：封装，继承，多态
* 7.构造器的调用顺序：先调用父类的，再调用子类的
*/
object class12 {
class Father() {
println("Father 的构造器...")
}
class Son extends Father(){
println("Son 的构造器...")
}
def main(args: Array[String]): Unit = {
//创建一个子类对象时，
//先调用父亲的构造器 → 子类的构造器
new Son()
}
}
