重构你的代码：探索Java中的混合、装饰器与组合设计模式

在软件开发中，设计模式是一种被广泛应用的解决特定问题的方法。它们提供了一种结构化的方式来组织代码，使得代码更加易于理解、维护和扩展。本文将介绍三种常用的 Java 设计模式：混合模式、装饰器模式和组合模式，并通过示例代码来展示它们的实际应用。

1. 混合模式（Mixin）

混合模式是一种将多个类的功能合并到一个单一类中的技术。它允许我们通过继承多个接口或抽象类来实现多重继承的效果。下面是一个使用混合模式的例子：

interface Flyable {
   
    void fly();
}

interface Swimmable {
   
    void swim();
}

class Duck implements Flyable, Swimmable {
   
    @Override
    public void fly() {
   
        System.out.println("Duck is flying");
    }

    @Override
    public void swim() {
   
        System.out.println("Duck is swimming");
    }
}

public class MixinExample {
   
    public static void main(String[] args) {
   
        Duck duck = new Duck();
        duck.fly();
        duck.swim();
    }
}

在这个例子中，我们定义了两个接口 Flyable 和 Swimmable，分别表示能够飞行和游泳的能力。然后，我们创建了一个 Duck 类，实现了这两个接口，从而让鸭子具有飞行和游泳的能力。

1. 装饰器模式（Decorator）

装饰器模式是一种结构型设计模式，它允许我们在不修改现有对象结构的情况下，动态地给一个对象添加新的功能。下面是一个简单的装饰器模式的例子：

interface Coffee {
   
    double cost();
}

class SimpleCoffee implements Coffee {
   
    @Override
    public double cost() {
   
        return 1.0;
    }
}

abstract class CoffeeDecorator implements Coffee {
   
    protected Coffee decoratedCoffee;

    public CoffeeDecorator(Coffee coffee) {
   
        this.decoratedCoffee = coffee;
    }

    public abstract double cost();
}

class MilkDecorator extends CoffeeDecorator {
   
    public MilkDecorator(Coffee coffee) {
   
        super(coffee);
    }

    @Override
    public double cost() {
   
        return decoratedCoffee.cost() + 0.5;
    }
}

public class DecoratorExample {
   
    public static void main(String[] args) {
   
        Coffee simpleCoffee = new SimpleCoffee();
        Coffee milkCoffee = new MilkDecorator(simpleCoffee);
        System.out.println("Simple coffee cost: " + simpleCoffee.cost());
        System.out.println("Milk coffee cost: " + milkCoffee.cost());
    }
}

在这个例子中，我们首先定义了一个 Coffee 接口和一个实现该接口的 SimpleCoffee 类。然后，我们创建了一个抽象的 CoffeeDecorator 类，它也实现了 Coffee 接口，并持有一个 Coffee 类型的引用。我们还创建了一个具体的装饰器 MilkDecorator，它在原有咖啡的基础上增加了牛奶的成本。最后，在 main 方法中，我们展示了如何使用装饰器来创建一个加了牛奶的咖啡。

1. 组合模式（Composite）

组合模式是一种结构型设计模式，它将对象组合成树形结构以表示部分-整体的层次结构。组合模式使得客户端对单个对象和组合对象的使用具有一致性。下面是一个组合模式的例子：

import java.util.ArrayList;
import java.util.List;

interface Component {
   
    void operation();
}

class Leaf implements Component {
   
    private String name;

    public Leaf(String name) {
   
        this.name = name;
    }

    @Override
    public void operation() {
   
        System.out.println("Leaf " + name + " operation");
    }
}

class Composite implements Component {
   
    private List<Component> children = new ArrayList<>();

    public void add(Component component) {
   
        children.add(component);
    }

    public void remove(Component component) {
   
        children.remove(component);
    }

    @Override
    public void operation() {
   
        for (Component child : children) {
   
            child.operation();
        }
    }
}

public class CompositeExample {
   
    public static void main(String[] args) {
   
        Composite root = new Composite();
        root.add(new Leaf("A"));
        root.add(new Leaf("B"));

        Composite branch = new Composite();
        branch.add(new Leaf("C"));
        branch.add(new Leaf("D"));

        root.add(branch);
        root.operation();
    }
}

在这个例子中，我们定义了一个 Component 接口，以及实现了该接口的 Leaf 类和 Composite 类。Leaf 类代表叶子节点，而 Composite 类代表组合节点，它可以包含其他 Component 对象。在 main 方法中，我们创建了一个根节点 root，并向其中添加了两个叶子节点和一个子组合节点。最后，我们调用根节点的 operation 方法，它会递归地调用其所有子节点的 operation 方法。