设计模式总结：适配器、桥接、组合和迭代器模式

空青726

于 2024-07-25 09:58:57 发布

阅读量817

点赞数 20

文章标签：设计模式迭代器模式 java 后端架构面试考研

本文链接：https://blog.csdn.net/weixin_55745942/article/details/140681758

版权

在之前的对话中，我们讨论了五种常见的 Java 设计模式：单例、工厂、策略、装饰器和观察者模式。现在，让我们继续探索其他四种设计模式：适配器、桥接、组合和迭代器模式。

适配器模式

概念：
适配器模式是一种结构型设计模式，用于将一个类的接口转换为另一个类期望的接口。适配器模式可以让原本由于接口不兼容而不能一起工作的类可以进行交互。

使用场景：

当你需要将一个类的接口转换为另一个类期望的接口时。
当你想要重用一些现有的类，但是这些类的接口与你需要的接口不兼容时。

优点：

提供了一种简单的方法来使不兼容的接口协同工作。
可以避免修改现有的代码，从而降低了修改引入的风险。

缺点：

如果接口的差异过大，可能会导致适配器类变得复杂。
过度使用适配器模式可能会使得系统的结构变得混乱。

使用注意事项：

确保适配器类正确地转换接口。
考虑使用其他设计模式（如桥接模式）来解决接口不兼容的问题。

代码示例：

// Target interface
public interface Volt3 {
    public void getVolt();
}

// Adaptee class
public class Volt220 {
    public void get220Volt() {
        System.out.println("220 volts");
    }
}

// Adapter class
public class VoltAdapter implements Volt3 {
    private Volt220 volt220;

    public VoltAdapter(Volt220 volt220) {
        this.volt220 = volt220;
    }

    @Override
    public void getVolt() {
        volt220.get220Volt();
    }
}

// Usage
public class Main {
    public static void main(String[] args) {
        Volt220 volt220 = new Volt220();
        Volt3 volt3 = new VoltAdapter(volt220);
        volt3.getVolt();
    }
}

桥接模式

概念：
桥接模式是一种结构型设计模式，用于将抽象部分与实现部分分离，使它们可以独立变化。桥接模式可以在运行时选择或切换实现。

使用场景：

当你需要在运行时选择或切换实现时。
当你想要避免使用继承来扩展功能时。

优点：

提供了一种灵活的方式来扩展功能，而不需要修改原有代码。
可以将抽象部分和实现部分分离，从而降低了系统的复杂度。

缺点：

如果桥接的接口过于复杂，可能会使得系统的复杂度增加。
在某些情况下，桥接模式可能会导致性能问题。

使用注意事项：

确保抽象类和实现类都有清晰的定义和职责。
在设计桥接模式时，需要权衡其带来的灵活性和系统复杂度的增加。

代码示例：

// Abstraction
public abstract class Shape {
    protected DrawAPI drawAPI;

    protected Shape(DrawAPI drawAPI){
        this.drawAPI = drawAPI;
    }

    public abstract void draw();
}

// Refined Abstraction
public class Circle extends Shape {
    private int x, y, radius;

    public Circle(int x, int y, int radius, DrawAPI drawAPI) {
        super(drawAPI);
        this.x = x;
        this.y = y;
        this.radius = radius;
    }

    @Override
    public void draw() {
        drawAPI.drawCircle(x, y, radius);
    }
}

// Implementor
public interface DrawAPI {
    void drawCircle(int x, int y, int radius);
}

// Concrete Implementor
public class DrawAPI1 implements DrawAPI {
    @Override
    public void drawCircle(int x, int y, int radius) {
        System.out.println("Drawing circle using DrawAPI1");
    }
}

// Concrete Implementor
public class DrawAPI2 implements DrawAPI {
    @Override
    public void drawCircle(int x, int y, int radius) {
        System.out.println("Drawing circle using DrawAPI2");
    }
}

// Usage
public class Main {
    public static void main(String[] args) {
        Shape circle1 = new Circle(1, 2, 3, new DrawAPI1());
        Shape circle2 = new Circle(5, 6, 7, new DrawAPI2());
        circle1.draw();
        circle2.draw();
    }
}

组合模式

概念：
组合模式是一种结构型设计模式，用于表示部分-整体层次结构。组合模式让你可以将对象组合成树形结构来表示部分-整体的层次关系。

使用场景：

当你需要表示部分-整体层次结构时。
当你想要让客户端可以统一地处理单个对象和对象集合时。

优点：

提供了一种简单的方式来构建复杂的对象结构。
可以使得客户端代码更加简洁和易于维护。

缺点：

如果组合层次过深，可能会使得系统的复杂度增加。
在某些情况下，组合模式可能会导致性能问题。

使用注意事项：

确保组合对象和叶子对象都实现了相同的接口。
在设计组合模式时，需要考虑如何处理添加或删除子元素的操作。

代码示例：

// Component
public interface Component {
    void operation();
}

// Leaf
public class Leaf implements Component {
    private String name;

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

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

// Composite
public 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 component : children) {
            component.operation();
        }
    }
}

// Usage
public class Main {
    public static void main(String[] args) {
        Composite composite1 = new Composite();
        Composite composite2 = new Composite();

        Leaf leaf1 = new Leaf("Leaf 1");
        Leaf leaf2 = new Leaf("Leaf 2");
        Leaf leaf3 = new Leaf("Leaf 3");

        composite1.add(leaf1);
        composite1.add(leaf2);

        composite2.add(leaf3);
        composite2.add(composite1);

        composite2.operation();
    }
}

迭代器模式

概念：
迭代器模式是一种行为型设计模式，用于遍历集合对象。迭代器模式可以隐藏集合对象的内部实现细节。

使用场景：

当你需要遍历一个集合对象时。
当你想要隐藏集合对象的内部实现细节时。

优点：

提供了一种统一的方式来访问集合对象中的元素。
可以使得集合对象的实现细节对外部世界隐藏。

缺点：

如果迭代器的实现过于复杂，可能会使得系统的复杂度增加。
在某些情况下，迭代器模式可能会导致性能问题。

使用注意事项：

确保迭代器对象正确地遍历集合对象。
在设计迭代器模式时，需要考虑如何处理集合对象的修改操作。

代码示例：

// Iterator
public interface Iterator {
    boolean hasNext();
    Object next();
}

// Aggregate
public interface Aggregate {
    Iterator createIterator();
}

// Concrete Aggregate
public class ConcreteAggregate implements Aggregate {
    private List<Object> list = new ArrayList<>();

    public void add(Object object) {
        list.add(object);
    }

    public void remove(Object object) {
        list.remove(object);
    }

    @Override
    public Iterator createIterator() {
        return new ConcreteIterator(this);
    }
}

// Concrete Iterator
public class ConcreteIterator implements Iterator {
    private ConcreteAggregate aggregate;
    private int index = 0;

    public ConcreteIterator(ConcreteAggregate aggregate) {
        this.aggregate = aggregate;
    }

    @Override
    public boolean hasNext() {
        return index < aggregate.list.size();
    }

    @Override
    public Object next() {
        Object object = aggregate.list.get(index);
        index++;
        return object;
    }
}

// Usage
public class Main {
    public static void main(String[] args) {
        ConcreteAggregate aggregate = new ConcreteAggregate();
        aggregate.add("Item 1");
        aggregate.add("Item 2");
        aggregate.add("Item 3");

        Iterator iterator = aggregate.createIterator();
        while (iterator.hasNext()) {
            Object item = iterator.next();
            System.out.println(item);
        }
    }
}

这个示例演示了如何使用迭代器模式来遍历一个集合对象（在本例中是一个列表）。ConcreteAggregate类是具体的聚合对象，它实现了Aggregate接口并提供了一个createIterator()方法来返回一个迭代器对象。ConcreteIterator类是具体的迭代器对象，它实现了Iterator接口并提供了hasNext()和next()方法来遍历聚合对象中的元素。最后，在Main类中，我们创建了一个ConcreteAggregate对象，添加了一些元素，然后使用迭代器对象来遍历并打印每个元素。

以上就是适配器、桥接、组合和迭代器模式的简要介绍。这些设计模式在解决特定类型的问题时都有其独特的优势和适用场景。掌握这些模式可以帮助我们编写更灵活、更可维护和更可扩展的代码。