Scala 类的继承

复习：

package levelo3

object class01 {
  // 动物
  class  Animal() {
    def eat():Unit={
      println("animal eat.......")
    }
  }

  class Dog() extends Animal(){

  }

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

}

结果：

继承

1

好处：不劳而获 子类可以直接使用父类的数学和方法

package levelo3

object class01 {
// 好处：不劳而获  子类可以直接使用父类的数学和方法

  // 动物
  class Animal(var name:String="动物") {
    val age:Int=10;

    def eat():Unit={
      println("animal eat.......")
    }
    def  run():Unit={
      println("animal run......")
    }
  }
  // 狗
  class  Dog() extends Animal(){

  }


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

结果：

继承的方法重写

代码：

package levelo3

object class02 {
  class Parent() {
    def run():Unit={
      println("run......")
    }
  }
  class  Son extends  Parent{

   // 如果希望对父亲的方法改进：觉得不好
   def run1():Unit={
     println("开始自动驾驶的车 run.......")
   }

    override  def run():Unit={
      println("开自动驾驶的车 run....")
    }
  }

  def main(args: Array[String]): Unit = {
    val s1 =new Son()
    s1.run()
  }
}

结果：

super语法：

代码：

package levelo3

object class02 {
  class Parent() {
    def run():Unit={
      println("run......")
    }
  }
  class  Son extends  Parent{

   // 如果希望对父亲的方法改进：觉得不好
   def run1():Unit={
     println("开始自动驾驶的车 run.......")
   }

    override  def run():Unit={

      super.run() //super.run在子类中，调用父类的方法
      println("开自动驾驶的车 run....")
    }
  }

  def main(args: Array[String]): Unit = {
    val s1 =new Son()
    s1.run()
  }
}

结果：

继承与多态

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

代码：

package levelo3

object class03 {
  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)

  }
}

结果：

处理构造器的调用顺序

代码演示：

package levelo3

import levelo3.class02.Son

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


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

  def main(args: Array[String]): Unit = {
    new Son()
  }
}

结果：

父类与子类构造器被调用

代码演示：

package levelo3

object class05 {
  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 colar:String) extends Animal(name, age){
    println(s"子类的构造器被调用........${name},${age},${colar}")
    override  def say():Unit={
      super.say()
      println(s"狗狗..... 我的颜色是${colar}")
    }
  }

  def main(args: Array[String]): Unit = {
    val d1 = new Dog("旺财",1,"黑色")
    d1.say()
  }
}

结果：