Scala-11：面向对象04-特质(Trait)

Myth丶恋晨 2023-10-04 16:51 81阅读 0赞

## Scala-11：面向对象04-特质(Trait) ##

### 一、概述 ###

Scala 语言中，采用特质 trait（特征）来代替接口的概念，也就是说，多个类具有相同的特质（特征）时，就可以将这个特质（特征）独立出来，采用关键字 trait 声明。

Scala 中的 trait 中**即可以有抽象属性和方法，也可以有具体的属性和方法，一个类可以混入（ mixin）多个特质**。这种感觉类似于 Java 中的抽象类。

Scala 引入 trait 特征，第一可以替代 Java 的接口，第二个也是对单继承机制的一种补充。

### 二、特质声明 ###

#### 1：语法 ####

trait 特质名 {
         
      trait 主体 
    }

trait PersonTrait {
         
     
        // 声明属性 
        var name:String = _ 
     
        // 声明方法 
        def eat():Unit={
         
     
        } 
     
        // 抽象属性 
        var age:Int 
         
        // 抽象方法 
        def say():Unit 
    }

### 三、特质基本语法 ###

一个类具有某种特质（特征），就意味着这个类满足了这个特质（特征）的所有要素，所以在使用时，也采用了 extends 关键字，如果有多个特质或存在父类，那么需要采用 with关键字连接。

#### 1：基本语法 ####

**没有父类：**

class  类名 extends  特质 1   with    特质 2   with   特质 3 …

**有父类：**

class  类名  extends  父类   with  特质 1   with   特质 2  with 特质 3…

#### 2：说明 ####

1.  类和特质的关系：使用继承的关系。
2.  当一个类去继承特质时，第一个连接词是 extends，后面是 with。
3.  如果一个类在同时继承特质和父类时，应当把父类写在 extends 后。

#### 3：案例 ####

（1）特质可以同时拥有抽象方法和具体方法

trait PersonTrait {
         
     
        //（1）特质可以同时拥有抽象方法和具体方法 
        // 声明属性 
        var name: String = _ 
     
        // 抽象属性 
        var age: Int 
        // 声明方法 
        def eat(): Unit = {
         
            println("eat") 
        } 
     
        // 抽象方法 
        def say(): Unit 
    }

（2）一个类可以混入（mixin）多个特质

//一个类可以实现/继承多个特质 
    class Teacher extends PersonTrait with TestTrait {
         
     
        override def say(): Unit = {
         
            println("say") 
        } 
     
        override var age: Int = _ 
    }

（3）所有的 Java 接口都可以当做 Scala 特质使用

//所有的 Java 接口都可以当做 Scala 特质使用 
    class Teacher extends PersonTrait with java.io.Serializable {
         
     
        override def say(): Unit = {
         
            println("say") 
        } 
     
        override var age: Int = _ 
    }

（4）动态混入：可灵活的扩展类的功能

（4.1）动态混入：创建对象时混入 trait，而无需使类混入该 trait

（4.2）如果混入的 trait 中有未实现的方法，则需要实现

object TestTrait {
         
     
        def main(args: Array[String]): Unit = {
         
     
            val teacher = new Teacher 
     
            teacher.say() 
            teacher.eat() 
     
            //（4）动态混入：可灵活的扩展类的功能 
            val t2 = new Teacher with SexTrait {
         
                override var sex: String = "男" 
            } 
     
            //调用混入 trait 的属性 
            println(t2.sex) 
        } 
    }

### 四、特质叠加 ###

#### 1：单层叠加 ####

一个类（Sub）混入的两个 trait（TraitA，TraitB）中具有相同的具体方法，且两个 trait 之间没有任何关系，解决这类冲突问题，直接在类（Sub）中重写冲突方法。  
![在这里插入图片描述][be381f2476da47b5aab2941aed582a44.png]

如果有多个Trait，多个trait中有同一个方法或者属性，在使用super的时候，都是以with的最后一个为准，既是执行顺序是从右至左

#### 2：钻石叠加 ####

一个类（Sub）混入的两个 trait（TraitA，TraitB）中具有相同的具体方法，且两个 trait 继承自相同的 trait（TraitC），及所谓的“钻石问题”，解决这类冲突问题，Scala采用了特质叠加的策略。  
![在这里插入图片描述][df4108247037416b9081807ac92b1ee1.png]

class Sub extends taritA with TraitC

顺序就是：Sub–>TraitB–>TraitA–>TraitC

trait Ball {
         
       def describe(): String = {
         
          "ball" 
       } 
    } 
     
    trait Color extends Ball {
         
       override def describe(): String = {
         
          "blue-" + super.describe() 
       } 
    } 
     
    trait Category extends Ball {
         
       override def describe(): String = {
         
          "foot-" + super.describe() 
       } 
    } 
     
    class MyBall extends Category with Color {
         
       override def describe(): String = {
         
          "my ball is a " + super.describe() 
       } 
    } 
     
    object TestTrait {
         
       def main(args: Array[String]): Unit = {
         
          println(new MyBall().describe()) 
       } 
    }

**输出结果就是：**

my ball is a blue-foot-ball

#### 3：特质叠加顺序 ####

当一个类混入多个特质的时候，scala 会对所有的特质及其父特质按照一定的顺序进行排序，而此案例中的 super.describe()调用的实际上是排好序后的下一个特质中的 describe()方法。，排序规则如下：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NjQyOTI5MA_size_16_color_FFFFFF_t_70]

**结论：**

（1） 案例中的 super， 不是表示其父特质对象， 而是表示上述叠加顺序中的下一个特质，即， MyClass 中的 super 指代 Color， Color 中的 super 指代 Category， Category 中的 super指代 Ball。

（2）如果想要调用某个指定的混入特质中的方法，可以增加约束：super\[\]，例如super\[Category\].describe()。

### 五、特质和抽象类的区别 ###

1.优先使用特质。一个类扩展多个特质是很方便的，但却只能扩展一个抽象类。

2.如果需要构造函数参数，使用抽象类。因为抽象类可以定义带参数的构造函数，而特质不行（有无参构造）。

### 六、扩展 ###

#### 1：类型检查和转换 ####

（1）obj.isInstanceOf\[T\]：判断 obj 是不是 T 类型。

（2）obj.asInstanceOf\[T\]：将 obj 强转成 T 类型。

（3）classOf 获取对象的类名。

class Person{
         
     
    } 
     
    object Person {
         
        def main(args: Array[String]): Unit = {
         
     
            val person = new Person 
     
            //（1）判断对象是否为某个类型的实例 
            val bool: Boolean = person.isInstanceOf[Person] 
     
            if ( bool ) {
         
                //（2）将对象转换为某个类型的实例 
                val p1: Person = person.asInstanceOf[Person] 
                println(p1) 
            } 
     
            //（3）获取类的信息 
            val pClass: Class[Person] = classOf[Person] 
            println(pClass) 
        } 
    }

#### 2：枚举类和应用类 ####

枚举类：需要继承 Enumeration ：主要用于常量的使用

应用类：需要继承 App ：可以类比为Java的测试类

object Test {
         
        def main(args: Array[String]): Unit = {
         
     
            println(Color.RED) 
        } 
    } 
     
    // 枚举类 
    object Color extends Enumeration {
         
        val RED = Value(1, "red") 
        val YELLOW = Value(2, "yellow") 
        val BLUE = Value(3, "blue") 
    } 
    // 应用类 
    object Test20 extends App {
         
        println("xxxxxxxxxxx"); 
    }

#### 3：Type 定义新类型 ####

使用 type 关键字可以定义新的数据数据类型名称，本质上就是类型的一个别名

object Test {
         
     
        def main(args: Array[String]): Unit = {
         
             
            type S=String 
            var v:S="abc" 
            def test():S="xyz" 
        } 
    }

[be381f2476da47b5aab2941aed582a44.png]: https://img-blog.csdnimg.cn/be381f2476da47b5aab2941aed582a44.png
[df4108247037416b9081807ac92b1ee1.png]: https://img-blog.csdnimg.cn/df4108247037416b9081807ac92b1ee1.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NjQyOTI5MA_size_16_color_FFFFFF_t_70]: https://img-blog.csdnimg.cn/a49b81c1a4454c3fb4765223310d1595.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NjQyOTI5MA==,size_16,color_FFFFFF,t_70