//父类
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
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.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("(", ",", ")"))
}
这里想要得到 range 的值，会去调用子类 range() 方法，因为 override val 重写变量的同时也重写了其 get 方法；
调用子类的 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("(", ",", ")"))
}
}
1.5.2 提前定义
想要解决上面的问题，有以下几种方法：
(1) . 将变量用 final 修饰，代表不允许被子类重写，即 final val range: Int = 10；
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
}
// 混入 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
}
