Scala-trait(特质)

Trait(特质)

• Scala中没有Java中的接口（interface），但有trait(特质)可以替代，且功能要比接口更为强大。
• 与接口不同的是，它还可以定义属性和方法的实现。
• 类继承要求每个类只能继承一个，但是如果是 Trait 的话就可以继承多个，使用关键字with。
• 特质的定义和抽象类的定义很像，但它使用的是trait关键字。

Trait作为接口使用

1、继承单个trait

示例：

trait Logger {
    // 抽象方法
    def log(message:String)
  }
  
	//继承单个trait
  class ConsoleLogger extends Logger {
    override def log(message: String): Unit = println("控制台日志:" + message)
  }

	
  def main(args: Array[String]): Unit = {
    val logger = new ConsoleLogger
    logger.log("这是一条日志")
  }

2、继承多个trait

示例：

trait MessageSender {
    def send(msg:String)
}

trait MessageReceive {
    def receive():String
}

//继承多个trait
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())
}

3、object继承trait

示例：

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的子类自动拥有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的子类中实现，这种设计方式也称为模板模式

• trait中定义了一个抽象方法
• trait中定义了其他的几个具体方法，会调用抽象方法
• 其他实现类可以来实现抽象方法
• 真正调用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中的同一个方法在最后都依次执行super关键字即可。类中调用多个tait中都有这个方法时，首先会从最右边的trait方法开始执行，然后依次往左执行，形成一个调用链条。

示例：

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继承class

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

示例：

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()
}