Scala面向对象特质的动态混入功能

/**
  * 定义特质（接口）
  */

trait Type{
  //没有赋值的属性 能源
  val energy:String
  //声抽象方法 获取能源方式
  def power():String
  //已实现的方法 轮子
  def wheels:String = {
    "have four wheel"
  }
}
trait Type1{
  //已实现的方法
  def skill():String = {
    "飞上天"
  }
}
trait Type2{
  //赋值的属性 品牌
  val brand: String = "冒牌货战车"
  //已实现的方法
  def skill2():String={
    "能下海潜水作战"
  }
}

/**
  * 定义一个抽象类 汽车类
  */
abstract class Car{
  //声明一个没有赋值的属性 品牌
  val brand: String
  //抽象方法 跑
  def run(): String
  //定义一个已经实现的方法 动作方法
  def action: String = {"by car"}

}


/**
  * 实现类
  */

class Bmw extends Car with Type{
  //赋值了抽象类中的没有赋值的属性，可以没有override
  val brand: String = "宝马"
  //实现了抽象类中没有实现的方法
  def run(): String = "我能跑200迈"
  //赋值了特质中的没有赋值的属性，可以没有override
  val energy: String = "电"
  //实现了特质中没有实现的方法
  def power(): String = "充电"

  //重定了抽象类中的方法，必须有override
  override def action:String = "自动驾驶"
  //重定了特质中的方法，必须有override
  override val wheels:String={"我有四个轮子"}

  override def toString: String = "<<<车的品牌是："+this.brand+
  "<<<车的技能1是："+this.run()+"<<<驱动方式是："+this.action+
    "<<<用的能源是："+this.energy+"<<<能源补充方式是:"+this.power()+
  "<<<基本构造："+this.wheels
}

/**
  * 创建一个类 冒牌货
  */
class MaoPaiHuo


object TraitDemo{

  def main(args: Array[String]): Unit = {
    //加工一辆宝马车
    val b = new Bmw
    println(b.toString)
   println("***********    冒牌货     **************")
    //特质的动态混入功能，可以在new一个对象的时候with N个特质，
    // 就有with的每个特质的已实现方法和已定义的属性
    val mph: MaoPaiHuo with Type1 with Type2 = new MaoPaiHuo with Type1 with Type2
    println("我的品牌叫做："+mph.brand +"----拥有技能1-->"+mph.skill()+
      "----拥有技能2--->"+mph.skill2())

  }
}

 

 

运行结果：

 

<<<车的品牌是：宝马<<<车的技能1是：我能跑200迈<<<驱动方式是：自动驾驶<<<用的能源是：电<<<能源补充方式是:充电<<<基本构造：我有四个轮子
*********** 冒牌货 **************
我的品牌叫做：冒牌货战车----拥有技能1-->飞上天----拥有技能2--->能下海潜水作战

 

转载于:https://www.cnblogs.com/itBulls/articles/9441303.html