Scala 的继承与多态

1.1Scala的继承概述

  下面通过介绍继承的定义、优点以及相关语法来说明Scala中的继承特点。Scala中的继承与Java中的继承十分相似，这有助于我们进一步了解Scala的继承。

1.继承的定义

  关于继承，Java中也有相关概念，Scala中继承的定义为在原有类的基础上定义一个新类，原有类称为父类，新类称为子类。 

2.继承的好处

  继承可以复用代码和实现多态。继承就代表子类可以继承父类的特性并且子类可以在自己内部实现类没有的特性，以实现代码的复用和多态特性。 

3.继承的语法

  在Scala中，子类继承父类使用关键字extends，这一点与Java相同。假设定义Parents为父类， C1为子类，通过关键字extends 子类便可以继承父类的特性，相关代码为:

class C1 extends Parents{
}

class Animal(){
  var leg = 4
  def run(): Unit = {
    println("animal run......")
  }
}

//继承 不劳而获
class Dog extends Animal(){

}

object Test17 {
  def main(args: Array[String]): Unit = {
    //实例化一个对象：new 一个对象
//    var a1 = new Animal()
//    a1.run()

    var d1 = new Dog()
    d1.run()
  }
}

1.2构造器

  下面介绍父类构造器的基础知识和语法规则以及辅助构造器的调用规则，然后结合相关案例进一步说明继承和构造器调用的应用。 

1.调用父类构造器语法

通过之前对Scala继承关系的了解，下面介绍有关父类构造器的知识。调用父类构造器的语法为：

class Dog(name:String,age:Int) extends Animal(name,age)

  从调用父类构造器的语法中可以看出定义类的同时也调用了一个构造器，并通过extends关键字在表明继承关系的同时，也明确了调用类中的哪一个构造器。

2.辅助构造器调用

辅助构造器调用规则如下:

  第一条规则:父类的辅助构造器可以被子类的主构造器调用。假设父类A有一个名为name的构造器，同时类的内部有一个无参的构造器。子类A1继承自A，则A1可以调用父类中的无参构造器，即父类的辅助构造器。

  第二条规则:父类的辅助构造器不能被子类的辅助构造器调用。如果子类A1中有一个无参的构造器，那么这个构造器不可以像Java中一样使用super调用父类的辅助构造器。

相关代码如下：

class Animal(var name:String,var age:Int){
  println(s"父类-构造器Animal正在运行...${name} ${age}")
  var leg = 4
  def run(): Unit = {
    println("animal run......")
  }
}

//继承 不劳而获
class Dog(name:String,age:Int) extends Animal(name, age){
  println(s"子类-构造器Animal正在运行...${name} ${age}")
  leg = 3//对于 var修饰父类的属性，可以直接覆盖

  //用override 重写（覆盖）父类的同名的方法
  override def run(): Unit ={
    println(s"${leg}条腿的 Dog run.....")
  }
}

object Test17 {
  def main(args: Array[String]): Unit = {
    //实例化一个对象：new 一个对象
//    var a1 = new Animal("小黑",1)
//    var a1 = new Animal()
//    a1.run()

    var d1 = new Dog("小黑",1)
//    var d1 = new Dog()
//    d1.run()
  }
}

1.3 Scala的多态概述

  下面从多态的含义、作用以及多态的实现手段介绍Scala的多态。同一操作作用于不同的对象，可以有不同的解释，产生不同的执行结果，这就是多态性。Scala的多态与Java中的相关概念相似。

1.多态的定义

  从编译的角度解释Scala的多态含义:在执行期间而非编译期间确定所引用对象的类型，根据实际类型调用其方法。一个编译型的语言有两种类型，分别为编译类型和运行类型。程序中定义的引用变最所指向的具体类型和通过该变量发出的方法调用在编译时并不确定，而是在程序运行期间才确定的。 

2.多态的作用

  当子类继承父类时，不同的子类需要实现自己的行为。Scala多态的这种特性可以提高程序的可扩充性和可维护性，提高代码的复用率。 

3.多态的实现手段

  多态通过重写实现。重写要求名称和参数列表相同，这种特性与Java中的相同。子类对父类中的某些方法进行重新定义，在调用这些方法时就会调用子类的方法。 

5.1.4 方法的继承和重写

  下面通过介绍方法的继承和方法的重写进一步说明Scala中子类继承父类的特性，结合Scala的多态相关案例详细说明方法的继承和多态。 

1.方法的继承

  Scala中子类继承父类表示同时继承了父类的所有功能，包括父类的方法。子类可以调用从父类继承过来的方法，这种方式使程序得以扩充，程序代码得以复用。 

2.方法的重写

  当子类继承父类，并且从父类继承的方法不能满足要求时，子类需要有自己的行为。当需要对一个类的方法新增功能时，一般不要修改原有的类，而是通过创建一个子类继承父类的所有功能，在里面使用方法重写一些新的功能。 

3.方法重写语法

  在Scala中通过override关键字实现方法重写。Java中重写关键字可以省略而Scala中的override 关键字不可以省略，例如重写一个方法:overridea()={方法体}。

相关代码如下：

class Animal(){
  var name = ""
  def run(): Unit = {
    println("animal run......")
  }
}

//继承 不劳而获
class Dog extends Animal(){
  override def run(): Unit ={
    println("dog is running...")
  }

}

class Cat extends Animal(){
  override def run(): Unit = {
    println("cat is running...")
  }
}

object Test17 {
  def main(args: Array[String]): Unit = {
    var d1 = new Dog()
    var c1 = new Cat()
//    d1.run() 多态：
    //定义函数： 一个函数的参数是一个对象，对象的类型是父类类型
    //调用函数： 传入子类的实例
    run(d1)
    run(c1)
  }
  def run(obj:Animal): Unit ={
    obj.run()
  }
}