动态绑定
    Scala 中属性和方法都是动态绑定，而 Java 中只有方法为动态绑定。

    1. // 定义一个父类
    2. class Person7() {
    3.   var name: String = _
    4.   var age: Int = _
    6.   println("1. 父类的主构造器调用")
    8.   def this(name: String, age: Int){
    9.     this()
    10.     println("2. 父类的辅助构造器调用")
    11.     this.name = name
    12.     this.age = age
    13.   }
    15.   def printInfo(): Unit = {
    16.     println(s"Person: $name $age")
    17.   }
    19.   //可以多态
    20.   def printInfo(person7: Person7): Unit = {
    21.     println("Person: " + person7.printInfo())
    22.   }
    23. }
    25. // 定义子类
    26. class Student7(name: String, age: Int) extends Person7(name, age) {
    27.   var stdNo: String = _
    29.   println("3. 子类的主构造器调用")
    31.   def this(name: String, age: Int, stdNo: String){
    32.     this(name, age)
    33.     println("4. 子类的辅助构造器调用")
    34.     this.stdNo = stdNo
    35.   }
    37.   override def printInfo(): Unit = {
    38.     println(s"Student: $name $age $stdNo")
    39.   }
    40. }
    43. class Teacher extends Person7 {
    44.   override def printInfo(): Unit = {
    45.     println(s"Teacher")
    46.   }
    47. }

    调用

    1. val person = new Person7()
    2. val student = new Student7("abc", 11)
    3. val teacher = new Teacher()
    4. println("=======================")
    5. person.printInfo(student)
    7. /**
    8. 输出
    9. 1. 父类的主构造器调用
    10. 2. 父类的辅助构造器调用
    11. 3. 子类的主构造器调用
    12. 1. 父类的主构造器调用
    13. =======================
    14. Student: abc 11 null
    15. Person: ()
    16. */

    动态绑定

    1. val person = new Student7("abc", 11)
    2. println("=======================")
    3. person.printInfo()
    4. println(person.name)
    6. /**
    7. 1. 父类的主构造器调用
    8. 2. 父类的辅助构造器调用
    9. 3. 子类的主构造器调用
    10. =======================
    11. Student: abc 11 null
    12. */