零、本节学习目标

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

一、类

（一）类的定义

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

class User {private var name = "张三丰"private var gender = "男"private var age = 25def speak(): Unit = println(name + ", " + gender + ", 今年" + age + "岁了~")
}

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

（二）类的实例化

• 关键字new用于创建类的实例
• 实例化User类，调用其speak()方法
  
• 访问私有属性name，系统会报错
  
• 怎么才能访问类的私有属性呢？后面我们会定义setter和getter来访问私有属性。

二、单例对象

（一）单例对象概念

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

（二）案例演示

• 创建Person单例对象，包含三个私有属性和一个公共方法
  

object Person {private var name = "陈燕文"private var gender = "女"private var age = 18def speak(): Unit = println(name + ", " + gender + ", 今年" + age + "岁了~")
}

• 直接通过单例对象名调用其speak()方法
  

三、伴生对象

（一）伴生对象概念

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

（二）案例演示

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

package net.hw.obj/*** 功能：演示伴生对象* 作者：华卫* 日期：2022年05月14日*/
class Student {private var name = "李明文"def speak(): Unit = {// 访问伴生对象的私有成员println(name + "今年" + Student.age + "岁了。")}
}object Student {private var age = 18def main(args: Array[String]): Unit = {// 基于伴生类创建学生对象val student = new Student()// 访问伴生类对象的私有成员println("姓名：" + student.name)// 调用伴生类对象的方法student.speak()}
}

• 运行程序，查看结果
  

四、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.hw.obj包里创建Dog类
  

package net.hw.obj/*** 功能：狗类* 作者：华卫* 日期：2022年05月14日*/
class Dog {val id: Int = 1 // 系统会自动生成公共的get方法var name: String = "瑞瑞" // 系统会自动生成公共的get和set方法private var gender: String = "公" // 系统会自动生成私有的get和set方法，只有伴生对象可以访问private[this] var age: Int = 5 // 系统不会生成get和set方法，即使伴生对象也无法访问
}

（2）编译成字节码文件

• 将Dog.scala编译成Dog.class
  
• 在项目的out目录里，逐层点开，找到Dog，那就是生成字节码文件
  
  

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

• 使用Java反编译工具将字节码文件反编译为Java代码
  

package net.hw.obj;import scala.reflect.ScalaSignature;@ScalaSignature(bytes = "\006\001m2A!\001\002\001\023\t\031Ai\\4\013\005\r!\021aA8cU*\021QAB\001\003Q^T\021aB\001\004]\026$8\001A\n\003\001)\001\"a\003\b\016\0031Q\021!D\001\006g\016\fG.Y\005\003\0371\021a!\0218z%\0264\007\"B\t\001\t\003\021\022A\002\037j]&$h\bF\001\024!\t!\002!D\001\003\021\0351\002A1A\005\002]\t!!\0333\026\003a\001\"aC\r\n\005ia!aA%oi\"1A\004\001Q\001\na\t1!\0333!\021\035q\002\0011A\005\002}\tAA\\1nKV\t\001\005\005\002\"I9\0211BI\005\003G1\ta\001\025:fI\0264\027BA\023'\005\031\031FO]5oO*\0211\005\004\005\bQ\001\001\r\021\"\001*\003!q\027-\\3`I\025\fHC\001\026.!\tY1&\003\002-\031\t!QK\\5u\021\035qs%!AA\002\001\n1\001\037\0232\021\031\001\004\001)Q\005A\005)a.Y7fA!9!\007\001a\001\n\023y\022AB4f]\022,'\017C\0045\001\001\007I\021B\033\002\025\035,g\016Z3s?\022*\027\017\006\002+m!9afMA\001\002\004\001\003B\002\035\001A\003&\001%A\004hK:$WM\035\021\t\ri\002\001\025)\003\031\003\r\tw-\032")
public class Dog {private final int id = 1;public int id() {return this.id;}private String name = ";public String name() {return this.name;}public void name_$eq(String x$1) {this.name = x$1;}private String gender = ";private String gender() {return this.gender;}private void gender_$eq(String x$1) {this.gender = x$1;}private int age = 5;
}

（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单例对象
  

package net.hw.obj/*** 功能：测试狗类* 作者：华卫* 日期：2022年03月08日*/
object TestDog {def main(args: Array[String]): Unit = {// 创建Dog对象var dog: Dog = new Dog()// 访问id属性println("id: " + dog.id)// 设置name属性dog.name = "欢欢"// 访问name属性println("name: " + dog.name)}
}

• 运行程序，查看结果
  

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

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

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

• 运行程序，查看结果
  

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

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

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

• 注意：set方法的写法 —— 方法名_=
• 创建Cat类
  

package net.hw.obj/*** 功能：猫类* 作者：华卫* 日期：2022年05月14日*/
class Cat {private var privateName: String = "虎丸"// 定义get方法 - namedef name: String = privateName// 定义set方法 - name_=def name_=(name: String): Unit = {privateName = name}
}/*** 伴生对象*/
object Cat {def main(args: Array[String]): Unit = {val cat: Cat = new Cat()println("原来的名字：" + cat.name)cat.name_=("冰轮丸")println("现在的名字：" + cat.name)}
}

• 运行程序，查看结果
  

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

• 注意：get方法 —— getXXX()，set方法——setXXX()
• 创建Bird类
  

package net.hw.obj/*** 功能：鸟类* 作者：华卫* 日期：2022年05月14日*/
class Bird {private var name = "玲玲"// Java风格的get方法def getName: String = name// Java风格的set方法def setName(name: String): Unit = {this.name = name}
}/*** 伴生对象*/
object Bird {def main(args: Array[String]): Unit = {val bird = new Bird()println("原来的名字：" + bird.getName)bird.setName("菲菲")println("现在的名字：" + bird.getName)}
}

• 运行程序，查看结果
  

五、构造器

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

（一）主构造器

1、构造器参数带val或var

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

package net.hw.collection/*** 功能：人类* 作者：华卫* 日期：2022年05月14日*/
class Person (val name: String, var age: Int = 18) {def speak(): Unit = println(name + "今年" + age + "岁了~")
}/*** 伴生对象*/
object Person {def main(args: Array[String]): Unit = {// 基于主构造器创建对象，传入两个参数值val person = new Person("李文华", 25)// 访问构造器参数，其实是访问成员属性println("姓名：" + person.name)println("年龄：" + person.age)// 调用对象的方法person.speak()// 修改对象属性（name属性不能改，age属性可以改）person.age_=(26)// 再次调用对象的方法person.speak()}
}

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

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

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

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

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

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

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

class Person (name: String, age: Int) {}

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

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

4、类的初始化语句

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

package net.hw.constructor/*** 功能：狗类* 作者：华卫* 日期：2022年05月14日*/
class Dog (var name: String, var age: Int){name = "瑞瑞"age = 5println("主构造器被调用了~")def speak(): Unit = println(name + "今年" + age + "岁了~")
}// 伴生对象
object Dog {def main(args: Array[String]): Unit = {val dog = new Dog("", 0)dog.speak()}
}

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

5、私有化构造器

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

package net.hw.constructor/*** 功能：猫类* 作者：华卫* 日期：2022年03月08日*/
class Cat private (var name: String, var age: Int) {def speak(): Unit = {println(name + "今年" + age + "岁了~")}
}// 伴生对象
object Cat {def main(args: Array[String]): Unit = {val cat = new Cat("欢欢", 2)cat.speak()}
}

• 运行程序，查看结果
  
• 如果改成非伴生对象TestCat，报错：私有构造器不能被非伴生对象TestCat访问
  

6、无参构造器

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

package net.hw.constructor/*** 功能：鸟类* 作者：华卫* 日期：2022年03月08日*/
class Bird () { // 显式定义无参构造器var name = "玲玲"var age = 4def speak(): Unit = {println(name + "今年" + age + "岁了~")}
}// 伴生对象
object Bird {def main(args: Array[String]): Unit = {val bird = new Bird() // 调用无参构造器实例化bird.speak()}
}

• 运行程序，查看结果
  
• 其实，去掉类名Bird后面的()，系统依然会提供一个无参构造器，程序运行不会报错
  

（二）辅助构造器

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

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

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

2、案例演示

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

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

package net.hw.constructor/*** 功能：演示辅助构造器* 作者：华卫* 日期：2022年03月08日*/
class Student {private var name = "李林芮"private var age = 18// 定义单参辅助构造器def this(name: String) = {this() // 调用无参主构造器this.name = name}// 定义双参辅助构造器def this(name:String, age: Int) = {this(name) // 调用单参辅助构造器this.age = age}// 重写toString方法override def toString: String = name + "今年" + age + "岁了~"
}// 伴生对象
object Student {def main(args: Array[String]): Unit = {// 调用无参构造器实例化val student1 = new Student()println(student1)// 调用单参辅助构造器实例化val student2 = new Student("王晓琳")println(student2)// 调用双参辅助构造器实例化val student3 = new Student("张智霖", 21)println(student3)}
}

• 运行程序，查看结果
  

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

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

package net.hw.constructor/*** 功能：教师类* 作者：华卫* 日期：2022年03月08日*/
class Teacher (private var name: String, private var age: Int){ // 双参主构造器private var gender = ""// 三参辅助构造器def this(name: String, age: Int, gender: String) = {this(name, age) // 调用双参主构造器this.gender = gender}// 重写toString方法override def toString: String = name + "，" + gender + "，今年" + age + "岁了~"
}// 伴生对象
object Teacher {def main(args: Array[String]): Unit = {// 调用三参辅助构造器实例化val teacher = new Teacher("无心剑", 50, "男")println(teacher)}
}

• 运行程序，查看结果
  

六、抽象类

（一）抽象类的定义

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

abstract class 类名 {}

（二）抽象类的特征

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

（三）案例演示

1、创建抽象类 - Person

• 在net.hw.absclass包里创建Person抽象类
  

package net.hw.absclass/*** 功能：抽象人类* 作者：华卫* 日期：2022年03月08日*/
abstract class Person {var name: String // 抽象字段var age: Int // 抽象字段var address: String = "龙马潭区长桥路2号" // 普通字段// 抽象方法def speak()// 普通方法def walk(): Unit = {print(name + "在散步~")}
}

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

• 在net.hw.absclass包里创建Teacher普通类
  

package net.hw.absclass/*** 功能：教师类* 作者：华卫* 日期：2022年03月08日*/
class Teacher extends Person {// 实现抽象字段（可以不加override）var name: String = "无心剑"var age: Int = 50// 实现抽象方法，不用加overridedef speak(): Unit = {println(name + "，今年" + age + "岁，家住" + address + "，擅长讲课与翻译。" )}// 重写普通方法，必须加overrideoverride def walk(): Unit = {println(name + "喜欢雨中漫步~")}
}

3、创建测试单例对象 - TestTeacher

• 在net.hw.absclass包里创建TestTeacher单例对象
  

package net.hw.absclass/*** 功能：测试教师类* 作者：华卫* 日期：2022年03月08日*/
object TestTeacher {def main(args: Array[String]): Unit = {// 创建教师对象val teacher = new Teacher()// 调用对象方法teacher.speak()teacher.walk()}
}

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、语法格式

trait 特质名 {// 抽象字段// 抽象方法// 普通字段// 普通方法
}

2、案例演示

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

• 在net.hw.mytrait包里创建Pet特质
  

package net.hw.mytrait/*** 功能：宠物特质* 作者：华卫* 日期：2022年03月08日*/
trait Pet {// 抽象字段var name: Stringvar age: Int// 抽象方法def speak// 普通方法def eat: Unit = {print(name + "在吃东西~")}
}

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

• 在net.hw.mytrait包里创建Runnable特质
  

package net.hw.mytrait/*** 功能：奔跑特质* 作者：华卫* 日期：2022年03月08日*/
trait Runnable {// 抽象方法def run
}

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

• 在net.hw.mytrait包里创建Flyable特质
  

package net.hw.mytrait/*** 功能：飞翔特质* 作者：华卫* 日期：2022年03月08日*/
trait Flyable {// 抽象方法def fly
}

（三）特质的实现

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

1、语法格式

（1）实现一个特质

class 类名 extends 特质名 {// 实现抽象字段// 实现抽象方法
}

（2）实现多个特质

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

class 类名 extends 特质名1 with 特质名2 with 特质名3 …… with 特质名n {// 实现抽象字段// 实现抽象方法
}

2、案例演示

任务1、实现一个特质

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

package net.hw.mytrait/*** 功能：猫类* 作者：华卫* 日期：2022年03月08日*/
class Cat extends Pet {// 实现抽象字段var name: String = "虎丸"var age: Int = 3// 实现抽象方法def speak: Unit = {println(name + "今年" + age + "岁了~")}// 重写普通方法override def eat: Unit = {println(name + "在吃鱼虾~")}
}// 伴生对象
object Cat {def main(args: Array[String]): Unit = {// 创建猫对象val cat = new Cat()// 调用对象方法cat.speakcat.eat}
}

• 运行程序，查看结果
  

任务2、实现多个特质

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

package net.hw.mytrait/*** 功能：鸟类* 作者：华卫* 日期：2022年03月08日*/
class Bird extends Pet with Runnable with Flyable {var name: String = "玲玲"var age: Int = 2def speak: Unit = {println("鸟儿[" + name + "]今年" + age + "岁了~")}def run: Unit = {println("鸟儿[" + name + "]在欢快地奔跑~")}def fly: Unit = {println("鸟儿[" + name + "]在自由地飞翔~")}
}// 伴生对象
object Bird {def main(args: Array[String]): Unit = {// 创建鸟对象val bird = new Bird()// 调用对象方法bird.speakbird.runbird.fly}
}

• 运行程序，查看结果
  

八、课后作业

任务：学生喂养三种宠物

• 创建Animal特质，包含抽象字段：name和age，抽象方法：speak和eat
• 实现Animal特质，创建Dog类，包含双参主构造器，实现抽象字段和抽象方法
• 实现Animal特质，创建Cat类，包含双参主构造器，实现抽象字段和抽象方法
• 实现Animal特质，创建Bird类，包含双参主构造器，实现抽象字段和抽象方法
• 创建Student类，包含单参name构造器，包含普通方法feed，参数animal是Animal类型，方法里调用animal的speak和eat方法
• 创建TestStudent单例对象
  
• 运行程序，查看结果