scala 继承

灰太狼 2022-05-19 01:49 98阅读 0赞

**继承**

抽象类：abstract class ，抽象类中可以有抽象字段、非抽象字段、抽象方法、非抽象方法。

重写抽象字段、抽象方法时，可以不带override关键字；重写非抽象字段、非抽象方法时，必须带override关键字；

abstract class Person2 {
      //抽象字段，不能用private关键字修饰，否则子类不能进行重写
      var name: String
      //具体字段
      val age: Int = 23
      //抽象方法
      def say(context: String)
      //具体方法
      def run: Unit = {
        println("跑步")
      }
    }
    
    class Student2 extends Person2 {
      //重写抽象字段，可以不加override，既可以用val,也可以用var修饰
      var name: String = "张三"
      //重写非抽象字段，必须带override
      override val age: Int = 30
      //子类重写父类的抽象方法，可以不用override关键字修饰
      def say(context: String): Unit = {
        println(context)
      }
      //子类重写父类的非抽象方法，必须要用override关键字修饰
      override def run = {
        println("跑步.....")
      }
    }
    
    object Per {
      def main(args: Array[String]): Unit = {
        val p = new Student2
        println(p.name)
        println(p.age)
        p.say("hello")
        p.run
      }
    }

**isInstanceOf & asInstanceOf，getClass & classOf\[\]比较**

isInstanceOf 判断一个对象是否是指定的类或其子类的实例，不能做精确判断

asInstanceOf 将对象转换成指定的类型，在使用前应先用isInstanceOf判断

如果要精确判断，可以使用getClass 和classOf\[\]进行判断

class Animal {
      def say = {
        println("hello")
      }
    }
    
    class Dog extends Animal {
      override def say = {
        println("汪汪汪")
      }
    }
    
    class Cat extends Animal {
      override def say = {
        println("喵喵喵")
      }
    }
    
    object ObjectDemo_08 {
      def main(args: Array[String]): Unit = {
        val dog = new Dog
        //isInstanceOf 判断一个对象是否是指定的类或其子类的实例，不能做精确判断
        if(dog.isInstanceOf[Animal]){
          //asInstanceOf 将对象转换成指定的类型，在使用前应先用isInstanceOf判断
          val d = dog.asInstanceOf[Animal]
          d.say
        }
        
        val cat = new Cat
        //如果要精确判断，可以使用getClass 和classOf[]进行判断
        println(cat.getClass == classOf[Cat])//true
      }
    }

**子类调用父类的构造函数**

\* 子类继承父类，在创建子类的对象时，一定是先初始化父类的构造函数，然后再执行子类的构造函数

class Person09(var name: String, var age: Int) {
      println("主构造器代码块")
      println(name + ":" + age)
    }
    //子类的构造函数与父类的构造函数中参数名字一样，那么子类中相同的参数名称，不能用任何关键字修饰，否则scala会认为子类重写父类的field
    class Student091(name: String, age: Int, var sex: String) extends Person09("小红", 24) {
      println("Student091构造代码块")
      println(name + ":" + age + ":" + sex)
    }
    class Student092(name: String, age: Int, var sex: String) extends Person09(name, age) {
      println("Student092构造代码块")
      println(name + ":" + age + ":" + sex)
    }
    
    object ObjectDemo09 {
      def main(args: Array[String]): Unit = {
        new Student091("小王", 23, "男")
        println("--------")
        new Student092("小张", 28, "女")
      }
    }
    运行结果：
    主构造器代码块
    小红:24
    Student091构造代码块
    小王:23:男
    --------
    主构造器代码块
    小张:28
    Student092构造代码块
    小张:28:女