Scala继承

override重写

• 为何要用override关键字？由于这样更清楚，不容易出错，好比打错字了，就没覆盖成功，可是不会报错
• override能够覆盖feild和method

class Person{
    private val name = "CZM"
    def getName = name
}

class Student extends Person{
    private val score = "A"
    def getScore = score
    override def getName = "My name is "+super.getName      //重写须要使用关键字override声明。若是父类定义为final则不可重写
}

val s1 = new Student
s1.getScore
s1.getName

isInstanceOf和asInstanceOf:多态判断

• 在多态的转换中，会把子类对象赋值给父类变量，若是遇到须要把原本是子类的对象变回子类怎么实现？
• isInstanceOf用于判断是不是指定类的对象
• asInstanceOf用于将对象转换成指定类型

//接上文代码

//旧API,这个并不能精准判断
val p1:Person = new Student
if (p1.isInstanceOf[Student]){
  val s1:Student = p1.asInstanceOf[Student]     //p1的本质是没有改变的，返回一个clone的对象
  s1.getScore //若是不转换，这个学生就失去了这个方法
}

//新API，非精准判断
p1 match {
  case _: Student =>
    p1.asInstanceOf[Student]
    p1
  case _ =>
}

getClass和classOf:精准判断

val p1: Person = new Student
val s1 = new Student
p1.getClass == classOf[Student]     //false
p1.getClass == classOf[Person]      //true

protected关键字

除了private以外，scala还提供和了protect关键字，子类访问权限

• private[this]：出了本身的{ }就不认可了，就好比说一我的有病，只有本身知道，在外人看来是不存在的，儿子也不知道
• protected[this]：出了本身和儿子的{ }就不认可了，就好比说一我的有病，只有本身和儿子知道，在外人看来是不存在的，儿子不会告诉别人的儿子

class Person() {
  protected[this] val name = "CZM"    def getName = name }

class Student extends Person {
  private val score = "A"    def getScore = score    def makeFriend(s: Student): Unit = {
    println("My name is " + name + " , I'm " + s.name + " is friend!")      //在本身家能够调用name，没法调用s.name至关于本身儿子去了别人家
  }
}

val s1 = new Student
val s2 = new Student
s1.makeFriend(s2)

调用父类constructor

• 为何调用父类构造函数这么奇葩？ 由于子类constructor第一行必须调用主constructor或者其余辅助constructor
• 为何不用super(...)? 由于没有

//父类，定义了两个constructor
class Person(val name: String) {
  var age = 10    def getName = name

  def this(name: String, age: Int) {
    this(name)
    this.age = age
  }
}

//子类    定义本身的constructor(name:传值，age：重写父类中的age字段，score：定义本身的变量score) Person()这里就决定了调用哪个constructor
class Student(name: String, override val age: Int, val score: Double) extends Person(name) {

匿名内部类

• 匿名内部类：定义一个没有名称的某个类（接口）的子类，并立刻实例化new
• 匿名内部类自己没有构造器，可是会调用父类构造器
• 匿名内部类必须继承或实现一个接口，但最多只能一个父类或实现一个接口(JAVA == scala)

JAVA中的匿名内部类

new 父类构造器( ) 或  接口( )
{
    //todo
}

scala中的匿名内部类，跟JAVA没有一点区别

class Person(val name: String) {
  def sayHello = println("Person class " + name)
}

val p1 = new Person("CZM")    //p1是一个Person类的对象 
val p2 = new Person("leo") {  //p2是一个Person类的匿名子类的对象
  override def sayHello = println("new sun class " + name)
}

p1.sayHello
p2.sayHello

abstract抽象

• 子类覆盖抽象类的抽象方法能够不须要override，IDEA推荐仍是使用override
• 抽象类中容许有非抽象方法
• 没有implement关键字，依然使用extends
• 能够抽象field(须要在抽象类中)，编译在编译抽象类时，生成了getter和setter方法，可是父类中没有这个field

//抽象类和抽象方法
abstract class Person {
  def sayHello():Any
}

class student extends Person{
  override def sayHello() = ??? }

//抽象类和抽象field
abstract class Person {
  abstract val name:String }