scale教程（五）抽象 接口

1.抽象类

//测试类
object abs{
        def main(args:Array[String]){
                var car = new BMW()
                car.setName("BMW")
                car.run()
        }
}
// 定义抽象车类
abstract class Car{
        // 定义抽象 属性
        var name:String
        //定义抽象方法
        def run()
        //定义具体方法
        def getName():String=name
}
//定义BMW类 继承 Car
class BMW extends Car{
        // 重写 Car类的 属性
        override var name:String=""
        //重写方法
        override def run(){
                println(name + "车跑起来了")
        }
        //具体方法
        def setName(n:String){
                this.name=n
        }
}

2.接口 trait（特性，特点；品质；）
对于Java程序员来说理解traits的最好方法就是把他们当作可以包含代码的接口（interface）。在Scala中，当一个类继承一个trait时，它就实现了这个trait的接口，同时还从这个trait中继承了所有的代码。
1.构造函数不能有参数
2.在使用trait的时候用extend或者with。with的方式成为混入（mixin）。用户可以with任意多个特质

下面 是scala实现的一个简单的类适配器模式

//日志bean对象
class LogBean {
  // 日志id , 下划线在这里是一个占位符，它代码相应属性对应类型的默认值
  private var logId: String = _
  //操作人员id
  private var userId: String = _
  def setLogId(logId: String) {
    this.logId = logId
  }
  def setUserId(userId: String) {
    this.userId = userId
  }
  def getLogId: String = logId
  def getUserId: String = userId

  override def toString="logId="+this.logId + ",userId="+this.userId
}
// 伴生对象 （与类同名） ： 代表是 类中的静态方法
object LogBean {
  def build(logId: String, userId: String): LogBean = {
    var log = new LogBean()
    log.setLogId(logId)
    log.setUserId(userId)
    log
  }
}
//文件操作 特质（接口）
trait LogFileOperateApi {
  def read: ArrayBuffer[LogBean]
}
class LogFileOperate extends LogFileOperateApi {
  def read: ArrayBuffer[LogBean] = {
    var logs = ArrayBuffer[LogBean]()
    logs.append(LogBean.build("file-1", "1"))
    logs.append(LogBean.build("file-2", "2"))
    logs
  }
}
// db操作 特质（接口）
trait LogDbApi {
  def read: ArrayBuffer[LogBean]
}
// 适配器 
class LogAdapter extends LogDbApi with LogFileOperateApi {
  var logFile = new LogFileOperate
  override def read: ArrayBuffer[LogBean] = {
    var list = new ArrayBuffer[LogBean]
    // 添加自己的读
    list.append(LogBean.build("db-1", "1"))
    list.append(LogBean.build("db-1", "1"))
    //添加 LogFile的读
    list++= this.logFile.read
    list
  }
}
//测试
object test {
  def main(args: Array[String]) {
    var adapter = new LogAdapter
    for(i <- adapter.read){
      println(i)
    }
  }
}

---------------结果打印----------------
logId=db-1,userId=1
logId=db-1,userId=1
logId=file-1,userId=1
logId=file-2,userId=2

下面用scala实现一个简单的外观模式

object test {
  def main(args: Array[String]) {
    var app = new Application()
    app.onCreate
    app.onDestory
  }
}
trait LifeCycle {
  def onCreate
  def onDestory
}
class Activity extends LifeCycle {
  override def onCreate {
    println("Activity 组件被初始化")
  }
  override def onDestory {
    println("Activity 组件被销毁")
  }
}
class Service extends LifeCycle {
  override def onCreate {
    println("Service 组件被初始化")
  }
  override def onDestory {
    println("Service 组件被销毁")
  }
}
class Application extends LifeCycle {
  var activity = new Activity()
  var service = new Service()
  override def onCreate {
    activity.onCreate
    service.onCreate
  }
  override def onDestory {
    activity.onDestory
    service.onDestory
  }
}

---------------结果打印----------------
Activity 组件被初始化
Service 组件被初始化
Activity 组件被销毁
Service 组件被销毁