快速入门scala—scala(类与对象)

上期我们讲到scala的函数式编程，今天我们就来了解一下scala的类和对象吧。不多bb，废话只会耽误你们学习的时间。下面我们进入正题吧

1、类和对象成员的定义

1.1、创建类和对象

用法

• 使用class来定义一个类
• 使用new来创建对象

示例
创建一个Person类，并创建它的对象

步骤

1. 创建一个scala项目，并创建一个Object
2. 添加main方法
3. 创建类和对象

实现

1. 在IDEA中创建项目，并创建一个Object（main方法必须放在Object中）
2. 添加main方法
3. 创建一个Person类
4. 在main方法中创建Person类对象

参考代码

object _01ClassDemo {// 创建类class Person{}def main(args: Array[String]): Unit = {// 创建对象val p = new Person()println(p)}
}

1.1.1、简写方式

用法

• 如果类是空的，没有任何成员，可以省略{}

• 如果构造器的参数为空，可以省略()

示例

使用简写方法重新创建Person类和对象

参考代码

object _02ClassDemo {// 创建类，省略花括号class Persondef main(args: Array[String]): Unit = {// 创建对象，省略括号val person = new Person}
}

1.2、定义和访问成员变量

用法

• 在类中使用var/val来定义成员变量
• 对象直接使用成员变量名称来访问成员变量

示例

1. 定义一个Person类，包含一个姓名和年龄字段
2. 创建一个名为"张三"、年龄为20岁的对象
3. 打印对象的名字和年龄

步骤

1. 创建一个Object，添加main方法
2. 创建Person类，添加姓名字段和年龄字段，并对字段进行初始化，让scala自动进行类型推断
3. 在main方法中创建Person类对象，设置成员变量为"张三"、20
4. 打印对象的名字和年龄

参考代码

object _03ClassDemo {class Person {// 定义成员变量var name = ""var age = 0}def main(args: Array[String]): Unit = {// 创建Person对象val person = new Personperson.name = "zhangsan"person.age = 20// 获取变量值println(person.name)println(person.age)}
}

1.3、使用下划线初始化成员变量

scala中有一个更简洁的初始化成员变量的方式，可以让代码看起来更加简洁。

用法

• 在定义var类型的成员变量时，可以使用_来初始化成员变量
  • String => null
  • Int => 0
  • Boolean => false
  • Double => 0.0
  • …
• val类型的成员变量，必须要自己手动初始化

示例

1. 定义一个Person类，包含一个姓名和年龄字段
2. 创建一个名为"张三"、年龄为20岁的对象
3. 打印对象的名字和年龄

步骤

1. 创建一个Object，添加main方法
2. 创建Person类，添加姓名字段和年龄字段，指定数据类型，使用下划线初始化
3. 在main方法中创建Person类对象，设置成员变量为"张三"、20
4. 打印对象的名字和年龄

参考代码

object _04ClassDemo {class Person{// 使用下划线进行初始化var name:String = _var age:Int = _}def main(args: Array[String]): Unit = {val person = new Personprintln(person.name)println(person.age)}
}

1.4、定义成员方法

类可以有自己的行为，scala中也可以通过定义成员方法来定义类的行为。

定义
在scala的类中，也是使用def来定义成员方法

示例
1.创建一个Customer类,Custormer有两个成员变量 name(String),sex(String)
2.创建一个该类的对象，并调用printHello方法
步骤

1. 创建一个Object，添加main方法
2. 创建Customer类，添加成员变量、成员方法
3. 在main方法中创建Customer类对象，设置成员变量值(张三、男)
4. 调用成员方法

参考代码

object _05ClassDemo {class Customer {var name:String = _var sex:String = _// 定义成员方法def sayHi(msg:String) = {println(msg)}}def main(args: Array[String]): Unit = {val customer = new Customercustomer.name = "张三"customer.sex = "男"customer.sayHi("你好")}
}

1.5、访问修饰符

和Java一样，scala也可以通过访问修饰符，来控制成员变量和成员方法是否可以被访问。

定义
Java中的访问控制，同样适用于scala，可以在成员前面添加private/protected关键字来控制成员的可见性。但在scala中，没有public关键字，任何没有被标为private或protected的成员都是公共的

案例
1.定义一个Person类

2.在main方法中创建该类的对象，测试是否能够访问到私有成员

参考代码

object _02AccessDemo {class Person {// 定义私有成员变量private var name:String = _private var age:Int = _def getName() = namedef setName(name:String) = this.name = namedef getAge() = agedef setAge(age:Int) = this.age = age// 定义私有成员方法private def getNameAndAge = {name -> age}}def main(args: Array[String]): Unit = {val person = new Personperson.setName("张三")person.setAge(10)println(person.getName())println(person.getAge())}
}

2、类的构造器

当创建类对象的时候，会自动调用类的构造器。之前使用的都是默认构造器，我们接下来要学习如何自定义构造器。

2.1、主构造器

语法

class 类名(var/val 参数名:类型 = 默认值, var/val 参数名:类型 = 默认值){// 构造代码块
}

[!NOTE]

• 主构造器的参数列表是直接定义在类名后面，添加了val/var表示直接通过主构造器定义成员变量
• 构造器参数列表可以指定默认值
• 创建实例，调用构造器可以指定字段进行初始化
• 整个class中除了字段定义和方法定义的代码都是构造代码

示例

1. 定义一个Person类，通过主构造器参数列表定义姓名和年龄字段，并且设置它们的默认值
2. 在主构造器中输出"调用主构造器"
3. 创建"张三"对象（姓名为张三，年龄为20），打印对象的姓名和年龄
4. 创建"空"对象，不给构造器传入任何的参数，打印对象的姓名和年龄
5. 创建"man40"对象，不传入姓名参数，指定年龄为40，打印对象的姓名和年龄

参考代码

object _06ConstructorDemo {// 定义类的主构造器// 指定默认值class Person(var name:String = "", var age:Int = 0) {println("调用主构造器")}def main(args: Array[String]): Unit = {// 给构造器传入参数val zhangsan = new Person("张三", 20)println(zhangsan.name)println(zhangsan.age)println("---")// 不传入任何参数val empty = new Personprintln(empty.name)println(empty.age)println("---")// 指定字段进行初始化val man40 = new Person(age = 40)println(man40.name)println(man40.age)}
}

2.2、辅助构造器

在scala中，除了定义主构造器外，还可以根据需要来定义辅助构造器。例如：允许通过多种方式，来创建对象，这时候就可以定义其他更多的构造器。我们把除了主构造器之外的构造器称为辅助构造器。

语法

• 定义辅助构造器与定义方法一样，也使用def关键字来定义
• 这个方法的名字为this

def this(参数名:类型, 参数名:类型) {// 第一行需要调用主构造器或者其他构造器// 构造器代码
}

[!DANGER]

辅助构造器的第一行代码，必须要调用主构造器或者其他辅助构造器

示例

示例说明

• 定义一个Customer类，包含一个姓名和地址字段
• 定义Customer类的主构造器（初始化姓名和地址）
• 定义Customer类的辅助构造器，该辅助构造器接收一个数组参数，使用数组参数来初始化成员变量
• 使用Person类的辅助构造器来创建一个"zhangsan"对象
  • 姓名为张三
  • 地址为北京
• 打印对象的姓名、地址

参考代码

object _07ConstructorDemo {class Customer(var name:String = "", var address:String = "") {// 定义辅助构造器def this(arr:Array[String]) = {// 辅助构造器必须要调用主构造器或者其他辅助构造器this(arr(0), arr(1))}}def main(args: Array[String]): Unit = {val zhangsan = new Customer(Array("张三", "北京"))println(zhangsan.name)println(zhangsan.address)}
}

3、单例对象

scala中没有Java中的静态成员，我们想要定义类似于Java的static变量、static方法，就要使用到scala中的单例对象——object.

3.1、定义单例对象

单例对象表示全局仅有一个对象（类似于Java static概念）

• 定义单例对象和定义类很像，就是把class换成object
• 在object中定义的成员变量类似于Java的静态变量
• 可以使用object直接引用成员变量

示例
示例说明

• 定义一个Dog单例对象，保存狗有几条腿
• 在main方法中打印狗腿的数量

参考代码

object _08ObjectDemo {// 定义一个单例对象object Dog {// 定义腿的数量val LEG_NUM = 4}def main(args: Array[String]): Unit = {println(Dog.LEG_NUM)}
}

3.2、在单例对象中定义成员方法

在object中定义的成员方法类似于Java的静态方法
示例

示例说明

• 设计一个单例对象，定义一个能够打印分割线（15个减号）的方法
• 在main方法调用该方法，打印分割线

参考代码

object _09ObjectDemo {object PrintUtil {// 打印分割线def printSpliter() = {// 字符串乘法，表示返回多少个字符串println("-" * 10)}}def main(args: Array[String]): Unit = {PrintUtil.printSpliter()}
}

3.3、工具类案例

需求

• 编写一个DateUtil工具类专门用来格式化日期时间
• 定义一个方法，用于将日期（Date）转换为年月日字符串，例如：2030-10-05

步骤

• 定义一个DateUtil单例对象，定义日期格式化方法（format）
• 使用SimpleDateFormat将日期转换为字符串

参考代码

object _10ObjectDemo {object DateUtils {// 在object中定义的成员变量，相当于Java中定义一个静态变量// 定义一个SimpleDateFormat日期时间格式化对象val simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm")// 相当于Java中定义一个静态方法def format(date: Date) = simpleDateFormat.format(date)}// main是一个静态方法，所以必须要写在object中def main(args: Array[String]): Unit = {println(DateUtils.format(new Date()))}
}

##4、main方法
scala和Java一样，如果要运行一个程序，必须有一个main方法。而在Java中main方法是静态的，而在scala中没有静态方法。在scala中，这个main方法必须放在一个单例对象中。

4.1、定义main方法

main方法

def main(args:Array[String]):Unit = {// 方法体
}

示例

示例说明

• 创建一个单例对象，在该单例对象中打印"hello, scala"

参考代码

object Main5 {def main(args:Array[String]) = {println("hello, scala")}
}

4.2、实现App Trait来定义入口

创建一个object，继承自App Trait（特质），然后将需要编写在main方法中的代码，写在object的构造方法体内。

object 单例对象名 extends App {// 方法体
}

示例

示例说明

• 继承App特质，来实现一个入口。同样输出"hello, scala"

参考代码

object Main5 extends App {println("hello, scala")
}

5、伴生对象

在Java中，经常会有一些类，同时有实例成员又有静态成员。例如：

public class CustomerService {private static String SERVICE_NAME = "CustomerService";public void save() {// 保存客户System.out.println(SERVICE_NAME + ":保存客户");}public static void main(String[] args) {new CustomerService().save();}
}

在scala中，要实现类似的效果，可以使用伴生对象来实现。
我们还可以使用伴生对象来实现快速创建对象，例如：

// 无需使用new就可以快速来创建对象
val a = Array(1,2,3)
val b = Set(1,2,3)

5.1、定义伴生对象

一个class和object具有同样的名字。这个object称为伴生对象，这个class称为伴生类

• 伴生对象必须要和伴生类一样的名字
• 伴生对象和伴生类在同一个scala源文件中
• 伴生对象和伴生类可以互相访问private属性

示例

示例说明

• 编写一个CustomerService类，有一个save方法，打印

  服务类名称:保存客户
  

• 编写一个CustomerService伴生对象，定义一个私有变量，用于保存服务类名称

• 创建CustomerService对象，调用save方法

参考代码

object _11ObjectDemo {class CustomerService {def save() = {println(s"${CustomerService.SERVICE_NAME}:保存客户")}}// CustomerService的伴生对象object CustomerService {private val SERVICE_NAME = "CustomerService"}def main(args: Array[String]): Unit = {val customerService = new CustomerService()customerService.save()}
}

5.2、private[this]访问权限

如果某个成员的权限设置为private[this]，表示只能在当前类中访问。伴生对象也不可以访问

示例

示例说明

• 定义一个Person类，包含一个name字段
• 定义Person类的伴生对象，定义printPerson方法
• 测试伴生对象是否能访问private[this]权限的成员

示例代码

  class Person(private[this] var name:String)object Person {def printPerson(person:Person): Unit = {println(person.name)}}def main(args: Array[String]): Unit = {val person = new Person("张三")Person.printPerson(person)}

上述代码，会编译报错。但移除掉[this]就可以访问了

5.3、伴生对象 | apply方法

我们之前使用过这种方式来创建一个Array对象。

// 创建一个Array对象
val a = Array(1,2,3,4)

这种写法非常简便，不需要再写一个new，然后敲一个空格，再写类名。我们可以通过伴生对象的apply方法来实现。

定义

定义apply方法

object 伴生对象名 {def apply(参数名:参数类型, 参数名:参数类型...) = new 类(...)
}

创建对象

伴生对象名(参数1, 参数2...)

示例

示例说明

• 定义一个Person类，它包含两个字段：姓名和年龄
• 重写apply方法，使用Person类名就可以创建对象
• 在main方法中创建该类的对象，并打印姓名和年龄

参考代码

object _12ApplyDemo {class Person(var name:String = "", var age:Int = 0)object Person {// 定义apply方法，接收两个参数def apply(name:String, age:Int) = new Person(name, age)}def main(args: Array[String]): Unit = {// 使用伴生对象名称来创建对象val zhangsan = Person("张三", 20)println(zhangsan.name)println(zhangsan.age)}
}

6、继承

scala语言是支持面向对象编程的，我们也可以使用scala来实现继承，通过继承来减少重复代码。

定义语法

• scala和Java一样，使用extends关键字来实现继承
• 可以在子类中定义父类中没有的字段和方法，或者重写父类的方法
• 类和单例对象都可以从某个父类继承

语法

class/object 子类 extends 父类 {..
}

6.1、示例 | 类继承

• 定义一个Person类，再定义一个Student类，继承自Person类
  

• 创建一个Student类对象实例，并设置name为“张三”

• 打印姓名

参考代码

class Person {var name = "super"def getName = this.name
}class Student extends Personobject Main13 {def main(args: Array[String]): Unit = {val p1 = new Person()val p2 = new Student()p2.name = "张三"println(p2.getName)}
}

6.2、示例 | 单例对象继承

示例说明

• 创建一个Student单例对象，让单例对象继承示例1中的Person类
• 设置单例对象的名字为"张三"，调用Student单例对象的getName方法

class Person {var name = "super"def getName = this.name
}object Student extends Personobject Main13 {def main(args: Array[String]): Unit = {println(Student.getName)}
}

6.3、override和super

类似于Java语言，我们在子类中使用override需要来重写父类的成员，可以使用super来引用父类
用法

• 子类要覆盖父类中的一个方法，必须要使用override关键字

• 使用override来重写一个val字段

• 使用super关键字来访问父类的成员方法
  示例
  示例说明

• 定义一个Person类，包含

  • 姓名字段（不可重新赋值）
  • 获取姓名方法

• 定义一个Student类

  • 重写姓名字段
  • 重写获取姓名方法，返回"hello, " + 姓名

• 创建Student对象示例，调用它的getName方法
  参考代码

class Person {val name = "super"def getName = name
}class Student extends Person {// 重写val字段override val name: String = "child"// 重写getName方法override def getName: String = "hello, " + super.getName
}object Main13 {def main(args: Array[String]): Unit = {println(new Student().getName)}
}

7、类型判断

有时候，我们设计的程序，要根据变量的类型来执行对应的逻辑。

在scala中，如何来进行类型判断呢？

有两种方式：

• isInstanceOf
• getClass/classOf

7.1、 isInstanceOf/asInstanceOf

在Java中，我们可以使用instanceof关键字来判断类型、以及(类型)object来进行类型转换，在scala中如何实现呢？

scala中对象提供isInstanceOf和asInstanceOf方法。

• isInstanceOf判断对象是否为指定类的对象
• asInstanceOf将对象转换为指定类型
  用法

// 判断对象是否为指定类型
val trueOrFalse:Boolean = 对象.isInstanceOf[类型]
// 将对象转换为指定类型
val 变量 = 对象.asInstanceOf[类型]

示例
示例说明

• 定义一个Person类
• 定义一个Student类继承自Person类
• 创建一个Student类对象
• 判断该对象是否为Student类型，如果是，将其转换为Student类型并打印该对象

参考代码

class Person3
class Student3 extends Person3object Main3 {def main(args: Array[String]): Unit = {val s1:Person3 = new Student3// 判断s1是否为Student3类型if(s1.isInstanceOf[Student3]) {// 将s1转换为Student3类型val s2 =  s1.asInstanceOf[Student3]println(s2)}}
}

7.2、getClass和classOf

isInstanceOf 只能判断对象是否为指定类以及其子类的对象，而不能精确的判断出，对象就是指定类的对象。如果要求精确地判断出对象就是指定类的对象，那么就只能使用 getClass 和 classOf 。
用法

• p.getClass可以精确获取对象的类型

• classOf[x]可以精确获取类型

• 使用==操作符可以直接比较类型
  示例
  示例说明

• 定义一个Person类

• 定义一个Student类继承自Person类

• 创建一个Student类对象，并指定它的类型为Person类型

• 测试使用isInstance判断该对象是否为Person类型

• 测试使用getClass/classOf判断该对象是否为Person类型

• 测试使用getClass/classOf判断该对象是否为Student类型

参考代码

class Person4
class Student4 extends Person4object Student4{def main(args: Array[String]) {val p:Person4=new Student4//判断p是否为Person4类的实例println(p.isInstanceOf[Person4])//true//判断p的类型是否为Person4类println(p.getClass == classOf[Person4])//false//判断p的类型是否为Student4类println(p.getClass == classOf[Student4])//true}
}

8、抽象类

和Java语言一样，scala中也可以定义抽象类

定义

如果类的某个成员在当前类中的定义是不包含完整的，它就是一个抽象类

不完整定义有两种情况：

1. 方法没有方法体（抽象方法）
2. 变量没有初始化（抽象字段）

定义抽象类和Java一样，在类前面加上abstract关键字

// 定义抽象类
abstract class 抽象类名 {// 定义抽象字段val 抽象字段名:类型// 定义抽象方法def 方法名(参数:参数类型,参数:参数类型...):返回类型
}

8.2、抽象方法

示例

• 设计4个类，表示上述图中的继承关系
• 每一个形状都有自己求面积的方法，但是不同的形状计算面积的方法不同

步骤

1. 创建一个Shape抽象类，添加一个area抽象方法，用于计算面积
2. 创建一个Square正方形类，继承自Shape，它有一个边长的主构造器，并实现计算面积方法
3. 创建一个长方形类，继承自Shape，它有一个长、宽的主构造器，实现计算面积方法
4. 创建一个圆形类，继承自Shape，它有一个半径的主构造器，并实现计算面积方法
5. 编写main方法，分别创建正方形、长方形、圆形对象，并打印它们的面积

参考代码

// 创建形状抽象类
abstract class Shape {def area:Double
}// 创建正方形类
class Square(var edge:Double /*边长*/) extends Shape {// 实现父类计算面积的方法override def area: Double = edge * edge
}// 创建长方形类
class Rectangle(var length:Double /*长*/, var width:Double /*宽*/) extends Shape {override def area: Double = length * width
}// 创建圆形类
class Cirle(var radius:Double /*半径*/) extends Shape {override def area: Double = Math.PI * radius * radius
}object Main6 {def main(args: Array[String]): Unit = {val s1:Shape = new Square(2)val s2:Shape = new Rectangle(2,3)val s3:Shape = new Cirle(2)println(s1.area)println(s2.area)println(s3.area)}
}

8.3、抽象字段

在scala中，也可以定义抽象的字段。如果一个成员变量是没有初始化，我们就认为它是抽象的。

定义
语法

abstract class 抽象类 {val/var 抽象字段:类型
}

示例

示例说明

1. 创建一个Person抽象类，它有一个String抽象字段WHO_AM_I
2. 创建一个Student类，继承自Person类，重写WHO_AM_I字段，初始化为学生
3. 创建一个Policeman类，继承自Person类，重写WHO_AM_I字段，初始化警察
4. 添加main方法，分别创建Student/Policeman的实例，然后分别打印WHO_AM_I
   参考代码

// 定义一个人的抽象类
abstract class Person6 {// 没有初始化的val字段就是抽象字段val WHO_AM_I:String
}class Student6 extends Person6 {override val WHO_AM_I: String = "学生"
}class Policeman6 extends Person6 {override val WHO_AM_I: String = "警察"
}object Main6 {def main(args: Array[String]): Unit = {val p1 = new Student6val p2 = new Policeman6println(p1.WHO_AM_I)println(p2.WHO_AM_I)}
}

9、特质(trait)

scala中没有Java中的接口（interface），替代的概念是——特质
定义

• 特质是scala中代码复用的基础单元
• 它可以将方法和字段定义封装起来，然后添加到类中
• 与类继承不一样的是，类继承要求每个类都只能继承一个超类，而一个类可以添加任意数量的特质。
• 特质的定义和抽象类的定义很像，但它是使用trait关键字

语法

定义特质

trait 名称 {// 抽象字段// 抽象方法
}

继承特质

class 类 extends 特质1 with 特质2 {   // 字段实现    // 方法实现}

9.1、trait作为接口使用

trait作为接口使用，与java的接口使用方法一样。

9.1.1、 示例 | 继承单个trait

---

示例说明

1. 创建一个Logger特质，添加一个接受一个String类型参数的log抽象方法
2. 创建一个ConsoleLogger类，继承Logger特质，实现log方法，打印消息
3. 添加main方法，创建ConsoleLogger对象，调用log方法

参考代码

  trait Logger {// 抽象方法def log(message:String)}class ConsoleLogger extends Logger {override def log(message: String): Unit = println("控制台日志:" + message)}def main(args: Array[String]): Unit = {val logger = new ConsoleLoggerlogger.log("这是一条日志")}

9.1.2、示例 | 继承多个trait

---

示例说明

1. 创建一个MessageSender特质，添加send方法
2. 创建一个MessageReceiver特质，添加receive方法
3. 创建一个MessageWorker实现这两个特质
4. 在main中调用，分别调用send方法、receive方法

参考代码

trait MessageSender {def send(msg:String)
}trait MessageReceive {def receive():String
}class MessageWorker extends MessageSender with MessageReceive {override def send(msg: String): Unit = println(s"发送消息:${msg}")override def receive(): String = "你好！我叫一个好人！"
}def main(args: Array[String]): Unit = {val worker = new MessageWorkerworker.send("hello")println(worker.receive())
}

9.1.3、示例 | object继承trait

---

示例说明

1. 创建一个Logger特质，添加一个log抽象方法
2. 创建一个ConsoleLogger的object，实现LoggerForObject特质，实现log方法，打印消息
3. 编写main方法，调用ConsoleLogger的log方法

参考代码

trait Logger {def log(message:String)
}object ConsoleLogger extends Logger {override def log(message: String): Unit = println("控制台消息:" + message)
}def main(args: Array[String]): Unit = {ConsoleLogger.log("程序退出!")
}

9.2、特质 | 定义具体的方法

和类一样，trait中还可以定义具体的方法

示例

示例说明

1. 定义一个Logger特质，添加log实现方法
2. 定义一个UserService类，实现Logger特质

• 添加add方法，打印"添加用户"

3. 添加main方法

• 创建UserService对象实例
• 调用add方法
  参考代码

trait LoggerDetail {// 在trait中定义具体方法def log(msg:String) = println(msg)
}class UserService extends LoggerDetail {def add() = log("添加用户")
}object MethodInTrait {def main(args: Array[String]): Unit = {val userService = new UserServiceuserService.add()}
}

9.3、trait中定义具体的字段和抽象的字段

定义

• 在trait中可以定义具体字段和抽象字段

• 继承trait的子类自动拥有trait中定义的字段

• 字段直接被添加到子类中

示例
示例说明

通过trait来实现一个日志输出工具，该日志工具可以自动添加日志的日期

步骤

1. 创建Logger特质
   • 定义一个SimpleDateFormat字段，用来格式化日期（显示到时间）
   • 定义一个TYPE抽象字段，用于定义输出的信息
   • 创建一个log抽象方法，用于输出日志
2. 创建ConsoleLogger类，实现TYPE抽象字段和log方法
3. 添加main方法

• 创建ConsoleLogger类对象
• 调用log方法

参考代码

  trait Logger {val sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm")def log(msg:String)}class ConsoleLogger extends Logger {override def log(msg: String): Unit = {val info = s"${sdf.format(new Date())}:控制台消息:${msg}"println(info)}}def main(args: Array[String]): Unit = {val logger = new ConsoleLogger()logger.log("NullPointerException")}

9.4、使用trait实现模板模式

要实现以下需求：

• 实现一个输出日志的功能
• 目前要求输出到控制台
• 将来可能会输出到文件、输出到Redis、或者更多的需求

如何实现将来不修改之前的代码，来扩展现有功能呢？

定义

在一个特质中，具体方法依赖于抽象方法，而抽象方法可以放到继承trait的子类中实现，这种设计方式也称为模板模式

在scala中，trait是可以定义抽象方法，也可以定义具体方法的

• trait中定义了一个抽象方法
• trait中定义了其他的几个具体方法，会调用抽象方法
• 其他实现类可以来实现抽象方法
• 真正调用trait中具体方法的时候，其实会调用实现类的抽象方法实现

示例
示例说明

• 编写一个日志输出工具，分别有info、warn、error三个级别的日志输出
• 日志输出的方式要求设计为可扩展的，例如：可以输出到控制台、将来也可以扩展输出到文件、数据库等

实现步骤

1. 添加一个Logger特质
   • 添加一个log抽象方法
   • 添加一个info、warn、error具体方法，这几个方法调用log抽象方法
2. 创建ConsoleLogger类，实现Logger特质
3. 添加main方法
   • 创建ConsoleLogger类对象
   • 分别调用info、warn、error方法输出日志

参考代码

 trait Logger {def log(msg:String)def info(msg:String) = log("INFO:" + msg)def warn(msg:String) = log("WARN:" + msg)def error(msg:String) = log("ERROR:" + msg)}class ConsoleLogger extends Logger {override def log(msg: String): Unit = {println(msg)}}def main(args: Array[String]): Unit = {val logger = new ConsoleLoggerlogger.info("信息日志")logger.warn("警告日志")logger.error("错误日志")}

9.5、对象混入trait

scala中可以将trait混入到对象中，就是将trait中定义的方法、字段添加到一个对象中

定义
语法

val/var 对象名 = new 类 with 特质

示例

• 给一个对象添加一些额外的行为

步骤

1. 创建一个Logger特质
   • 添加一个log实现方法，打印参数
2. 创建一个UserService类
3. 添加main方法
   • 创建UserService对象，混入Logger特质
   • 调用log方法

参考代码

trait Logger {def log(msg:String) = println(msg)}class UserServicedef main(args: Array[String]): Unit = {val service = new UserService with Loggerservice.log("混入的方法")}

9.6、trait实现调用链模式

9.6.1、trait调用链

类继承了多个trait后，可以依次调用多个trait中的同一个方法，只要让多个trait中的同一个方法在最后都依次执行super关键字即可。类中调用多个tait中都有这个方法时，首先会从最右边的trait方法开始执行，然后依次往左执行，形成一个调用链条。
示例
实现一个模拟支付过程的调用链

步骤

1. 定义一个HandlerTrait特质
   • 定义一个具体的handler方法，打印"处理数据…"
2. 定义一个DataValidHandlerTrait，继承HandlerTrait特质
   • 重写handler方法，打印"验证数据"
   • 调用父特质的handler方法
3. 定义一个SignatureValidHandlerTrait，继承HandlerTrait特质
   • 重写Handler方法
   • 打印"检查签名"
   • 调用父特质的handler方法
4. 创建一个PaymentService类
   • 继承DataValidHandlerTrait
   • 继承SignatureValidHandlerTrait
   • 定义pay方法
     • 打印"准备支付"
     • 调用父特质的handler方法
5. 添加main方法
   • 创建PaymentService对象实例
   • 调用pay方法

参考代码

trait HandlerTrait {def handle(data:String) = println("处理数据...")
}trait DataValidHanlderTrait extends HandlerTrait {override def handle(data:String): Unit = {println("验证数据...")super.handle(data)}
}trait SignatureValidHandlerTrait extends HandlerTrait {override def handle(data: String): Unit = {println("校验签名...")super.handle(data)}
}class PayService extends DataValidHanlderTrait with SignatureValidHandlerTrait {override def handle(data: String): Unit = {println("准备支付...")super.handle(data)}
}def main(args: Array[String]): Unit = {val service = new PayServiceservice.handle("支付参数")
}// 程序运行输出如下：
// 准备支付...
// 检查签名...
// 验证数据...
// 处理数据...

9.7、trait继承class

定义

trait也可以继承class的。特质会将class中的成员都继承下来。

示例

示例说明

• 定义一个特质，继承自一个class

步骤

1. 创建一个MyUtils类，定义printMsg方法
2. 创建一个Logger特质，继承自MyUtils，定义log方法
3. 创建一个Person类，添加name字段
   • 继承Logger特质
   • 实现sayHello方法，调用log方法
4. 添加main方法，创建一个Person对象，调用sayHello方法

参考代码

class MyUtil {def printMsg(msg:String) = println(msg)
}trait Logger extends MyUtil {def log(msg:String) = printMsg("Logger:" + msg)
}class Person extends Logger {def sayHello() = log("你好")
}def main(args: Array[String]): Unit = {val person = new Personperson.sayHello()
}

---

好了，以上内容就到这里了。欢迎关注小编，为小编的博客点赞。你们的点赞就是小编坚持下去的动力。小编会继续更新scala的文章哦。最好的关系就是互相成就，我们下期见。
我是小哪吒，是传智的一名学子。一个互联网行业的业余选手…哈哈哈

时间不在于你拥有多少，而在于你怎样使用