在软件开发中，设计模式是一种被广泛应用的解决特定问题的方法。它们提供了一种结构化的方式来组织代码，使得代码更加易于理解、维护和扩展。本文将介绍三种常用的 Java 设计模式：混合模式、装饰器模式和组合模式，并通过示例代码来展示它们的实际应用。
- 混合模式（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 类，实现了这两个接口，从而让鸭子具有飞行和游泳的能力。
- 装饰器模式（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 方法中，我们展示了如何使用装饰器来创建一个加了牛奶的咖啡。
- 组合模式（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 方法。
