特质 trait

scala中没有接口（interface）的概念，有特质（trait）的概念，类似于接口

package chapter02


//特质：接口
//scala中没有接口（interface）的概念，有特质（trait）的概念，类似于接口
object test13 {

  def main(args:Array[String]):Unit={
    var user=new User12()
    println(user)

  }

}


trait test12 {}
trait test22{}

class Person12{}

//特质可以继承的，使用关键字extends
//如果类要继承多个特质，可以用with连接
//如果类同时存在父类和特质，依然采用继承方式，extends父类，with特质
class User12 extends Person12 with test12 with test22 {}

 

package chapter01

object test15 {
  def main(args:Array[String]):Unit={
    //java中的接口无法构建对象，必须使用实现类
    //java接口无法写入代码
    //java中的接口可以声明方法
    //Java中的接口可以声明属性，属性值无法修改

    //scala也无法直接构建对象
    //scala特质中可以写入有代码
    //scala特质中的属性和方法都可以在混入的类中调用
    //特质中可以申明抽象方法
    //new Test15()

    var user = new User22()
    //属性
    user.username="lisi"
    println(user.username)
    
    //方法
    user.test()

    //抽象方法
    user.test02()

  }
}


trait Test22{
  println("test22....")

  var username:String="zhangshan"
  def test():Unit={
    println("test......")
  }
  //抽象方法
  def test02()
}

class Person22{}

class User22 extends Person22 with Test22{
  def test02():Unit={
    println("user22.....")
  }
}

 

package chapter01

object test16 {
  def main(args:Array[String]):Unit={
    var user = new User26()
  }
}


trait Test26{
   println("trait.....")

}

class Person26 {
  println("parent.....")
}

//特质只与当前类有关
class User26 extends Person26 with Test26{
  println("child.....")
}

//parent.....
//trait.....
//child.....

package chapter01

object test16 {
  def main(args:Array[String]):Unit={
    var user = new User26()
  }
}


trait Test26{
   println("trait.....")

}

class Person26 extends Test26 {
  println("parent.....")
}

//特质只与当前类有关，父类先执行，特质再执行
//如果父类中有相同的特质，trait只初始化一次


class User26 extends Person26 with Test26{
  println("child.....")
}

//trait.....
//parent.....
//child.....

 

package chapter01

object test16 {
  def main(args:Array[String]):Unit={
    var mysql = new Mysql01()
    mysql.insert()
  }
}


trait Operate01{
  println("Operate......")
   def insert(): Unit ={
     println("插入数据")
   }
}

//特质可以继承其他特质
trait DB01 extends Operate01 {
  println("DB......")
  override def insert(): Unit ={
    print("向数据库")
    super.insert()
  }
}

trait File01 extends Operate01 {
  println("File......")
  override def insert(): Unit ={
    print("向文件")
    super[Operate01].insert()
  }
}


//多特质混入，代码执行顺序为从左到右
//多特质混入，方法执行顺序从右向左
//特质中super不是指代父特质，指代上一级特质，即File01中的super指代DB01
//如果希望super指代父特质，需要增加[]
//java中的接口可以当作scala中的特质来使用
class Mysql01 extends DB01 with File01 with Serializable {

}

//Operate......
//DB......
//File......
//向文件插入数据

 

package chapter01

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

    //动态混入，扩展性非常强
    var mysql = new Mysql01() with Operate01
    mysql.insert()
  }
}

trait Operate01{
   def insert(): Unit ={
     println("插入数据")
   }
}

class Mysql01  {

}

package chapter01

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

    //动态混入，扩展性非常强
    var mysql = new Mysql01()
    mysql.insert()
    mysql.getMessage
  }
}

trait Operate01{
  //特质使用范围
   this:Exception =>
   def insert(): Unit ={
     println("插入数据")
     this.getMessage
   }
}

class Mysql01 extends Exception with Operate01 {

}