重学scala：scala面向对象编程之trait特质

简介

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

1、作为接口

使用使用extends来继承trait（scala不论是类还是特质，都是使用extends关键字）如果要继承多个trait，则使用with关键字

trait B {...}
trait C {...}
class D
class A extends D
class A extends D with B
class A extends B
class A extends B with C

  

 

  
1
  
2
  
3
  
4
  
5
  
6
  
7
 

示例一：继承单个trait

trait Logger1 {
  // 抽象方法
  def log(msg:String)
}

class ConsoleLogger1 extends Logger1 {
  override def log(msg: String): Unit = println(msg)
}

class FileLogger2 extends Logger1 {
  override def log(msg: String): Unit = println(msg)
}

object LoggerMain {
  def main(args: Array[String]): Unit = {
    val logger = new ConsoleLogger1
    logger.log("控制台：这是一条日志")
  }
}

  

 

  
1
  
2
  
3
  
4
  
5
  
6
  
7
  
8
  
9
  
10
  
11
  
12
  
13
  
14
  
15
  
16
  
17
  
18
  
19
 

示例二：继承多个trait

trait Logger1 {
  // 抽象方法
  def log(msg:String)
}

trait Exception1 {
  def throwException(msg:String)
}

class FileLogger2 extends Logger1 with Exception1 {
  override def log(msg: String): Unit = println(msg)

  override def throwException(msg: String): Unit = println(msg)
}

object LoggerMain {
  def main(args: Array[String]): Unit = {

    val fileLogger = new FileLogger2
    fileLogger.log("文件：这是一条日志")
    fileLogger.throwException("文件：这里有一个异常！")
  }
}

  

 

  
1
  
2
  
3
  
4
  
5
  
6
  
7
  
8
  
9
  
10
  
11
  
12
  
13
  
14
  
15
  
16
  
17
  
18
  
19
  
20
  
21
  
22
  
23
 

2、定义具体的方法

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

trait LoggerDetail {
  // 在trait中定义具体方法
  def log(msg:String) = println(msg)
}

class PersonService extends LoggerDetail {
  def add() = log("添加用户")
}

object MethodInTrait {
  def main(args: Array[String]): Unit = {
    val personService = new PersonService
    personService.add()
    personService.log("添加好了")
  }
}

  

 

  
1
  
2
  
3
  
4
  
5
  
6
  
7
  
8
  
9
  
10
  
11
  
12
  
13
  
14
  
15
  
16
 

3、定义具体方法和抽象方法

在trait中，可以混合使用具体方法和抽象方法使用具体方法依赖于抽象方法，而抽象方法可以放到继承trait的子类中实现，这种设计方式也称为模板模式。
示例：

trait Logger3 {
  // 抽象方法
  def log(msg:String)
  // 具体方法（该方法依赖于抽象方法log
  def info(msg:String) = log("INFO:" + msg)
  def warn(msg:String) = log("WARN:" + msg)
  def error(msg:String) = log("ERROR:" + msg)
}

class ConsoleLogger3 extends Logger3 {
  override def log(msg: String): Unit = println(msg)
}

object LoggerTrait3 {
  def main(args: Array[String]): Unit = {
    val logger3 = new ConsoleLogger3
    logger3.log("这是一条日志")

    logger3.info("这是一条普通信息")
    logger3.warn("这是一条警告信息")
    logger3.error("这是一条错误信息")
  }
}

  

 

  
1
  
2
  
3
  
4
  
5
  
6
  
7
  
8
  
9
  
10
  
11
  
12
  
13
  
14
  
15
  
16
  
17
  
18
  
19
  
20
  
21
  
22
  
23
 

4、定义具体字段和抽象字段

在trait中可以定义具体字段和抽象字段继承trait的子类自动拥有trait中定义的字段，字段直接被添加到子类中
示例

trait LoggerEx {
  // 具体字段
  val sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm")
  val INFO: String = "信息:" + sdf.format(new Date)
  // 抽象字段
  val TYPE:String

  // 抽象方法
  def log(msg:String)
}

class ConsoleLoggerEx extends LoggerEx {
  // 实现抽象字段
  override val TYPE: String = "控制台"
  // 实现抽象方法
  override def log(msg:String): Unit = print(s"$TYPE $INFO $msg")
}

object FieldInTrait {
  def main(args: Array[String]): Unit = {
    val logger = new ConsoleLoggerEx

    logger.log("这是一条消息")
  }
}

  

 

  
1
  
2
  
3
  
4
  
5
  
6
  
7
  
8
  
9
  
10
  
11
  
12
  
13
  
14
  
15
  
16
  
17
  
18
  
19
  
20
  
21
  
22
  
23
  
24
  
25
 

5、实例对象混入trait

trait还可以混入到实例对象中，给对象实例添加额外的行为，只有混入了trait的对象才具有trait中的方法，其他的类对象不具有trait中的行为，使用with将trait混入到实例对象中
例子：

trait LoggerMix {
  def log(msg:String) = println(msg)
}

class UserService

object FixedInClass {
  def main(args: Array[String]): Unit = {
    // 使用with关键字直接将特质混入到对象中
    val userService = new UserService with LoggerMix

    userService.log("混入了特质")
  }
}

  

 

  
1
  
2
  
3
  
4
  
5
  
6
  
7
  
8
  
9
  
10
  
11
  
12
  
13
  
14
 

文章来源: blog.csdn.net，作者：橙子园，版权归原作者所有，如需转载，请联系作者。

原文链接：blog.csdn.net/Chenftli/article/details/124860294