Scala 中的复合设计模式？

Question

在java中，我可以实现复合设计模式，如下所示：

interface Component{
    void operation();

}

class Composite implements Component{
    @override
    public void operation(){
       for(Child child in children){
           child.operation();
       }
    }        

    public void add(Component child){//implementation}
    public void remove(Component child){//implementation}
    public void getChild(int index);
 }

 class Leaf implements Component{
      @override
      public void operation(){
         //implementation
      }
 }

如何在scala中编写它？特别是我无法理解如何编写接口并实现它？

Answer 1

在 Scala 中，没有任何具体方法的 Trait 只是一个接口。所以直接翻译是：

trait Component { def operation(): Unit }

class Composite extends Component {
  def operation() = children foreach { _.operation() }
  def add(child: Component) = ...
  def remove(child: Component) = ...
  def getChild(index: Int) = ...
}

class Leaf extends Component {
  def operation() = ...
}

虽然如果你想要更惯用的 Scala，我会推荐这样的东西作为 Composite 的定义：

class Composite extends Component {
  def operation() = children foreach { _.operation() }
  def +=(child: Component) = ...
  def -=(child: Component) = ...
  def apply(index: Int) = ...
}

用作：

val comp = new Composite
comp += child1
comp += child2
comp -= child1
val firstChild = comp(0)

如果你想得出一个合乎逻辑的结论，我建议将整个复合结构构建为不可变的有向无环图（尽管我意识到这通常是不可能的）：

case class Composite(children: Component*) extends Component {
  def operation() = children foreach { _.operation() }
}

val comp = Composite(child1, Composite(child2, child3), child4)

Answer 2

这

import scala.collection.mutable.ListBuffer

trait Component{
    def operation():Unit
}

class Composite extends Component{

    val children = new ListBuffer[Component]()

    def operation():Unit = children.foreach {_.operation() }

    def add(child: Component):Unit = children += child
    def remove(child: Component):Unit = children -= child
    def getChild(index:Int) = children(index)
 }:

 class Leaf extends Component {
      def operation():Unit = println("leaf") 
 }

是一个非常直接的翻译。在 Scala 中，通常首选不可变的解决方案。另一个区别是，您经常使用模式匹配而不是继承。例如，您可以通过从 Component 和 Leaf 中删除 operation() 并改为编写来重写示例

trait Component{
    def operation():Unit = this match {
      case c:Composite => c.children.foreach(_.operation())
      case leaf:Leaf => println("leaf")  
    }
}

Answer 3

更干净的不可变方式是：

trait Component {
  def operation()
  def +(other: Component): Component = new Composite(this, other)
}

class Leaf(name: String) extends Component {
  override def operation(): Unit = println(name)
}

class Composite(children: Component*) extends Component {
  override def operation(): Unit = children foreach { _.operation() }
}

val c = new Leaf("Tom") + new Leaf("Tim")
c.operation() // Tom Tim

Answer 4

在 Java 中作为接口呈现的功能可以在 Scala 中编码为特征

trait Component{
    def operation():Unit
}

class Composite extends Component{
    @override
    def operation(){
       for(child<-children)
         child.operation()
    }        

    def add(child:Component){//implementation}
    def remove(child:Component){//implementation}
    def getChild(index:Int){//implementation}
 }

 class Leaf extends Component{
      def operation(){
         //implementation
      }
 }

值得一提的是，特征比 Java 接口更强大，并且可以包括实现和接口规范。