scala中的继承

1. 继承：是面向对象开发语言中的一个概念，继承可以使得子类具有父类的属性和方法或者重新定义、追加属性和方法等
2. 如果一个类别A“继承自”另一个类别B，就把这个A称为“B的子类别”，而把B称为“A的父类别”也可以称“B是A的超类”
3. 继承作用：可以使得子类别具有父类别的各种属性和方法，而不需要再次编写相同的代码，可以有效复用代码
4. 在子类别继承父类别的同时，可以重新定义某些属性，并重写某些方法，即覆盖父类别的原有属性和方法，使其获得与父类别不同的功能
5. 在子类别继承父类别的同时，还可以定义子类特有的字段和方法
6. 父类定义一般的属性和方法（可以理解为是所有子类共有的），而子类拥有其更加具体的成员（属性和方法）
7. final修饰的 class无法被继承，final修饰的field和method是无法被覆盖的

继承中的关键字

extends

1. 用extends关键字来实现继承
2. 继承的语法： 如A类继承B类
   1. class A类 extends B类{ }    其中A类是子类，B类是父类

    class Person {
      private val name = "Weiking"
      def getName = name
    }
    class Student extends Person {
      def getAge= 26
    }
    object test{
      def main(args: Array[String]): Unit = {
        val stu=new Student
        printf(stu.getName,stu.getAge)
      }
    }

 override与super

1. override:子类覆盖父类中的非抽象成员（字段和方法），必须使用override关键字
2. super：子类覆盖父类方法之后，要调用父类中被覆盖的方法，要使用super关键字，显式地指定要调用父类的方法，无法通过super调用父类中的字段

 class Person1 {
      val age = 48
      def getName = "Weiking"
    }
    class Student1 extends Person1 {
      override val age = 20
      override def getName="jack"    // 重写父类方法
      def ParentMember =println("我父亲的名字是 "+ super.getName,"我父亲今年"+super.age)  //super调用父类的方法getName可以，调用父类的字段age就会报错
      def selfMember =println("我的名字是 "+ getName,"我今年"+age)
    }
    object test{
      def main(args: Array[String]): Unit = {
        val stu=new Student1
        stu.ParentMember   //Error:(19, 73) super may be not be used on value age
        stu.selfMember
      }
    }

数据类型的向上转型和向下转型

1. 解决的问题：创建了子类的对象，但赋予了父类类型，需要将父类类型转换为子类的类型
2. 子类转换为父类可以直接转换，父类转换为子类则需要先判断是是否是该子类

isInstanceOf和asInstanceOf

1. isInStanceOf：用来判断对象是否是指定类的对象
   1. 用法：对象名.isInStanceOf[l类名]

   2. person.isInstanceOf[Person]

2. asInstanceOf :将对象转换为指定类型
   1. 对象名.asInstanceOf[l类名]

   2. person.asInstanceOf[Student]

class Person{}
class Student extends Person{}

object Test {
  def main(args: Array[String]): Unit = {
  val person =new Student
  println(person.isInstanceOf[Person])
    println(person.isInstanceOf[Student])
if (person.isInstanceOf[Student]){
  val stu =person.asInstanceOf[Student]

}

注意1：isInstanceOf新版本已被弃用改用模式匹配

注意2：如果对象是null，则isInstanceOf一定返回false，asInstanceOf一定返回null

class Person{}
class Student extends Person{}

object Test {
  def main(args: Array[String]): Unit = {
    val p: Person =  new Student
    var s: Student = null
    println(p.isInstanceOf[Student])
    println(s.isInstanceOf[Student])

    println(s.asInstanceOf[Student])
 }
}

模式匹配

1. 模式匹配的功能上面和isInstanceOf功能一样，不过更加好用

class Person{}
class Student extends Person{}
class Teacher extends Person{}
object Test {
  def main(args: Array[String]): Unit = {
    val p: Person = new Student
    p match {
      case pe: Teacher  => println("person对象")
      case stu: Student => println("student对象")
    }
  }
}

getclass与classof

1. getclass：可以精确的获取对象的类
2. classOf：可以精确的获取类

class Person{}
class Student extends Person{}
object Test {
  def main(args: Array[String]): Unit = {
    val person: Person = new Student
    val ob: Class[_ <: Person] = person.getClass
    val cla: Class[Student] = classOf[Student]
    if (person.getClass == classOf[Person]) println("True") else println("false") 
    if (person.getClass == classOf[Student]) println("True") else println("false")
    if(1.getClass==classOf[Int]) println("True") else println("false")
  }
}