Scala入门系列之八--scala中的特质(trait)，也称接口

传送门
Scala入门系列之一--使用命令行往文件输入数据并读取数据
Scala入门系列之二--数组、元组、列表、集合数据类型简述
Scala入门系列之三--类和方法的创建以及命令行执行scala文件
Scala入门系列之四--类成员的可见性（private）以及用value和value_=进行读取和修改
Scala入门系列之五--主构造器和辅助构造器
Scala入门系列之六--伴生对象和伴生类
Scala入门系列之七--scala中的继承
Scala入门系列之八--scala中的特质(trait)，也称接口
Scala入门系列之九--模式匹配两大法宝（match语句和case类）
Scala入门系列之十--包
Scala入门系列之十一--函数式编程基础
Scala入门系列之十二--高阶函数
Scala入门系列之十三--针对容器的操作(遍历/映射/过滤/规约操作)
Scala入门系列之十四--使用IDEA编写Scala代码并Maven打包提交集群运行
传送门

一、特质(trait)，也称接口

1）基本概念

• scala中没有接口的概念，而是提供了特质（trait）
• scala的特质是代码重用的基本单元，可以同时拥有抽象方法和具体方法
• 特质（trait）可以被多重继承，从而重用特质中的方法和字段。
• 特质可以使用extends继承其它的特质

//特质的定义

trait Flyable{
    val maxFlyHeight:Int  //抽象字段
    def fly()
    def breathe(){println("I can!")}  //具体方法
}

//与抽象类的区别
//同：特质既可以包含抽象成员，也可以包含非抽象成员。
//异：包含抽象成员时，不需要abstract关键字。（就是说直接用trait定义就好）

2）Scala中特质trait与抽象类abstract的区别

• 优先使用特质。一个类扩展多个特质很方便的，但只能扩展一个抽象类
• 如果你需要构造函数参数，使用抽象类。因为抽象类是可以定义带参数的构造函数，而特质比较麻烦。例如：你不能trait t(i:int){}，参数i是非法的

//特质要实现带参数，可以在方法里面去定义
trait helloworld{
    def sayhello(name:String)
}

3）把特质混入类中

• 可以使用extends或with关键字调用特质方法
• 如果特质中包含抽象成员，则该类必须为这些抽象成员提供具体实现，除非该类被定义为抽象类(即上一节中的抽象类)

//混入单个特质trait
trait Flyable{
    var maxFlyHeight:Int  //抽象字段
    def fly()  //抽象方法
    def breathe(){println("I can breathe")}  //具体的方法
}

class Bird(flyHeight:Int) extends Flyable{
    var maxFlyHeight:Int = flyHeight  //重载特质的抽象字段
    def fly(){
        println("I can fly at the height of" + maxFlyHeight)  //重载特质的抽象方法
    }
}

object Bird{
    def main(args:Array[String]){
        val v = new Bird(100)
        v.fly()  //I can fly at the height of 100
        v.breathe() //I can breathe
    }
}


//混入多个特质
trait Flyable{
    var maxFlyHeight:Int  //抽象字段
    def fly()  //抽象方法
    def breathe(){println("I can breathe")}  //具体的方法
}

trait HasLegs{
    var legs:Int
    def move(){println("I can walk with "+ legs + "legs")}
}

class Animal(val category:String){
    def info(){println("This is a "+category)}
}

class Bird(flyHeight:Int) extends Animal("Bird") with Flyable with HssLegs{
    var maxFlyHeight:Int = flyHeight  //重载特质的抽象字段
    var legs = 2 //重载特质的抽象字段
    def fly(){
        println("I can fly at the height of" + maxFlyHeight)  //重载特质的抽象方法
    }
}

object Bird{
    def main(args:Array[String]){
        val v = new Bird(100)
        v.fly()  //I can fly at the height of 100
        v.breathe() //I can breathe
        
        b.info()  //This is a Bird
    }
}

4）练习：

定义一个父类person，里面包含人的类别字段和一个方法，人的类别字段当作构造方法参数传入，方法返回人的类别
定义一个特质医生，里面包含一个医生行为方法，看病（抽象方法）
定义一个特质教师，里面包含一个教师行为方法，上课（抽象方法）
再写一个子类，里面继承person类，根据实际类别，混入1个特质，
子类创建后能够调用父类和特质的方法

//定义一个父类person，里面包含人的类别字段和一个方法，人的类别字段当作构造方法参数传入，方法返回人的类别
//定义一个特质医生，里面包含一个医生行为方法，看病（抽象方法）
//定义一个特质教师，里面包含一个教师行为方法，上课（抽象方法）
//再写一个子类，里面继承person类，根据实际类别，混入1个特质，
//子类创建后能够调用父类和特质的方法

class person(var people:String){
    def info(){println("hello, I am " + people)}
}

trait doctor{
    def working()
}

trait teacher{
    def classing()
}

class son extends person("teacher") with teacher{
    def teacher(){
        println("He is a teacher")
    }
}

object myScala{
    def main(args:Array[String]){
        var s = new son()
        s.teacher() //He is a teacher
        s.info()  //hello, I am teacher
    }
}