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

空青7262024-07-26 23:35

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

适配器模式

概念：

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

使用场景：

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

优点：

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

缺点：

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

使用注意事项：

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

代码示例：

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();
    }
}
桥接模式

概念：

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

使用场景：

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

优点：

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

缺点：

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

使用注意事项：

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

代码示例：

java 复制代码 
// 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();
    }
}
组合模式

概念：

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

使用场景：

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

优点：

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

缺点：

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

使用注意事项：

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

代码示例：

java 复制代码 
// 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();
    }
}
迭代器模式

概念：

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

使用场景：

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

优点：

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

缺点：

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

使用注意事项：

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

代码示例：

java 复制代码 
// 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对象，添加了一些元素，然后使用迭代器对象来遍历并打印每个元素。

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

相关推荐
激流丶2 分钟前
【Kafka 实战】如何解决Kafka Topic数量过多带来的性能问题？
java·大数据·kafka·topic
Themberfue6 分钟前
Java多线程详解⑤（全程干货！！！）线程安全问题 || 锁 || synchronized
java·开发语言·线程·多线程·synchronized·锁
时差95321 分钟前
【面试题】Hive 查询：如何查找用户连续三天登录的记录
大数据·数据库·hive·sql·面试·database
让学习成为一种生活方式23 分钟前
R包下载太慢安装中止的解决策略-R语言003
java·数据库·r语言
晨曦_子画28 分钟前
编程语言之战：AI 之后的 Kotlin 与 Java
android·java·开发语言·人工智能·kotlin
假装我不帅1 小时前
asp.net framework从webform开始创建mvc项目
后端·asp.net·mvc
南宫生1 小时前
贪心算法习题其三【力扣】【算法学习day.20】
java·数据结构·学习·算法·leetcode·贪心算法
神仙别闹1 小时前
基于ASP.NET+SQL Server实现简单小说网站（包括PC版本和移动版本）
后端·asp.net
Heavydrink1 小时前
HTTP动词与状态码
java
ktkiko111 小时前
Java中的远程方法调用——RPC详解
java·开发语言·rpc
热门推荐
01【HarmonyOS】HUAWEI DevEco Studio 下载地址汇总02(欧拉)openEuler系统添加网卡文件配置流程、(欧拉)openEuler系统手动配置ipv6地址流程、(欧拉)openEuler系统网络管理说明03组基轨迹建模 GBTM的介绍与实现（Stata 或 R）04【AIGC】重塑未来的科技巨轮05全面解析：构建基于深度学习的安全帽检测系统（UI界面+YOLO代码+数据集）06【经验分享】Ubuntu22.04安装微信(linux官方版)07基于YOLOv10深度学习的CT扫描图像肾结石智能检测系统【python源码+Pyqt5界面+数据集+训练代码】深度学习实战、目标检测08Ubuntu 20.04使用Livox mid 360 测试 FAST_LIO09RAG 实践- Ollama+RagFlow 部署本地知识库10【TC3xx芯片】TC3xx芯片电源管理系统PMS详解