文章目录
特质(trait)
scala中没有Java中的接口（interface），替代的概念是——特质
定义
- 特质是scala中代码复用的基础单元
- 它可以将方法和字段定义封装起来，然后添加到类中
- 与类继承不一样的是，类继承要求每个类都只能继承
一个超类，而一个类可以添加任意数量的特质。 - 特质的定义和抽象类的定义很像，但它是使用
trait关键字
语法
定义特质
trait 名称 {
// 抽象字段
// 抽象方法
}
继承特质
class 类 extends 特质1 with 特质2 {
// 字段实现
// 方法实现
}
- 使用
extends来继承trait（scala不论是类还是特质，都是使用extends关键字） - 如果要继承多个trait，则使用
with关键字
trait作为接口使用
trait作为接口使用，与java的接口使用方法一样。
示例 | 继承单个trait
示例说明
- 创建一个Logger特质，添加一个接受一个String类型参数的log抽象方法
- 创建一个ConsoleLogger类，继承Logger特质，实现log方法，打印消息
- 添加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 ConsoleLogger
logger.log("这是一条日志")
}
示例 | 继承多个trait
示例说明
- 创建一个MessageSender特质，添加send方法
- 创建一个MessageReceiver特质，添加receive方法
- 创建一个MessageWorker实现这两个特质
- 在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 MessageWorker
worker.send("hello")
println(worker.receive())
}
示例 | object继承trait
示例说明
- 创建一个Logger特质，添加一个log抽象方法
- 创建一个ConsoleLogger的object，实现LoggerForObject特质，实现log方法，打印消息
- 编写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("程序退出!")
}
特质 | 定义具体的方法
和类一样，trait中还可以定义具体的方法
示例
示例说明
参考代码
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 UserService
userService.add()
}
}
trait中定义具体的字段和抽象的字段
定义
示例
示例说明
通过trait来实现一个日志输出工具，该日志工具可以自动添加日志的日期
步骤
参考代码
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")
}
使用trait实现模板模式
要实现以下需求：
定义
在一个特质中，具体方法依赖于抽象方法，而抽象方法可以放到继承trait的子类中实现，这种设计方式也称为模板模式
在scala中，trait是可以定义抽象方法，也可以定义具体方法的
示例
示例说明
实现步骤
参考代码
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 ConsoleLogger
logger.info("信息日志")
logger.warn("警告日志")
logger.error("错误日志")
}
对象混入trait
scala中可以将trait混入到对象中，就是将trait中定义的方法、字段添加到一个对象中
定义
语法
val/var 对象名 = new 类 with 特质
示例
步骤
参考代码
trait Logger {
def log(msg:String) = println(msg)
}
class UserService
def main(args: Array[String]): Unit = {
val service = new UserService with Logger
service.log("混入的方法")
}
trait实现调用链模式
我们如果要开发一个支付功能，往往需要执行一系列的验证才能完成支付。例如：
- 进行支付签名校验
- 数据合法性校验
- …
如果将来因为第三方接口支付的调整，需要增加更多的校验规则，此时如何不修改之前的校验代码，来实现扩展呢？
责任链模式
trait调用链
类继承了多个trait后，可以依次调用多个trait中的同一个方法，只要让多个trait中的同一个方法在最后都依次执行super关键字即可。类中调用多个tait中都有这个方法时，首先会从最右边的trait方法开始执行，然后依次往左执行，形成一个调用链条。
示例
步骤
- 定义一个HandlerTrait特质
- 定义一个DataValidHandlerTrait，继承HandlerTrait特质
- 定义一个SignatureValidHandlerTrait，继承HandlerTrait特质
- 创建一个PaymentService类
- 添加main方法
参考代码
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 PayService
service.handle("支付参数")
}
// 程序运行输出如下：
// 准备支付...
// 检查签名...
// 验证数据...
// 处理数据...
trait的构造机制
如果一个类实现了多个trait，那这些trait是如何构造的呢？
定义
- trait也有构造代码，但和类不一样，特质不能有构造器参数
- 每个特质只有**
一个无参数**的构造器。 - 一个类继承另一个类、以及多个trait，当创建该类的实例时，它的构造顺序如下：
- 执行父类的构造器
从左到右依次执行trait的构造器- 如果trait有父trait，先构造父trait，如果多个trait有同样的父trait，则只初始化一次
- 执行子类构造器
示例
示例说明
- 定义多个特质，然后用一个类去实现它们
- 测试trait的构造顺序
步骤
- 创建一个Logger特质，在构造器中打印"执行Logger构造器!"
- 创建一个MyLogger特质，继承自Logger特质，，在构造器中打印"执行MyLogger构造器!"
- 创建一个TimeLogger特质，继承自Logger特质，在构造器中打印"执行TimeLogger构造器!"
- 创建一个Person类，在构造器中打印"执行Person构造器!"
- 创建一个Student类，继承自Person、MyLogger、TimeLogge特质，在构造器中打印"执行Student构造器!"
- 添加main方法，实例化Student_One类，观察输出。
参考代码
trait Logger {
println("执行Logger构造器")
}
trait MyLogger extends Logger {
println("执行MyLogger构造器")
}
trait TimeLogger extends Logger {
println("执行TimeLogger构造器")
}
class Person{
println("执行Person构造器")
}
class Student extends Person with TimeLogger with MyLogger {
println("执行Student构造器")
}
def main(args: Array[String]): Unit = {
new Student
}
// 程序运行输出如下：
// 执行Person构造器
// 执行Logger构造器
// 执行TimeLogger构造器
// 执行MyLogger构造器
// 执行Student构造器
# trait继承class
定义
trait也可以继承class的。特质会将class中的成员都继承下来。
示例
示例说明
步骤
- 创建一个MyUtils类，定义printMsg方法
- 创建一个Logger特质，继承自MyUtils，定义log方法
- 创建一个Person类，添加name字段
- 添加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 Person
person.sayHello()
}
版权声明：本文内容由互联网用户自发贡献，该文观点与技术仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容， 请发送邮件至 [email protected] 举报，一经查实，本站将立刻删除。
