大数据处理学习笔记1.7 掌握Scala类、对象、抽象类与特质

零、本节学习目标

1. 掌握类的定义与实例化
2. 理解单例对象和伴生对象
3. 掌握构造器和辅助构造器
4. 掌握抽象类和特质

一、类

 （一）类的定义

• 对象是类的具体实例，类是抽象的，不占用内存，而对象是具体的，占用存储空间。
• 面向对象三大特性之一：封装（encapsulation） - 封装数据和操作
• Scala中一个简单的类定义是使用关键字class，类名首字母必须大写。类中的方法用关键字def定义
• 创建net.huawei.day04包，在包里创建User类，包含三个私有属性和一个公共方法

1. package net.zyf.day04

3. /**

4. * 功能：用户类

5. * 作者：zyf

6. * 日期：2023年03月日

7. */

8. class User{

9. private var name = "张三丰"

10. private var gender = "男"

11. private var age = 25

13. def speak(): Unit = println("我叫" + name + "，" + gender + "，今年" + age + "岁了~")

16. }

• 说明：在Scala里，如果一个类不写访问修饰符，那么默认访问级别为public，这与Java是不一样的。

（二）类的实例化

• 关键字new用于创建类的实例
• 实例化User类，调用其speak()方法
• 在net.huawei.day04包里创建TestUser对象

1. package net.zyf.day04

3. /**

4. * 功能：

5. * 作者：zyf

6. * 时间：2023年03月23号

7. */

8. object TestUser {

9. def main(args: Array[String]): Unit = {

10. // 创建用户对象

11. val user = new User()

12. // 调用对象方法

13. user.speak()

14. }

17. }

---

• 运行查看结果

•  访问私有属性name，系统会报错

 

• 怎么才能访问类的私有属性呢？后面我们会定义setter和getter来访问私有属性。

二、单例对象

（一）单例对象概念

• Scala中没有静态方法或静态字段，但是可以使用关键字object定义一个单例对象，单例对象中的方法相当于Java中的静态方法，可以直接使用“单例对象名.方法名”方式进行调用。单例对象除了没有构造器参数外，可以拥有类的所有特性。

（二）案例演示

• 在net.huawei.day04里创建Person单例对象，包含三个私有属性和一个公共方法

1. package net.zyf.day04

3. /**

4. * 功能：

5. * 作者：zyf

6. * 时间：2023年03月00号

7. */

8. object Person {private var name = "陈燕文"

9. private var gender = "女"

10. private var age = 18

12. def speak(): Unit = println("我叫" + name + "，" + gender + "，今年" + age + "岁了~")

15. }

•  在net.huawei.day04包里创建TestPerson对象

1. package net.zyf.day04

3. /**

4. * 功能：

5. * 作者：zyf

6. * 时间：2023年03月00号

7. */

8. object TestPerson {

9. def main(args: Array[String]): Unit = {

10. //直接调用对象方法()

11. Person.speak()

12. }

15. }

三、伴生对象

（一）伴生对象概念

• 当单例对象的名称与某个类的名称一样时，该对象被称为这个类的伴生对象。类被称为该对象的伴生类。类和它的伴生对象必须定义在同一个文件中，且两者可以互相访问其私有成员。

（二）案例演示

• 在net.huawei.day04包里，创建Scala类Student，在文件里创建其伴生对象Student

1. package net.zyf.day04

3. /**

4. * 功能：

5. * 作者：zyf

6. * 时间：2023年03月00号

7. */

8. //伴生类

9. class Student {

10. private var name = "陈燕文"

12. def speak(): Unit = {

13. // 访问伴生对象的私有成员(Student.age)

14. println("我叫" + name + "，今年" + Student.age + "岁了~")

15. }

16. }

18. // 伴生对象

19. object Student {

20. private var age = 18

22. def main(args: Array[String]): Unit = {

23. // 基于伴生类创建学生对象

24. val student = new Student()

25. // 访问伴生类对象的私有成员（name）

26. println("姓名：" + student.name)

27. // 访问伴生对象的私有成员（age）

28. println("年龄：" + age) // 或者写成Student.age，但是不能写成student.age

29. // 调用伴生类对象的方法

30. student.speak()

31. }

32. }

四、get和set方法

（一）生成原则

• Scala默认会根据类的属性的修饰符生成不同的get和set方法

1、val修饰的属性 - 公共常量属性

• 系统会自动生成一个私有常量属性和一个公有get方法。

2、var修饰的属性 - 公共变量属性

• 系统会自动生成一个私有变量属性和一对公有get/set方法。

3、private var修饰的属性 - 私有变量属性

• 系统会自动生成一对私有get/set方法，相当于类的私有属性，只能在类的内部和伴生对象中使用。

4、private[this]修饰的属性 - 本地私有变量属性

• 系统不会生成get/set方法，即只能在类的内部使用该属性。

（二）案例演示

任务1、利用系统自动生成的get和set方法

（1）创建Dog类

• 在net.huawei.day04包里创建Dog类

1. package net.zyf.day04

3. /**

4. * 功能：狗类

5. * 作者：zyf

6. * 日期：2023年03月日

7. */

8. class Dog {

9. val id: Int = 1 // 系统会自动生成公共的get方法

10. var name: String = "瑞瑞" // 系统会自动生成公共的get和set方法

11. private var gender: String = "公" // 系统会自动生成私有的get和set方法，只有伴生对象可以访问

12. private[this] var age: Int = 5 // 系统不会生成get和set方法，即使伴生对象也无法访问

14. }

（2）编译成字节码文件

• 将Dog.scala编译成Dog.class

   

• 直接用记事本打开就是乱码 

（3）将字节码文件反编译为Java代码

• Java反编译工具 - Java Decompiler

1. package net.zyf.day04;

3. import scala.reflect.ScalaSignature;

5. @ScalaSignature(bytes = "\006\005}2Aa\003\007\001'!)!\004\001C\0017!9a\004\001b\001\n\003y\002BB\022\001A\003%\001\005C\004%\001\001\007I\021A\023\t\017E\002\001\031!C\001e!1\001\b\001Q!\n\031Bq!\017\001A\002\023%Q\005C\004;\001\001\007I\021B\036\t\ru\002\001\025)\003'\021\031q\004\001)Q\005A\t\031Ai\\4\013\0055q\021!\0023bsB\"$BA\b\021\003\rQ\030P\032\006\002#\005\031a.\032;\004\001M\021\001\001\006\t\003+ai\021A\006\006\002/\005)1oY1mC&\021\021D\006\002\007\003:L(+\0324\002\rqJg.\033;?)\005a\002CA\017\001\033\005a\021AA5e+\005\001\003CA\013\"\023\t\021cCA\002J]R\f1!\0333!\003\021q\027-\\3\026\003\031\002\"a\n\030\017\005!b\003CA\025\027\033\005Q#BA\026\023\003\031a$o\\8u}%\021QFF\001\007!J,G-\0324\n\005=\002$AB*ue&twM\003\002.-\005Aa.Y7f?\022*\027\017\006\0024mA\021Q\003N\005\003kY\021A!\0268ji\"9q'BA\001\002\0041\023a\001=%c\005)a.Y7fA\0051q-\0328eKJ\f!bZ3oI\026\024x\fJ3r)\t\031D\bC\0048\021\005\005\t\031\001\024\002\017\035,g\016Z3sA\005\031\021mZ3")

6. public class Dog {

7. private final int id = 1;

9. public int id() {

10. return this.id;

11. }

13. private String name = ";

15. public String name() {

16. return this.name;

17. }

19. public void name_$eq(String x$1) {

20. this.name = x$1;

21. }

23. private String gender = ";

25. private String gender() {

26. return this.gender;

27. }

29. private void gender_$eq(String x$1) {

30. this.gender = x$1;

31. }

33. private int age = 5;

34. }

 （4）说明反编译生成的Java代码

• 使用name属性举例，在Scala中，get和set方法并非被命名为getName和setName，而是被命名为name和name_=，由于JVM不允许在方法名中出现=，因此=被翻译成$eq。
• 从上述代码可以看出，由于属性id使用val修饰，因此不可修改，只生成了与get方法对应的id()；属性name使用var修饰，因此生成了与get和set方法对应的name()和name_$eq()方法，且都为public；属性gender由于使用private var修饰，因此生成了private修饰的get和set方法 - gender()和gender_$eq()；属性age由于使用private[this]修饰，因此没有生成get和set方法，只能在类的内部使用。

（5）创建单例对象用来测试Dog类

• 创建TestDog单例对象

1. package net.zyf.day04

3. /**

4. * 功能：

5. * 作者：zyf

6. * 时间：2023年03月00号

7. */

8. object TestDog {

9. def main(args: Array[String]): Unit = {

10. // 创建狗对象

11. val dog: Dog = new Dog()

12. // 访问id属性

13. println("id: " + dog.id)

14. // 设置name属性

15. dog.name = "欢欢"

16. // 访问name属性

17. println("name: " + dog.name)

18. }

21. }

•  注意：本地私有属性age，不能访问，即使伴生对象也无法访问

•  私有属性gender只有在伴生对象里可以访问，在非伴生对象TestDog里是无法访问的

• 创建Dog类的伴生对象，可以访问属性id和name，就可以访问Dog类的私有属性gender

1. package net.zyf.day04

3. /**

4. * 功能：狗类

5. * 作者：zyf

6. * 日期：2023年03月15日

7. */

8. // 伴生类

9. class Dog {

10. val id: Int = 1 // 系统会自动生成公共的get方法

11. var name: String = "瑞瑞" // 系统会自动生成公共的get和set方法

12. private var gender: String = "公" // 系统会自动生成私有的get和set方法，只有伴生对象可以访问

13. private[this] var age: Int = 5 // 系统不会生成get和set方法，即使伴生对象也无法访问

14. }

16. // 伴生对象

17. object Dog {

18. def main(args: Array[String]): Unit = {

19. // 创建Dog对象

20. val dog: Dog = new Dog()

21. // 伴生对象访问id属性

22. println("id: " + dog.id)

23. // 伴生对象访问name属性

24. dog.name = "萌萌哒"

25. println("name: " + dog.name)

26. // 伴生对象设置伴生类对象的私有属性gender

27. dog.gender = "母"

28. // 伴生对象访问伴生类对象的私有属性gender

29. println("gender: " + dog.gender)

30. }

31. }

• 运行程序，查看结果

•  即使伴生对象也无法访问伴生类的本地私有属性age

•  类似的效果，用Java来实现

任务2、用户自己编写私有属性的Scala风格的get和set方法

• 注意：set方法的写法 —— 方法名_=
• 在net.huawei.day04包里创建Cat类

1. package net.zyf.day04

3. /**

4. * 功能：猫类

5. * 作者：zyf

6. * 日期：2023年03月24日

7. */

8. // 伴生类

9. class Cat {

10. private var catName: String = "虎丸"

12. // 定义get方法 - name

13. def name: String = catName // 相当于Java里的getCatName方法

15. // 定义set方法 - name_=

16. def name_=(name: String): Unit = { // 相当于Java里的setCatName方法

17. catName = name

18. }

19. }

21. // 伴生对象

22. object Cat {

23. def main(args: Array[String]): Unit = {

24. // 创建猫对象

25. val cat: Cat = new Cat()

26. // 获取对象属性

27. println("猫原来的名字：" + cat.name)

28. // 设置对象属性

29. cat.name_=("冰轮丸")

30. // 访问伴生类对象私有属性

31. println("猫现在的名字：" + cat.catName)

32. }

33. }

• 运行结果

任务3、用户自己编写私有属性的Java风格的get和set方法

• 注意：get方法 —— getXXX()，set方法——setXXX()
• 在net.huawei.day04包里创建Bird类

1. package net.zyf.day04

3. /**

4. * 功能：

5. * 作者：zyf

6. * 时间：2023年03月00号

7. */

8. object Bird {

9. // 伴生类

10. class Bird {

11. private var name = "玲玲"

13. // Java风格的get方法

14. def getName: String = name

16. // Java风格的set方法

17. def setName(name: String): Unit = {

18. this.name = name

19. }

20. }

22. // 伴生对象

23. object Bird {

24. def main(args: Array[String]): Unit = {

25. // 创建鸟对象

26. val bird = new Bird()

27. // 获取对象属性

28. println("鸟原来的名字：" + bird.getName)

29. // 设置对象属性

30. bird.setName("菲菲")

31. // 伴生对象访问伴生类对象私有属性

32. println("鸟现在的名字：" + bird.name)

33. }

34. }

38. }

 

五、构造器

• Scala中的构造器分为主构造器和辅助构造器。

（一）主构造器

1、构造器参数带val或var

• 主构造器的参数直接放在类名之后，且将被编译为类的成员变量，其值在初始化类时传入。注意，构造器参数必须指定类型
• 在net.huawei.day05包里创建Person类

1. package net.zyf.day05

3. /**

4. * 功能：

5. * 作者：zyf

6. * 时间：2023年03月00号

7. */

9. // 伴生类

10. class Person (val name: String, var age: Int = 18) {

11. def speak(): Unit = println("我叫" + name + "，今年" + age + "岁了~")

12. }

14. // 伴生对象

15. object Person {

16. def main(args: Array[String]): Unit = {

17. // 基于主构造器创建对象，传入两个参数值

18. val person = new Person("李文华", 25)

20. // 访问构造器参数，其实是访问成员属性

21. println("姓名：" + person.name)

22. println("年龄：" + person.age)

24. // 调用对象的方法

25. person.speak()

27. // 修改对象属性（name属性不能改，age属性可以改）

28. person.age_=(26)

30. // 再次调用对象的方法

31. person.speak()

32. }

33. }

 

•  修改对象的name属性，要报错，因为主构造器的name参数是常量，所以类不提供设置属性的方法

•  因为主构造器第二个参数是有初始值，所以创建对象时可以不再初始化第二个参数，采用主构造器参数的初始值

2、构造器参数带访问权限

• 可以通过对主构造器的参数添加访问修饰符来控制参数的访问权限
• 创建Person类，将参数age设置为私有的，参数name设置为不可修改（val）

1. class Person (val name: String, private var age: Int) {

3. }

• 系统会为name属性添加一个公共的get方法
• 系统会为age属性添加一个私有的get和set方法

3、构造器参数不带var或val

• 构造参数也可以不带val或var，此时默认为private[this] val，这样会被编译成类的本地私有成员，不会生成get和set方法，只能在类的内部访问。

1. class Person (name: String, age: Int) {

3. }

• 可以改写成带访问权限的参数

1. class Person (private[this] val name: String, private[this] val age: Int) {

3. }

4、类的初始化语句

• 主构造器执行时，类中定义的语句作为初始化语句
• 在net.huawei.day05包里创建Dog类

1. package net.zyf.day05

3. /**

4. * 功能：

5. * 作者：zyf

6. * 时间：2023年03月00号

7. */

8. class Dog (var name: String, var age: Int){

9. name = "瑞瑞"

10. age = 5

11. println("主构造器被调用了~")

13. def speak(): Unit = println("我叫" + name + "，今年" + age + "岁了~")

14. }

16. // 伴生对象

17. object Dog {

18. def main(args: Array[String]): Unit = {

19. val dog = new Dog("", 0)

20. dog.speak()

21. }

22. }

• 说明：实例化Dog时，传入的参数是""与0，但是会执行类里的两个给成员变量赋值的语句，于是name成了瑞瑞，age成了5，于是调用对象的speak()方法，会输出我叫瑞瑞，今年5岁了~。

5、私有化构造器

• 如果需要将整个主构造器设置为私有的，那么只需要添加private关键字即可，注意，只有伴生对象里才能调用私有构造器来实例化，非伴生对象里就不能调用私有构造器来实例化
• 在net.huawei.day05包里创建Cat类

1. package net.zyf.day05

3. /**

4. * 功能：类

5. * 作者：zyf

6. * 日期：2023年03月日

7. */

8. // 伴生类

9. class Cat private (var name: String, var age: Int) {

10. def speak(): Unit = {

11. println("我叫" + name + "，今年" + age + "岁了~")

12. }

13. }

15. // 伴生对象

16. object Cat {

17. def main(args: Array[String]): Unit = {

18. val cat = new Cat("欢欢", 2)

19. cat.speak()

20. }

21. }

•  如果改成非伴生对象TestCat，报错：私有构造器不能被非伴生对象TestCat访问

6、无参构造器

• 主构造器也可以没有参数，一个类中如果没有显式地定义主构造器，就默认有一个无参构造器。
• 在net.huawei.day05包里创建Bird类

 

1. package net.zyf.day05

3. /**

4. * 功能：鸟类

5. * 作者：zyf

6. * 日期：2023年03月日

7. */

8. // 伴生类

9. class Bird () { // 显式定义无参构造器

10. var name = "玲玲"

11. var age = 4

13. def speak(): Unit = {

14. println("我叫" + name + "，今年" + age + "岁了~")

15. }

16. }

18. // 伴生对象

19. object Bird {

20. def main(args: Array[String]): Unit = {

21. val bird = new Bird() // 调用无参构造器实例化

22. bird.speak()

23. }

24. }

（二）辅助构造器

• Scala类除了可以有主构造器外，还可以有任意多个辅助构造器。

1、定义辅助构造器的注意事项

• 辅助构造器的方法名称为this
• 每一个辅助构造器的方法体中必须首先调用其他已定义的构造器
• 辅助构造器的参数不能使用var或val进行修饰

2、案例演示

（1）无参主构造器与有参辅助构造器

• 在net.hw.constructor包里创建Student类

1. package net.zyf.day05

3. /**

4. * 功能：演示辅助构造器

5. * 作者：zyf

6. * 时间：2023年03月00号

7. */

8. // 伴生类

9. class Student {

10. private var name = "李林芮"

11. private var age = 18

13. // 定义单参辅助构造器

14. def this(name: String) = {

15. this() // 调用无参主构造器

16. this.name = name

17. }

19. // 定义双参辅助构造器

20. def this(name: String, age: Int) = {

21. this(name) // 调用单参辅助构造器

22. this.age = age

23. }

25. // 重写toString方法

26. override def toString: String = "我叫" + name + "，今年" + age + "岁了~"

27. }

29. // 伴生对象

30. object Student {

31. def main(args: Array[String]): Unit = {

32. // 调用无参构造器实例化

33. val student1 = new Student()

34. println(student1)

35. // 调用单参辅助构造器实例化

36. val student2 = new Student("王晓琳")

37. println(student2)

38. // 调用双参辅助构造器实例化

39. val student3 = new Student("张智霖", 21)

40. println(student3)

41. }

42. }

运行结果 

• 课堂练习：用Java程序来完成上述任务

（2）有参主构造器与有参辅助构造器

• 主构造器还可以与辅助构造器同时使用，在这种情况下，一般辅助构造器的参数要多于主构造器
• 在net.huawei.day05包里创建Teacher类

1. package net.zyf.day05

3. /**

4. * 功能：教师类

5. * 作者：zyf

6. * 时间：2023年03月00号

7. */

8. class Teacher (private var name: String, private var age: Int){ // 双参主构造器

9. private var gender = ""

11. // 三参辅助构造器

12. def this(name: String, age: Int, gender: String) = {

13. this(name, age) // 调用双参主构造器

14. this.gender = gender

15. }

17. // 重写toString方法

18. override def toString: String = "我叫" + name + "，" + gender + "，今年" + age + "岁了~"

19. }

21. // 伴生对象

22. object Teacher {

23. def main(args: Array[String]): Unit = {

24. // 调用三参辅助构造器实例化

25. val teacher = new Teacher("无心剑", 50, "男")

26. println(teacher)

27. }

28. }

六、抽象类

（一）抽象类的定义

• Scala的抽象类使用关键字abstract定义

1. abstract class 类名 {

3. }

（二）抽象类的特征

1. 抽象类不能被实例化。
2. 抽象类中可以定义抽象字段（没有初始化的字段）和抽象方法（没有被实现的方法），也可以定义被初始化的字段和被实现的方法。
3. 若某个子类继承了一个抽象类，则必须实现抽象类中的抽象字段和抽象方法，且实现的过程中可以添加override关键字，也可以省略。若重写了抽象类中已经实现的方法，则必须添加override关键字。
    

（三）案例演示

1、创建抽象类 - Person

• 在net.huawei.day06包里创建Person抽象类

1. package net.zyf.day06

3. /**

4. * 功能：抽象人类类

5. * 作者：zyf

6. * 日期：2023年03月日

7. */

8. abstract class Person {

9. var name: String // 抽象字段

10. var age: Int // 抽象字段

11. var address: String = "龙马潭区长桥路2号" // 普通字段

13. // 抽象方法

14. def speak()

16. // 普通方法

17. def walk(): Unit = {

18. println(name + "在散步~")

19. }

20. }

2、继承抽象类，创建普通类 - Teacher

• 在net.huawei.day06包里创建Teacher普通类

3、创建测试对象 - TestTeacher

• 在net.huawei.day06包里创建TestTeacher对象

 

4、运行程序，查看结果

• 运行TestTeacher对象

 5、简要说明

• 需要注意的是，上述Teacher类中speak()方法的地址字段（address）是从父类（抽象类Person）中继承而来的。由于该字段在Person中有初始化值，不是抽象字段，若需要在Teacher类中修改该字段的值，则可以在Teacher类的构造函数或其它方法中使用this.address对其重新赋值。例如，将地址改为“江阳区前进中路3号”，可以使用以下代码：this.address="江阳区前进中路3号"。

 七、特质

（一）特质的概念

• Scala特质使用关键字trait定义，类似Java 8中使用interface定义的接口。特质除了有Java接口的功能外，还有一些特殊的功能。Scala特质中，字段和方法的定义与Scala抽象类一样，可以定义抽象字段和抽象方法、非抽象字段和非抽象方法。

（二）特质的定义

1、语法格式

1. trait 特质名 {

2. // 抽象字段

3. // 抽象方法

4. // 普通字段

5. // 普通方法

6. }

2、案例演示

任务1、创建宠物特质 - Pet

• 在net.huawei.day07包里创建Pet特质

任务2、创建奔跑特质 - Runnable

• 在net.huawei.day07包里创建Runnable特质

任务3、创建飞翔特质 - Flyable

• 在net.huawei.day07包里创建Flyable特质

（三）特质的实现

• 类可以使用关键字extends实现特质，但必须实现特质中未实现的字段和方法（抽象字段和抽象方法），这一点与继承抽象类是一致的。

1、语法格式

（1）实现一个特质

1. class 类名 extends 特质名 {

2. // 实现抽象字段

3. // 实现抽象方法

4. }

（2）实现多个特质

• 如果需要实现的特质不止一个，那么可以通过with关键字添加额外特质，但位于最左侧的特质必须使用extends关键字。

1. class 类名 extends 特质名1 with 特质名2 with 特质名3 …… with 特质名n {

2. // 实现抽象字段

3. // 实现抽象方法

4. }

2、案例演示

任务1、实现一个特质

• 在net.huawei.day07包里创建Cat类，实现Pet特质

• 运行程序，查看结果
   

任务2、实现多个特质

• 在net.huawei.day07包里创建Bird类，实现Pet、Runnable、Flyable特质

• 运行程序，查看结果