20类的继承（一）继承的概念和基本语法定义:在原有类的基础上定义一个新类，原有类称为父类，新类称为子类。 class

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

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

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

好处:复用代码和实现多态。复用代码：子类可以继承父类的特性。多态：子类可以在自己内部实现父类没有的特性。

假设定义Parents为父类，C1为子类，通过关键字extends子类便可以继承父类的特性，相关代码为：

class C1(参数可选) extends Parents(参数可选){ }

package level02
/**
 * 1. 类和对象（一个类Class，多个对象）
 * 2. new 创造对象，new XXXX()
 * 3. 构造函数，构造器
 * 4. 辅助构造器 this
 * 5. private, override, toString, equals, this
 * 6. apply 单例模式
 * 7. 伴生类 伴生对象
 * 8. 多个类之间的关系：继承
 *  狂飙
 *      高启强  马保国
 *  好处：不劳而获。
 *
 *   重写：子类对父类的同名方法进行重写！
 */
object Class12 {

    class Boss {
      def test(): Unit = {}
      def power(): Unit = {
        println("boss 有权力......")
      }
      var car = "豪车"
    }

    // 子类   继承  父类
    class NoBody extends Boss {
      // 子类自己的方法，与父类的方法不同名
      def run(): Unit = {}
      override def power(): Unit = {
        println("老弟，我想吃鱼了")
      }
    }

    def main(args: Array[String]): Unit = {
      val b = new NoBody()
      println(b.car)
      b.power()
      b.run()
    }

}

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

继承的特点：Dog就直接具备了animal的功能eating。

类图-图示

（三）继承的方法重写

格式：

override def 方法名(参数可选) { }

object Class14 {
  // 父类
  class Dog(var name:String, var age:Int) {
    println(s"Dog ${name}, ${age} 构造器被调用")
  }

  // 子类 中华田园犬
  // 子类带构造器
  // 1. 继承父类的属性，不用写 val、var 修饰符
  // 2. 自己的新属性，加上var、val修饰符
  // 父类构造器
  // 直接传入参数，不用写属性的类型
  class RuralDog(name:String, age:Int, var color:String) extends Dog(name, age) {
    println(s"RuralDog 构造器...${color}")
  }

  def main(args: Array[String]): Unit = {
    var dog1 = new RuralDog("旺财", 3, "土黄色")
  }
}

说明：在子类的内部，使用super来访问父类

（四）继承与多态

面向对象的三个特点：_封装继承多态。同一操作作用于不同的对象，可以有不同的解释，产生不同的执行结果，这就是多态性。

（五）构造器的调用顺序

package level02
/**
 * 1. 类和对象（一个类Class，多个对象）
 * 2. new 创造对象，new XXXX()
 * 3. 构造函数，构造器
 * 4. 辅助构造器 this
 * 5. private, override, toString, equals, this
 * 6. apply 单例模式
 * 7. 伴生类 伴生对象
 * 8. 多个类之间的关系：继承
 *  狂飙
 *      高启强  马保国
 *  好处：不劳而获。
 *
 *   重写：子类对父类的同名方法进行重写！
 */
object Class12 {

    class Boss {
      def test(): Unit = {}
      def power(): Unit = {
        println("boss 有权力......")
      }
      var car = "豪车"
    }

    // 子类   继承  父类
    class NoBody extends Boss {
      // 子类自己的方法，与父类的方法不同名
      def run(): Unit = {}
      override def power(): Unit = {
        println("老弟，我想吃鱼了")
      }
    }

    def main(args: Array[String]): Unit = {
      val b = new NoBody()
      println(b.car)
      b.power()
      b.run()
    }

}

（六）带参构造器的写法

要点如下：

1. 父类构造器正常写。

2. 在写子类构造器时：

（1）如果某个属性可以从父类中继承过来，那么这些属性就不要添加任何的修饰符(val,var都不加)如果这属性是子类自己特有的，就需要补充修饰符；

（2）在父类构造器时，直接传入对应的参数。

package level02
/*
1. 类和对象（一个类Class，多个对象）
2. new 创造对象，new XXXX()
3. 构造函数，构造器
4. 辅助构造器 this
5. private, override, toString, equals, this
6. apply 单例模式
7. 伴生类 伴生对象

8. 多个类之间的关系：继承
    狂飙
        高启强 马保国
    好处：不劳而获。
    重写：子类对父类的同名方法进行重写！
父类和子类的构造器调用顺序：先调用父类的构造器，再调用子类的构造器
带参构造器
*/
object Class14 {
  // 父类
  class Dog(var name: String, var age: Int) {
    println(s"Dog ${name} ${age} 构造器被调用")
  }

  // 子类 中华田园犬
  // 子类带参构造器
  // 1. 继承父类的属性。不用写 val, var 修饰符
  // 父类构造器
  // 直接传入参数，不用写属性的类型
  class RuralDog(name: String, age: Int) extends Dog(name, age) {
    println("RuralDog的构造器...")
  }

  def main(args: Array[String]): Unit = {
    new RuralDog("旺财", 3)
  }
}

说明：

1. class Dog（）中，参数name,age不需要添加var或者val。因为它继承Animal，所以它本身就有name,age属性。而weight需要添加var，它是子类的自己的属性。

2. Animal(name,age) 中， name, age的前面都没有添加修饰符。在子类构造函数调用的时候，就会执行这个函数，并进行参数传递。

20类的继承