释放双眼，带上耳机，听听看~！
第七章 面向对象编程-中级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
