BigData-Notes/notes/Scala继承和特质.md
2019-05-10 14:12:55 +08:00

12 KiB
Raw Blame History

继承和特质

一、继承
        1.1 Scala中的继承结构
        1.2 extends & override
        1.3 调用超类构造器
        1.4 类型检查和转换
        1.5 构造顺序和提前定义
二、抽象类
三、特质
        3.1 trait & with
        3.2 特质中的字段
        3.3 带有特质的对象
        3.4 特质构造顺序

一、继承

1.1 Scala中的继承结构

scala中继承关系如下图

  • Any是整个继承关系的根节点
  • AnyRef包含Scala Classes和Java Classes等价于Java中的java.lang.Object
  • AnyVal是所有值类型的一个标记
  • Null是所有引用类型的子类型唯一实例是null可以将null赋值给除了值类型外的所有类型的变量;
  • Nothing是所有类型的子类型。

1.2 extends & override

Scala的集成机制和Java有很多相似之处比如都使用extends 关键字表示继承,都使用override关键字表示重写父类的方法或成员变量。下面给出一个Scala继承的示例

//父类
class Person {


  var name = ""

  // 1.不加任何修饰词,默认为public,能被子类和外部访问
  var age = 0

  // 2.使用protected修饰的变量能子类访问但是不能被外部访问
  protected var birthday = ""

  // 3.使用private修饰的变量不能被子类和外部访问
  private var sex = ""


  def setSex(sex: String): Unit = {
    this.sex = sex
  }

  // 4.重写父类的方法建议使用override关键字修饰
  override def toString: String = name + ":" + age + ":" + birthday + ":" + sex

}

使用extends关键字实现继承:

// 1.使用extends关键字实现继承
class Employee extends Person {

  override def toString: String = "Employee~" + super.toString

  // 2.使用public或protected关键字修饰的变量能被子类访问
  def setBirthday(date: String): Unit = {
    birthday = date
  }

}

测试继承:


object ScalaApp extends App {

  val employee = new Employee

  employee.name = "heibaiying"
  employee.age = 20
  employee.setBirthday("2019-03-05")
  employee.setSex("男")

  println(employee)
}

// 输出: Employee~heibaiying:20:2019-03-05:男

1.3 调用超类构造器

在Scala的类中每个辅助构造器都必须首先调用其他构造器或主构造器这样就导致了子类的辅助构造器永远无法直接调用超类的构造器只有主构造器才能调用超类的构造器。所以想要调用超类的构造器代码示例如下

class Employee(name:String,age:Int,salary:Double) extends Person(name:String,age:Int) {
    .....
}

1.4 类型检查和转换

想要实现类检查可以使用isInstanceOf,判断一个实例是否来源于某个类或者其子类,如果是,则可以使用asInstanceOf进行强制类型转换。

object ScalaApp extends App {

  val employee = new Employee
  val person = new Person

  // 1. 判断一个实例是否来源于某个类或者其子类 输出 true 
  println(employee.isInstanceOf[Person])
  println(person.isInstanceOf[Person])

  // 2. 强制类型转换
  var p: Person = employee.asInstanceOf[Person]

  // 3. 判断一个实例是否来源于某个类(而不是其子类)
  println(employee.getClass == classOf[Employee])

}

1.5 构造顺序和提前定义

1. 构造顺序

在Scala中还有一个需要注意的问题如果你在子类中重写父类的val变量并且超类的构造器中使用了该变量那么可能会产生不可预期的错误。下面给出一个示例

// 父类
class Person {
  println("父类的默认构造器")
  val range: Int = 10
  val array: Array[Int] = new Array[Int](range)
}

//子类
class Employee extends Person {
  println("子类的默认构造器")
  override val range = 2
}

//测试
object ScalaApp extends App {
  val employee = new Employee
  println(employee.array.mkString("(", ",", ")"))

}

这里初始化array用到了变量range这里你会发现实际上array既不会被初始化Array(10)也不会被初始化为Array(2),实际的输出应该如下:

父类的默认构造器
子类的默认构造器
()

实际上array被初始化为Array(0),原因在于父类的构造器的执行先于子类的构造器,这里给出实际的执行步骤:

  1. 父类的构造器被调用,执行new Array[Int](range)语句;
  2. 这里想要得到range的值会去调用子类range()方法,因为override val 重写变量的同时也重写了其get方法
  3. 调用子类的range()方法自然也是返回子类的range值但是由于子类的构造器还没有执行这也就意味着对range赋值的range = 2语句还没有被执行所以自然返回range的默认值也就是0。

这里可能比较疑惑的是为什么val range = 2没有被执行却能使用range变量这里因为在虚拟机层面是先对成员变量先分配存储空间并赋给默认值之后才赋予给定的值。想要证明这一点其实也比较简单代码如下:

class Person {
  // val range: Int = 10 正常代码 array为Array(10)
  val array: Array[Int] = new Array[Int](range)
  val range: Int = 10  //如果把变量的声明放在使用之后此时数据array为array(0)
}

object Person {
  def main(args: Array[String]): Unit = {
    val person = new Person
    println(person.array.mkString("(", ",", ")"))
  }
}

2. 提前定义

想要解决上面的问题,有以下几种方法:

(1) . 将变量用final修饰代表不允许被子类重写final val range: Int = 10

(2) . 将变量使用lazy修饰代表懒加载即只有当你实际使用到array时候才去进行初始化

lazy val array: Array[Int] = new Array[Int](range)

(3) . 采用提前定义代码如下代表range的定义优先于超类构造器。

class Employee extends {
  //这里不能定义其他方法
  override val range = 2
} with Person {
  // 定义其他变量或者方法
  def pr(): Unit = {println("Employee")}
}

但是这种语法也有其限制:你只能在上面代码块中重写已有的变量,而不能定义新的变量和方法,定义新的变量和方法只能写在下面代码块中。

注意事项:不仅是类的继承存在这个问题,后文介绍的特质(trait)的继承也存在这个问题,也同样可以通过提前定义来解决。即便可以通过多种方法解决该问题,但还是建议合理设计继承以规避此类问题。

二、抽象类

Scala中允许使用abstract定义抽象类,并且通过extends关键字继承它。

定义抽象类:

abstract class Person {
  // 1.定义字段
  var name: String
  val age: Int

  // 2.定义抽象方法
  def geDetail: String

  // 3. scala的抽象类允许定义具体方法
  def print(): Unit = {
    println("抽象类中的默认方法")
  }
}

继承抽象类:

class Employee extends Person {
  // 覆盖抽象类中变量
  override var name: String = "employee"
  override val age: Int = 12

  // 覆盖抽象方法
  def geDetail: String = name + ":" + age
}

三、特质

3.1 trait & with

Scala中没有interface这个关键字想要实现类似的功能可以使用特质(trait)。trait等价于Java 8中的接口因为trait中既能定义抽象方法也能定义具体方法这和Java 8中的接口是类似的。

// 1.特质使用trait关键字修饰
trait Logger {

  // 2.定义抽象方法
  def log(msg: String)

  // 3.定义具体方法
  def logInfo(msg: String): Unit = {
    println("INFO:" + msg)
  }
}

想要使用特质,需要使用extends关键字,而不是implements关键字,如果想要添加多个特质,可以使用with关键字。

// 1.使用extends关键字,而不是implements,如果想要添加多个特质可以使用with关键字
class ConsoleLogger extends Logger with Serializable with Cloneable {

  // 2. 实现特质中的抽象方法
  def log(msg: String): Unit = {
    println("CONSOLE:" + msg)
  }
}

3.2 特质中的字段

和方法一样,特质中的字段可以是抽象的,也可以是具体的:

  • 如果是抽象字段,则混入特质的类需要重写覆盖该字段;
  • 如果是具体字段,则混入特质的类获得该字段,但是并非是通过继承关系得到,而是在编译时候,简单将该字段加入到子类。
trait Logger {
  // 抽象字段
  var LogLevel:String
  // 具体字段
  var LogType = "FILE"
}

覆盖抽象字段:

class InfoLogger extends Logger {
  // 覆盖抽象字段
  override var LogLevel: String = "INFO"
}

3.3 带有特质的对象

Scala支持在类定义的时混入父类trait,而在类实例化为具体对象的时候指明其实际使用的子类trait。下面给出一个示例:

trait Logger

// 父类
trait Logger {
  // 定义空方法 日志打印
  def log(msg: String) {}
}

trait ErrorLogger

// 错误日志打印继承自Logger
trait ErrorLogger extends Logger {
  // 覆盖空方法
  override def log(msg: String): Unit = {
    println("Error:" + msg)
  }
}

trait InfoLogger

// 通知日志打印继承自Logger
trait InfoLogger extends Logger {

  // 覆盖空方法
  override def log(msg: String): Unit = {
    println("INFO:" + msg)
  }
}

具体的使用类:

// 混入trait Logger
class Person extends Logger {
  // 调用定义的抽象方法
  def printDetail(detail: String): Unit = {
    log(detail)
  }
}

这里通过main方法来测试

object ScalaApp extends App {

  // 使用with指明需要具体使用的trait  
  val person01 = new Person with InfoLogger
  val person02 = new Person with ErrorLogger
  val person03 = new  Person with InfoLogger with ErrorLogger
  person01.log("scala")  //输出 INFO:scala
  person02.log("scala")  //输出 Error:scala
  person03.log("scala")  //输出 Error:scala

}

这里前面两个输出比较明显,因为只指明了一个具体的trait ,这里需要说明的是第三个输出,因为trait的调用是由右到左开始生效的,所以这里打印出Error:scala

3.4 特质构造顺序

trait有默认的无参构造器,但是不支持有参构造器。一个类混入多个特质后初始化顺序应该如下:

// 示例
class Employee extends Person with InfoLogger with ErrorLogger {...}
  1. 超类首先被构造(Person构造器执行)
  2. 特质的构造器在超类构造器之前,在类构造器之后;特质由左到右被构造;每个特质中,父特质首先被构造;
    • Logger构造器执行(Logger是InfoLogger的父类)
    • InfoLogger构造器执行
    • ErrorLogger构造器执行;
  3. 所有超类和特质构造完毕,子类才会被构造。

参考资料

  1. Martin Odersky . Scala编程(第3版)[M] . 电子工业出版社 . 2018-1-1
  2. 凯.S.霍斯特曼 . 快学Scala(第2版)[M] . 电子工业出版社 . 2017-7