大数据技术之_16_Scala学习_05_面向对象编程-中级

第七章 面向对象编程-中级7.1 包7.1.1 Java 中的包7.1.2 Scala 中的包7.1.3 Scala 包的特点概述7.1.4 Scala 包的命名7.1.5 Scala 会自动引入的常用包7.1.6 Scala 包注意事项和使用细节7.1.7 包对象7.1.8 包对象的底层实现机制分析(重点)7.1.9 包对象的注意事项7.2 包的可见性7.2.1 回顾 Java 包的可见性7.2.2 Scala 中包的可见性介绍7.2.3 Scala 中包的可见性和访问修饰符的使用7.3 包的引入7.3.1 Scala 引入包基本介绍7.3.2 Scala 引入包的细节和注意事项7.4 面向对象编程方法-抽象7.5 面向对象编程三大特征7.5.1 基本介绍7.5.2 封装的实现步骤7.5.3 快速入门案例7.5.4 Scala 封装的注意事项和细节7.6 面向对象编程方法-继承7.6.1 Java 继承的简单回顾7.6.2 Scala 的继承7.6.3 Scala 继承给编程带来的便利7.6.4 重写方法7.6.5 Scala 中类型检查和转换7.6.6 Java 中超类的构造7.6.7 Scala 中超类的构造7.6.8 覆写字段7.6.9 抽象类7.6.10 Scala 抽象类使用的注意事项和细节讨论7.6.11 匿名子类7.6.12 继承层级7.7 作业04

---

第七章 面向对象编程-中级

7.1 包

7.1.1 Java 中的包

看一个应用场景

回顾-Java 包的三大作用+打包命令+快速入门

示例代码如下：

package com.atguigu.chapter07.javapackage;

public class DogTest {
    public static void main(String[] args) {
        // 使用 xiaoming 的 Dog
        com.atguigu.chapter07.javapackage.xiaoming.Dog dog01 = new com.atguigu.chapter07.javapackage.xiaoming.Dog();
        // 使用 xiaoqiang 的 Dog
        com.atguigu.chapter07.javapackage.xiaoqiang.Dog dog02 = new com.atguigu.chapter07.javapackage.xiaoqiang.Dog();

        System.out.println("dog01=" + dog01 + "\ndao02=" + dog02);
    }
}

输出结果如下：

dog01=com.atguigu.chapter07.javapackage.xiaoming.Dog@12a3a380
dao02=com.atguigu.chapter07.javapackage.xiaoqiang.Dog@29453f44

回顾-Java 如何引入包+Java 包的特点

java 包 和 类源码文件路径、包文件路径、.class 文件路径 的关系图

7.1.2 Scala 中的包

Scala 包的基本介绍+快速入门

示例代码如下：

package com.atguigu.chapter07.scalapackage

object CatTest {
  def main(args: Array[String]): Unit = {
    // 使用 xiaoming 的 Cat
    var cat01 = new com.atguigu.chapter07.scalapackage.xiaoming.Cat
    println("cat01=" + cat01)

    // 使用 xiaoming 的 Cat
    var cat02 = new com.atguigu.chapter07.scalapackage.xiaoqiang.Cat
    println("cat02=" + cat02)
  }
}

输出结果如下：

cat01=com.atguigu.chapter07.scalapackage.xiaoming.Cat@1fbc7afb
cat02=com.atguigu.chapter07.scalapackage.xiaoqiang.Cat@7dc36524

7.1.3 Scala 包的特点概述

scala 包 和 类源码文件路径、包文件路径、.class 文件路径 的关系图

7.1.4 Scala 包的命名

7.1.5 Scala 会自动引入的常用包

7.1.6 Scala 包注意事项和使用细节

1、scala 进行 package 打包时，可以有如下形式。【案例演示+反编译查看】

第三种打包方式示例代码如下：

// 代码说明：
// 1. package com.atguigu{}  表示我们创建了包 com.atguigu，在{}中我们可以继续写它的子包 scala(即com.atguigu.scala)，还可以写类、特质trait、还可以写object。
// 2. 即 sacla 支持，在一个文件中，可以同时创建多个包，以及给各个包创建类、trait和object。【超级灵活】
package com.atguigu { // 创建包 com.atguigu
  package scala { // 表示在 com.atguigu 下创建包 scala

    class Person { // 表示在 com.atguigu.scala 下创建类 Person
      val name = "Nick"
      def play(message: String): Unit = {
        println(this.name + " " + message)
      }
    }

    object Test { // 表示在 com.atguigu.scala 下创建类 object Test
      def main(args: Array[String]): Unit = {
        println("object Test")
      }
    }

  }

}

2、包也可以像嵌套类那样嵌套使用（包中有包），这个在前面的第三种打包方式已经讲过了，在使用第三种方式时的好处是：程序员可以在同一个文件中，将类(class/object)、trait 创建在不同的包中，这样就非常灵活了。【案例演示+反编译查看】
示例代码如下：

// 代码说明：
// 1. package com.atguigu{}  表示我们创建了包 com.atguigu，在{}中我们可以继续写它的子包 scala(即com.atguigu.scala)，还可以写类、特质trait、还可以写object。
// 2. 即 sacla 支持，在一个文件中，可以同时创建多个包，以及给各个包创建类、trait和object。【超级灵活】
package com.atguigu { // 创建包 com.atguigu

  class User { // 表示在 com.atguigu 下创建类 User

  }

  package scala2 { // 表示在 com.atguigu 下创建包 scala2
    class User {   // 表示在 com.atguigu.scala2 下创建类 User

    }
  }

  package scala {  // 表示在 com.atguigu 下创建包 scala

    class Person { // 表示在 com.atguigu.scala 下创建类 Person
      val name = "Nick"
      def play(message: String): Unit = {
        println(this.name + " " + message)
      }
    }

    object Test {  // 表示在 com.atguigu.scala 下创建类 object Test
      def main(args: Array[String]): Unit = {
        println("object Test")
      }
    }

  }

}

3、作用域原则：可以直接向上访问。即: Scala 中子包中直接访问父包中的内容，大括号体现作用域。(提示：Java 中子包使用父包的类，需要 import)。在子包和父包 类重名时，默认采用就近原则，如果希望指定使用某个类，则带上包名即可。【案例演示+反编译查看】
示例代码如下：

// 代码说明：
// 1. package com.atguigu{}  表示我们创建了包 com.atguigu，在{}中我们可以继续写它的子包 scala(即com.atguigu.scala)，还可以写类、特质trait、还可以写object。
// 2. 即 sacla 支持，在一个文件中，可以同时创建多个包，以及给各个包创建类、trait和object。【超级灵活】
package com.atguigu { // 创建包 com.atguigu

  // com.atguigu 下的类 User
  class User { // 表示在 com.atguigu 下创建类 User

  }

  package scala2 { // 表示在 com.atguigu 下创建包 scala2
    // com.atguigu.scala2 下的类 User
    class User {   // 表示在 com.atguigu.scala2 下创建类 User

    }
  }

  package scala {  // 表示在 com.atguigu 下创建包 scala

    class Person { // 表示在 com.atguigu.scala 下创建类 Person
      val name = "Nick"
      def play(message: String): Unit = {
        println(this.name + " " + message)
      }
    }

    // com.atguigu.scala 下的类 User
    class User {

    }

    object Test {  // 表示在 com.atguigu.scala 下创建类 object Test
      def main(args: Array[String]): Unit = {
        println("object Test")

        // 我们可以直接使用父包的内容
        // 1.如果有同名的类，则采用【就近原则】来使用内容(比如包)
        val user1 = new User
        println("user1=" + user1)
        // 2.如果就是要使用父包的类，则指定路径即可
        val user2 = new com.atguigu.User
        println("user2=" + user2)
      }
    }

  }

}

输出结果如下：

object Test
user1=com.atguigu.scala.User@7d417077
user2=com.atguigu.User@7dc36524

4、父包要访问子包的内容时，需要import 对应的子包中的类。
5、可以在同一个 xxx.scala 文件中，可以声明多个并列的 package (建议嵌套的 pakage 不要超过3层)。 【案例演示+反编译】
6、包名可以相对也可以绝对，比如，访问 BeanProperty 的绝对路径是：_root_. scala.beans.BeanProperty，在一般情况下：我们使用相对路径来引入包，只有当包名冲突时，使用绝对路径来处理。
示例代码如下：

object TestBean {
  def main(args: Array[String]): Unit = {
    val m = new Manager("jack")
    println("m=" + m)
  }
}

class Manager(var name: String) {
  // 第一种形式：相对路径引入
  // import scala.beans.BeanProperty
  // @BeanProperty var age: Int = _
  // 第二种形式：和第一种一样，都是相对路径引入
  // @scala.beans.BeanProperty var age2: Int = _
  // 第三种形式：是绝对路径引入，可以解决包名冲突
  @_root_.scala.beans.BeanProperty var age3: Int = _
}

7.1.7 包对象

基本介绍
  包可以包含类、对象和特质 trait，但不能包含函数/方法或变量的定义。这是 Java 虚拟机的局限。为了弥补这一点不足，scala 提供了包对象的概念来解决这个问题。

包对象的应用案例
示例代码如下：

package com.atguigu {

  // 在包中直接写方法或者定义变量吧，就会报错
  // var name = "jack"

  // 1. 在包中直接写方法，或者定义变量，就错误==>使用包对象的技术来解决
  // 2. package object scala 表示创建一个包对象 scala, 他是 com.atguigu.scala 这个包对应的包对象
  // 3. 每一个包都可以有一个包对象
  // 4. 包对象的名字需要和子包一样
  // 5. 在包对象中可以定义变量，方法
  // 6. 在包对象中定义的变量和方法，就可以在对应的包中使用
  // 7. 在底层这个包对象会生成两个.class文件 package.class 和 package$.class

  // 每个包都可以有一个【包对象】。你需要在父包(com.atguigu)中定义它，且名称与子包一样。
  package object scala {
    var name = "jack"

    def sayOk(): Unit = {
      println("package object sayOk")
    }
  }
  package scala { // 表示在 com.atguigu 下创建子包 scala

    class Test04 {
      def test(): Unit = {
        // 这里的 name 就是包对象 scala 中声明的 name
        println(name)
        sayOk() // 这个 sayOk()函数 就是【包对象】 scala 中声明的函数 sayOk
      }
    }

    object TestObj {
      def main(args: Array[String]): Unit = {
        val t = new Test04()
        t.test()
        // 因为 TestObje 和 scala 这个【包对象】在同一包，因此也可以使用
        println("name=" + name)
        sayOk()
      }
    }

  }

}

输出结果如下：

jack
package object sayOk
name=jack
package object sayOk

7.1.8 包对象的底层实现机制分析(重点)

在底层这个包对象会生成两个.class文件 package.class 和 package$.class。

7.1.9 包对象的注意事项

  1、每个包都可以有一个包对象。你需要在父包中定义它。
  2、包对象名称需要和包名一致，一般用来对包的功能补充。

7.2 包的可见性

7.2.1 回顾 Java 包的可见性

回顾-Java 访问修饰符基本介绍
java 提供四种访问控制修饰符号控制方法和变量的访问权限（范围）：
  1、公开级别：用 public 修饰，对外公开。
  2、受保护级别：用 protected。修饰，对子类和同一个包中的类公开。
  3、默认级别：没有修饰符号，向同一个包的类公开。
  4、私有级别：用 private 修饰，只有类本身可以访问，不对外公开。

回顾-Java 中4种访问修饰符的访问范围

回顾-Java 访问修饰符使用注意事项
  1、修饰符可以用来修饰类中的属性，成员方法以及类。
  2、只有默认的和 public 才能修饰类，并且遵循上述访问权限的特点。

7.2.2 Scala 中包的可见性介绍

  在 Java 中，访问权限分为: public，private，protected 和默认。在 Scala 中，你可以通过类似的修饰符达到同样的效果。但是使用上有区别。
示例代码如下：

package com.atguigu.chapter07.visit

object VisitDemo01 {
  def main(args: Array[String]): Unit = {
    val c = new Clerk()
    c.showInfo()
    Clerk.test(c)
  }
}

class Clerk { // 伴生类
  var name: String = "jack"         // 在底层是私有，可读可写（隐式私有）
  private var sal: Double = 9999.9  // 在底层是私有，只可读（显式私有）

  def showInfo(): Unit = {
    // 在本类中可以使用私有的属性
    println("name=" + name + " sal=" + sal)
  }
}

// 当一个文件中同时出现了 class Clerk 和 object Clerk
// 1、class Clerk  称为伴生类
// 2、object Clerk 称为伴生对象
// 因为 scala 的设计者将 static 拿掉了，他就设计了 伴生类 和 伴生对象 的概念
// 将非静态的内容放在 伴生类 中
// 将静态的内容放在 伴生对象 中
object Clerk { // 伴生对象
  def test(c: Clerk): Unit = {
    // 这里体现出：在伴生对象中，可以访问伴生类的私有属性 c.sal
    println("test() name=" + c.name + " sal=" + c.sal)
  }
}

输出结果如下：

name=jack sal=9999.9
test() name=jack sal=9999.9

7.2.3 Scala 中包的可见性和访问修饰符的使用

所有的示例代码如下：

package com.atguigu.chapter07.visit

object VisitDemo01 {
  def main(args: Array[String]): Unit = {
    val c = new Clerk()
    c.showInfo()
    Clerk.test(c)

    val p = new Person
    println(p.pname)
    println(p.page)
  }
}

class Clerk { // 伴生类
  var name: String = "jack"         // 在底层是私有，可读可写（隐式私有）
  private var sal: Double = 9999.9  // 在底层是私有，只可读（显式私有），private 为私有权限，只在 类的内部 和 伴生对象 中可用。

  def showInfo(): Unit = { // 当方法访问权限为默认时，默认为 public 访问权限。
    // 在本类中可以使用私有的属性
    println("name=" + name + " sal=" + sal)
  }
}

// 当一个文件中同时出现了 class Clerk 和 object Clerk
// 1、class Clerk  称为伴生类
// 2、object Clerk 称为伴生对象
// 因为 scala 的设计者将 static 拿掉了，他就设计了 伴生类 和 伴生对象 的概念
// 将非静态的内容放在 伴生类 中
// 将静态的内容放在 伴生对象 中
object Clerk { // 伴生对象
  def test(c: Clerk): Unit = {
    // 这里体现出：在伴生对象中，可以访问伴生类的私有属性 c.sal
    println("test() name=" + c.name + " sal=" + c.sal)
  }
}

class Person {
  // 这里我们增加一个包访问权限
  // 下面 private[visit] 说明
  // 1、仍然是 private
  // 2、在 visit 包(包括子包)下也可以使用 name，相当于扩大访问范围
  private[visit] val pname = "tom" // 增加包访问权限后，1. private同时起作用。不仅同类可以使用 2. 同时com.atguigu.scala中包下其他类也可以使用
  // 当然，也可以将可见度延展到上层包
  private[chapter07] val page= "25"
}

补充：
// 在 Scala 中，只有两种访问控制符：public 和 private
// 在 Scala 中，属性只有三种修饰符：默认(可读可写) 和 private(只可读) 和 protected(可读可写,只能子类访问)，但是底层都是 private
示例代码如下：

package com.atguigu.chapter07.homework

object Exercise04 {
  def main(args: Array[String]): Unit = {
    println("xxx")
  }
}

// 在 Scala 中，只有两种访问控制符：public 和 private
// 在 Scala 中，属性只有三种修饰符：默认(可读可写) 和 private(只可读) 和 protected(可读可写,只能子类访问)，但是底层都是 private

class Monster {
  var age: Int = 1
  private var name: String = ""
  protected var sal: Double = 0.01
}

7.3 包的引入

7.3.1 Scala 引入包基本介绍

7.3.2 Scala 引入包的细节和注意事项

1、在 Scala 中，import 语句可以出现在任何地方，并不仅限于文件顶部，import 语句的作用一直延伸到包含该语句的块末尾。这种语法的好处是：在需要时在引入包，缩小 import 包的作用范围，提高效率。
2、Java 中如果想要导入包中所有的类，可以通过通配符*，Scala 中采用下划线。

3、如果不想要某个包中全部的类，而是其中的几个类，可以采用选取器(花括号)。

4、如果引入的多个包中含有相同的类，那么可以将不需要的类进行重命名进行区分，这个就是重命名。
5、如果某个冲突的类根本就不会用到，那么这个类可以直接隐藏掉。

7.4 面向对象编程方法-抽象

示例代码如下：

package com.atguigu.chapter07.abstractdemo

object BankDemo {
  def main(args: Array[String]): Unit = {
    // 开卡
    val account = new Account("gh001", 999.9, "123456")
    account.query("123456")
    account.withDraw("123456", 500)
    account.query("123456")
    account.deposit(200)
    account.query("123456")
  }
}

/**
  * 属性：
  *   账号，余额，密码
  * 方法：
  *   查询
  *   取款
  *   存款
  */
class Account(InAccountNo: String, InBalance: Double, InPwd: String) {
  val accountNo = InAccountNo
  var balance = InBalance
  var pwd = InPwd

  // 查询方法
  def query(InPwd: String): Unit = {
    if (!InPwd.equals(this.pwd)) {
      println("密码输入错误！")
      return
    }

    printf("账号为：%s，当前余额是：%.2f", this.accountNo, this.balance)
    println()
  }

  // 取款方法
  def withDraw(InPwd: String, money: Double): Any = {
    if (!InPwd.equals(this.pwd)) {
      println("密码输入错误！")
      return
    }
    if (money > this.balance) {
      println("余额不足，请充值！")
      return
    }
    this.balance -= money
    money
  }

  // 存款方法
  def deposit(money: Double): Unit = {
    this.balance += money
    println("存款成功！")
  }
}

输出结果如下：

账号为：gh001，当前余额是：999.90
账号为：gh001，当前余额是：499.90
存款成功！
账号为：gh001，当前余额是：699.90

7.5 面向对象编程三大特征

7.5.1 基本介绍

7.5.2 封装的实现步骤

7.5.3 快速入门案例

7.5.4 Scala 封装的注意事项和细节

7.6 面向对象编程方法-继承

7.6.1 Java 继承的简单回顾

Java 继承的简单回顾

Java 中继承的示意图

7.6.2 Scala 的继承

示例代码如下：

package com.atguigu.chapter07.myextends

object Extends01 {
  def main(args: Array[String]): Unit = {
    val stu = new Student
    stu.name = "tom" // 调用了父类 Person 的 stu.name_$eq() 方法相当于 setter 方法
    stu.studying()
    stu.showInfo()
  }
}

class Person {
  var name: String = _
  var age: Int = _

  def showInfo(): Unit = {
    println("学生信息如下：")
    println("名字：" + this.name)
  }
}

class Student extends Person {
  def studying(): Unit = {
    println(this.name + " 在学习 scala 中....")
  }
}

输出结果如下：

tom 在学习 scala 中....
学生信息如下：
名字：tom

7.6.3 Scala 继承给编程带来的便利

示例代码如下：

package com.atguigu.chapter07.myextends

// 说明：
// 1、在 Scala 中，子类继承了父类的所有属性，但是父类的 private 的属性和方法无法访问。
object Extends02 {
  def main(args: Array[String]): Unit = {
    val sub = new Sub()
    sub.sayOk()

    // sub.test200() // 错误，protected 为受保护权限，scala 中受保护权限比 Java 中更严格，只能子类访问，同包无法访问 (编译器)。
  }
}

class Base {
  var n1: Int = 1
  protected var n2: Int = 2
  private var n3: Int = 3

  def test100(): Unit = { // 底层是 public
    println("base 100")
  }

  protected def test200(): Unit = { // 底层是 public
    println("base 200")
  }

  private def test300(): Unit = { // 底层是 private
    println("base 300")
  }
}

class Sub extends Base {
  def sayOk(): Unit = {
    this.n1 = 20
    this.n2 = 40
    println("范围：" + this.n1 + " " + this.n2)
    test100()
    test200()
  }
}

输出结果如下：

范围：20 40
base 100
base 200

7.6.4 重写方法

  说明：scala 明确规定，重写一个非抽象方法需要用 override 修饰符，调用超类的方法使用 super 关键字。
示例代码如下：

package com.atguigu.chapter07.myextends

object MethodOverride01 {
  def main(args: Array[String]): Unit = {
    val emp = new Emp100
    emp.printName()
  }
}

class Person100 {
  var name: String = "tom"
  def printName() {
    println("Person printName() " + name)
  }
}

// scala 明确规定，重写一个非抽象方法需要用 override 修饰符，调用超类的方法使用 super 关键字。
class Emp100 extends Person100 {
  // 这里需要显式的使用 override
  override def printName() {
    println("Emp printName() " + name)
    super.printName()
  }
}

输出结果如下：

Emp printName() tom
Person printName() tom

7.6.5 Scala 中类型检查和转换

示例代码如下：

package com.atguigu.chapter07.myextends

object TypeConvert {
  def main(args: Array[String]): Unit = {
    // 获取对象类型
    println(classOf[String]) // class java.lang.String

    // 这种是 Java 中反射方式得到对象类型
    val s = "zhangsan"
    println(s.getClass.getName) // java.lang.String

    println(s.isInstanceOf[String]) // true
    println(s.asInstanceOf[String]) // 将 s 显示转换成 String

    var p2 = new Person200
    var emp2 = new Emp200
    // 将子类引用给父类（向上转型，自动）
    p2 = emp2
    // 将父类引用转成子类引用（向下转型，需要手动）
    var emp3 = p2.asInstanceOf[Emp200]
    emp3.sayHello()
  }
}

class Person200 {
  var name: String = "tom"

  def printName() {
    println("Person printName() " + name)
  }
}

// scala 明确规定，重写一个非抽象方法需要用 override 修饰符，调用超类的方法使用 super 关键字。
class Emp200 extends Person200 {
  // 这里需要显式的使用 override
  override def printName() {
    println("Emp printName() " + name)
    super.printName()
  }

  def sayHello(): Unit = {
    println("hello")
  }
}

输出结果如下：

class java.lang.String
java.lang.String
true
zhangsan
hello

Scala 中类型检查和转换的最佳实践
  类型检查和转换的最大价值在于：可以判断传入对象的类型，然后转成对应的子类对象，进行相关操作，这里也体现出多态的特点。
示例代码如下：

package com.atguigu.chapter07.myextends

object TypeConvertExer {
  def main(args: Array[String]): Unit = {
    // 创建子类对象
    val stu = new Stu
    val worker = new Worker
    test(stu)     // stuId=100
    test(worker)  // workerId=200
  }

  def test(p: Person300): Unit = {
    // 如果传入是 Student 实例，则调用 sayOk
    // 如果传入是 Worker 实例，则调用 sayHello
    // 进行 p.asInstanceOf[T] 转换时，要求 p 的引用本身就是指向 T 类型的引用
    if (p.isInstanceOf[Stu]) {
      // 向下转型
      p.asInstanceOf[Stu].sayOk() // 注意：p.asInstanceOf[Stu] 对 p 的类型没有任何变化，而是返回的是 Stu 类型
    } else if (p.isInstanceOf[Worker]) {
      p.asInstanceOf[Worker].sayHello()
    } else {
      println("转换错误")
    }
  }
}

class Person300 {
  var name: String = "tom"

  def printName() {
    println("name=" + name)
  }
}

class Stu extends Person300 {
  var stuId: Int = 100

  def sayOk(): Unit = {
    println("stuId=" + this.stuId)
  }
}

class Worker extends Person300 {
  var workerId: Int = 200

  def sayHello(): Unit = {
    println("workerId=" + this.workerId)
  }
}

输出结果如下：

stuId=100
workerId=200

7.6.6 Java 中超类的构造

回顾-Java 中超类的构造
示例代码如下：

package com.atguigu.chapter07.myextends;

public class JavaBaseConstractor {
    public static void main(String[] args) {
        B b1 = new B();
        B b2 = new B("tom");
    }
}

class A {
    public A() {
        System.out.println("A()");
    }
    public A(String name) {
        System.out.println("A(String name) " + name);
    }
}
class B extends A {
    public B() {
        // 这里会隐式调用super(); 就是无参的父类构造器A()
        System.out.println("B()");
    }
    public B(String name) {
        super(name);
        System.out.println("B(String name) " + name);
    }
}

输出结果如下：

A()
B()
A(String name) tom
B(String name) tom

说明：
  从代码可以看出：在 Java 中，创建子类对象时，子类的构造器总是去调用一个父类的构造器(显式或者隐式调用)。

7.6.7 Scala 中超类的构造

Scala 超类的构造说明
  1、类有一个主构器和任意数量的辅助构造器，而每个辅助构造器都必须先调用主构造器(也可以是间接调用)，这点在前面我们说过了。
  2、只有子类的主构造器可以调用父类的构造器(主和辅均可)。子类的辅助构造器不能直接调用父类的构造器。在 Scala 的子类的构造器中，你不能调用 super(params)。
完整示例代码如下：

package com.atguigu.chapter07.myextends

object ScalaBaseConstractor {
  def main(args: Array[String]): Unit = {
    // 分析一下它的执行流程
    // 1、因为 scala 遵守先构建父类部分 extends Person500()
    // 2、Person...
    // 3、Emp... (Emp500的主构造器)
    val emp1 = new Emp500()

    println("----------")
    // 分析一下它的执行流程
    // 1、因为 scala 遵守先构建父类部分 extends Person500()
    // 2、Person...
    // 3、Emp.... (Emp500的主构造器)
    // 4、Emp辅助构造器
    val emp2 = new Emp500("lucy")

    println("----------")
    // 分析一下它的执行流程
    // 1、因为 scala 遵守先构建父类部分 extends Person600()，由父类的辅助构造器调用该父类的带参主构造器
    // 2、Person...
    // 3、Emp.... (Emp600的主构造器)
    // 4、Emp辅助构造器
    val emp3 = new Emp600("lucy")

    println("----------")
    // 分析一下它的执行流程
    // 1、因为 scala 遵守先构建父类部分 extends Person700(eName)，调用该父类的带参主构造器
    // 2、Person...
    // 3、Emp.... (Emp700的主构造器)
    val emp4 = new Emp700("lucy", 20)
  }
}

class Person500 {
  var name = "zhangsan"
  println("Person...")
}

class Emp500 extends Person500 {
  println("Emp...")

  def this(name: String) {
    this // 该子类的辅助构造器必须调用该子类的主构造器
    this.name = name
    println("Emp辅助构造器")
  }
}

class Person600(pName: String) {
  var name = pName
  println("Person...")

  def this() {
    this("默认的名字") // 该父类的辅助构造器必须调用该父类的带参主构造器
    println("默认的名字")
  }
}

class Emp600 extends Person600 {
  println("Emp...")

  def this(name: String) {
    this // 该子类的辅助构造器必须调用该子类的主构造器
    this.name = name
    println("Emp辅助构造器")
  }
}

class Person700(pName: String) {
  var name = pName
  println("Person...")

  def this() {
    this("默认的名字") // 该父类的辅助构造器必须调用该父类的带参主构造器
    println("默认的名字")
  }
}

class Emp700(eName:String, eAge: Int) extends Person700(eName) {
  println("Emp...")

  def this(name: String) {
    this("mary", 10) // 该子类的辅助构造器必须调用该子类的主构造器
    this.name = name
    println("Emp辅助构造器")
  }
}

输出结果如下：

Person...
Emp...
----------
Person...
Emp...
Emp辅助构造器
----------
Person...
默认的名字
Emp...
Emp辅助构造器
----------
Person...
Emp...

7.6.8 覆写字段

Java 另一重要特性: 动态绑定 机制
示例代码如下：

package com.atguigu.chapter07.myextends;

public class JavaDaynamicBind {
    public static void main(String[] args) {
        // 提出 java 的动态绑定机制
        // 1. 当调用对象方法的时候，该方法会和该对象的内存地址绑定。
        // 2. 当调用对象属性时，没有动态绑定机制，哪里声明，那里使用。
        AA a = new BB();                // BB均不注销   BB只注销sum()  BB注销sum()和注销sum1()
        System.out.println(a.sum());    // 40           30              30
        System.out.println(a.sum1());   // 30           30              20

        //
        /*
        java中多态中对成员的访问的特点 = 动态绑定
        成员变量：
            编译看左边，运行看左边。
        成员方法：
　　　　    编译看左边，运行看右边。
        静态方法：
　　　　    编译看左边，运行看左边。
        */
    }
}

class AA {
    public int i = 10;
    public int sum() {
        return getI() + 10;
    }
    public int sum1() {
        return i + 10;
    }
    public int getI() {
        return i;
    }
}

class BB extends AA {
    public int i = 20;
/*    public int sum() {
        return i + 20;
    }*/
/*    public int sum1() {
        return i + 10;
    }*/
    public int getI() {
        return i;
    }
}

Scala 覆写字段快速入门
示例代码如下：

package com.atguigu.chapter07.myextends

object ScalaFiledOverride {
  def main(args: Array[String]): Unit = {
    val obj1: AAA = new BBB
    val obj2: BBB = new BBB
    println("obj1.age=" + obj1.age) // 动态绑定机制生效
    println("obj2.age=" + obj2.age)
  }
}

class AAA {
  val age: Int = 10 // 底层是 public int age() 方法
}

class BBB extends AAA {
  override val age: Int = 20 // 底层是 public int age() 方法
}

输出结果如下：

obj1.age=20
obj2.age=20

反编译后的代码：

public class AAA {
  private final int age = 10;
  public int age() { 
    return this.age;
  }
}

public class BBB extends AAA {
  private final int age = 20;
  public int age() { 
    return this.age;
  }
}

覆写字段的注意事项和细节

1、def 只能重写另一个 def (即：方法只能重写另一个方法)。
2、val 只能重写另一个 val 属性 或 重写不带参数的 def。
示例代码如下：

package com.atguigu.chapter07.myextends

object ScalaFiledOverrideDetail01 {
  def main(args: Array[String]): Unit = {

  }
}

// 2、val 只能重写另一个 val 属性。
class AAAA {
  // var name: String = "" // 底层会生成 public String name() 和 public String name_$seq()
  val name: String = "" // 底层只会生成 public String name()
}

class BBBB extends AAAA {
  override val name: String = "tom" // 底层只会生成 public String name()
}

示例代码如下：

package com.atguigu.chapter07.myextends

object ScalaFiledOverrideDetail02 {
  def main(args: Array[String]): Unit = {
    val b1 = new BBBBB
    println("b1.sal=" + b1.sal) // b1.sal=20

    val b2:AAAAA = new BBBBB // 动态绑定机制生效
    println("b2.sal=" + b2.sal()) // b2.sal=20
  }
}

// 2、val 只能重写重写不带参数的 def。
class AAAAA {
  def sal(): Int = { // 底层只会生成 public int sal()
    return 10
  }
}
class BBBBB extends AAAAA {
  override val sal: Int = 20 // 底层只会生成 public int sal()
}

3、var 只能重写另一个抽象的 var 属性。

示例代码如下：

package com.atguigu.chapter07.myextends

object ScalaFiledOverrideDetail03 {
  def main(args: Array[String]): Unit = {
    println()
  }
}

// 1、抽象属性：声明未初始化的变量(字段/属性)就是抽象的属性，抽象属性在抽象类中。
// 2、对于抽象的属性，在底层不会生成对应的属性声明，而是生成两个对应的抽象方法。
// public abstract String name();
// public abstract void name_$eq(String paramString);
abstract class A03 {
  var name: String
  val age: Int = 10 // val修饰，底层只生成 public int age()
}

// 1、我们在子类中重写父类的抽象属性，本质上是实现了抽象方法，生成了两个 public 方法
// public String name()
// public void name_$eq(String x$1)
// 2、如果是覆写一个父类的抽象属性，那么 override 关键字可省略。
// 3、如果是覆写一个父类的非抽象属性，那么 override 关键字不可省略。
class B03 extends A03 {
  // var name: String = _ // 如果是覆写一个父类的抽象属性，那么 override 关键字可省略。
  override var name: String = _
  override val age: Int = 20 // val修饰，底层只生成 public int age()
}

7.6.9 抽象类

示例代码如下：

package com.atguigu.chapter07.myextends

object AbstractDemo01 {
  def main(args: Array[String]): Unit = {
    println()
  }
}

abstract class Animal {
  var name: String // 抽象的字段
  var age: Int // 抽象的字段
  var color: String = "black" // 普通字段

  // def cry // 抽象的方法的小括号可以省略
  def cry() // 抽象的方法，不需要标记 abstract，否则报错
}

抽象类基本语法

7.6.10 Scala 抽象类使用的注意事项和细节讨论

示例代码如下：

package com.atguigu.chapter07.myextends

object AbstractClassDetail01 {
  def main(args: Array[String]): Unit = {
    // 1、抽象类不能被实例。但是有一种情况：当动态实现抽象类的所有抽象方法时，抽象类也就被实例化了。本质是该抽象类的匿名子类实现了该抽象类。
    val a1 = new Animal01 {
      override def eat(): Unit = {
        println("eat...")
      }
    }
    a1.eat()

    val a5 = new Cat
    a5.name = "小呆萌"
    a5.eat()
  }
}

abstract class Animal01 {
  def eat()
}

// 2、抽象类不一定要包含 abstract 方法。也就是说，抽象类可以没有 abstract 方法。
abstract class Animal02 {
  // 7、抽象类中可以有实现的方法。
  def eat(): Unit = {
    println("eat...")
  }
}

// 5、如果一个类继承了抽象类，则它必须实现抽象类的所有抽象方法和抽象属性，除非它自己也声明为 abstract 类。
abstract class Animal05 {
  var name:String
  def eat()
}

class Cat extends Animal05 {
  // 9、如果是覆写一个父类的抽象属性，那么 override 关键字可省略。
  override var name: String = _
  // 8、子类重写抽象方法不需要 override，写上也不会错。
  override def eat(): Unit = {
    println(this.name + " eat fash")
  }
}

输出结果如下：

eat...
小呆萌 eat fash

7.6.11 匿名子类

示例代码如下：

package com.atguigu.chapter07.myextends;

public class NoNameDemo01 {
    public static void main(String[] args) {
        A2 a = new A2() {
            @Override
            public void cry() {
                System.out.println("呜呜");
            }
        };
        a.cry();

    }
}

abstract class A2 {
    abstract public void cry();
}

输出结果如下：

呜呜

示例代码如下：

package com.atguigu.chapter07.myextends

object NoNameDemo02 {
  def main(args: Array[String]): Unit = {
    var monster = new Monster {
      override var name: String = "牛魔王"

      override def cry(): Unit = {
        println(this.name + " 哞哞")
      }
    }
    monster.cry()
  }
}

abstract class Monster {
  var name: String

  def cry()
}

输出结果如下：

牛魔王 哞哞

7.6.12 继承层级

Scala 继承层级一览图

继承层级图小结

7.7 作业04

1、编写一个 Time 类，加入只读属性 hours 和 minutes，和一个检查某一时刻是否早于另一时刻的方法 before(other: Time): Boolean。Time 对象应该以 new Time(hrs, min) 方式构建。
示例代码如下：

package com.atguigu.chapter07.homework

/**
  * 1、编写一个 Time 类，加入只读属性 hours 和 minutes，和一个检查某一时刻是否早于另一时刻的方法 before(other: Time): Boolean。
  * Time 对象应该以 new Time(hrs, min) 方式构建。
  */
object Exercise01 {
  def main(args: Array[String]): Unit = {
    // 测试
    val cur = new Time(10, 20)
    val other = new Time(10, 20)
    println(cur.before(other)) // 结果根据输入的对象不同而定
  }
}

class Time(hrs: Int, min: Int) { // 主构造器
  private val hours: Int = hrs // 只读属性
  private val minutes: Int = min // 只读属性

  def before(other: Time): Boolean = { // 方法
    if (hours < other.hours) { // 如果当前的小时数小于other
      true
    } else if (hours > other.hours) { // 如果当前的小时数大于other
      false
    } else { // 小时数相等，判断分钟
      if (minutes < other.minutes) true else false
    }
  }

}

2、创建一个 Student 类，加入可读写的 JavaBeans 属性 name (类型为 String)和 id (类型为 Long)。
（1）有哪些方法被生产？(用 javap 查看，该指令可以查看 .class 文件的反编译的方法声明，还可以看到反汇编代码)
（2）你可以在 Scala 中调用 JavaBeans 的 getter 和 setter 方法吗？

// 先进行编译的命令
scalac Student.scala
// 查看反编译的方法声明的命令
javap Student
// 查看反汇编代码的命令
javap -c Student

示例代码如下：

import scala.beans.BeanProperty

class Student {
  // 读写属性
  @BeanProperty var name: String = _
  @BeanProperty var id: Long = _
}

演示截图如下：

3、练习使用包的各种声明方式，并查看他们的不同。
答：一共有三种导入方式。在一般情况下：我们使用相对路径来引入包，只有当包名冲突时，使用绝对路径来处理。
示例代码如下：

object TestBean {
  def main(args: Array[String]): Unit = {
    val m = new Manager("jack")
    println("m=" + m)
  }
}

class Manager(var name: String) {
  // 第一种形式：相对路径引入
  // import scala.beans.BeanProperty
  // @BeanProperty var age: Int = _
  // 第二种形式：和第一种一样，都是相对路径引入
  // @scala.beans.BeanProperty var age2: Int = _
  // 第三种形式：是绝对路径引入，可以解决包名冲突
  @_root_.scala.beans.BeanProperty var age3: Int = _
}

4、编写一段程序，将 Java 哈希映射(Java 中的 HashMap)中的所有元素拷贝到 Scala 哈希映射(Scala 中的 HashMap)。用引入语句重命名这两个类。
示例代码如下：

package com.atguigu.chapter07.homework

// 说明：
// 1、当我们继承了App后，就可以直接在这个类中执行代码，不需要再写 main 入口了。
object Exercise03 extends App {

  import java.util.{HashMap => JavaHashMap} // 重命名 Java 中的 HashMap
  import collection.mutable.{HashMap => ScalaHashMap, _} // 重命名 Scala 中的 HashMap

  val javaMap = new JavaHashMap[Int, String] // 创建 Java 的 HashMap，其中 [Int, String] 是泛型
  javaMap.put(1, "One");  // 加入了四对 key-val
  javaMap.put(2, "Two");
  javaMap.put(3, "Three");
  javaMap.put(4, "Four");

  val scalaMap = new ScalaHashMap[Int, String] // 创建 Scala 的 HashMap，其中 [Int, String] 是泛型

  // 说明
  // 1、javaMap.keySet().toArray，这里是将 javaMap 的 key 转成数组
  // 2、key.asInstanceOf[Int] 将 key 强转成 Int 类型
  // 3、javaMap.get(key)，得到这个 key 对应 value
  // 4、(key.asInstanceOf[Int] -> javaMap.get(key))  是 key -> value
  // 5、+= 将 key -> value 加入（拷贝）到 scalaMap
  for (key <- javaMap.keySet().toArray) {
    scalaMap += (key.asInstanceOf[Int] -> javaMap.get(key))
  }
  println(scalaMap) // Map(2 -> Two, 4 -> Four, 1 -> One, 3 -> Three)
  println(scalaMap.mkString(" ")) // 2 -> Two 4 -> Four 1 -> One 3 -> Three
}

输出结果如下：

Map(2 -> Two, 4 -> Four, 1 -> One, 3 -> Three)
2 -> Two 4 -> Four 1 -> One 3 -> Three