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 }

转载于:https://www.cnblogs.com/cenzhongman/p/7458959.html