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 }
posted @ 2017-08-31 16:28  岑忠满  阅读(158)  评论(0编辑  收藏  举报