Scala之旅-混合组成的类（CLASS COMPOSITION WITH MIXINS）

古城微笑少年丶 2022-05-25 14:07 183阅读 0赞

**Mixins** 就是用于组成类的 **traits**。

abstract class A { 
      val message: String
    }
    class B extends A { 
      val message = "I'm an instance of class B"
    }
    trait C extends A { 
      def loudMessage = message.toUpperCase()
    }
    class D extends B with C
    val d = new D
    println(d.message)  // I'm an instance of class B
    println(d.loudMessage)  // I'M AN INSTANCE OF CLASS B

![这里写图片描述][70]  
类 `D` 有一个父类 `B` 和一个 mixin `C`。类只能拥有一个父类但是可以拥有多个 **mixin** (分别使用关键字 `extends` 和 `with` )。**mixin** 和类可以拥有相同的父类。

现在让我们来看一个更有趣的例子，新建一个抽象类。

abstract class AbsIterator { 
      type T
      def hasNext: Boolean
      def next(): T
    }

该类中有一个抽象类型 `T` 和标准的迭代器方法。  
接下来,我们将实现一个具体的类(实现抽象类中全部的成员，包括抽象类型 `T`， `hashNext` 和 `next` 方法)

class StringIterator(s: String) extends AbsIterator { 
      type T = Char
      private var i = 0
      def hasNext = i < s.length
      def next() = {
        val ch = s charAt i
        i += 1
        ch
      }
    }

`StringIterator` 实现类带有一个 `String` 类型参数的构造器，可用于对字符串进行迭代。(比如查看字符串中是否包含某个字符)  
现在建立一个也继承 `AbsIterator` 的 **trait**。

trait RichIterator extends AbsIterator { 
      def foreach(f: T => Unit): Unit = while (hasNext) f(next())
    }

只要有更多的元素，该 **trait** 就会循环调用在下一个元素 (`next()`) 上的函数 `f: T = > Unit` 来实现 `foreach`。  
因为 `RichIterator` 是一个 **trait**，所以它不需要实现 `AbsIterator` 中的抽象成员属性或方法。

下面我们把 `StringIterator` 和 `RichIterator` 中的功能组合成单个类。

object StringIteratorTest extends App { 
      class RichStringIter extends StringIterator("Scala") with RichIterator
      val richStringIter = new RichStringIter
      richStringIter foreach println
    }

新类 `RichStringIter` 有一个 `StringIterator` 父类和 `RichIterator` 作为 **mixin**。

**如果是单一继承,我们将无法达到这样的灵活性**。

[70]: /images/20220525/304692f4484a45af94521835db7db8d9.png