首页 > 其他分享 >设计模式总结:适配器、桥接、组合和迭代器模式

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

时间:2024-07-25 09:57:57浏览次数:16  
标签:桥接 适配器 模式 public class int new 设计模式 void

在之前的对话中,我们讨论了五种常见的 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对象,添加了一些元素,然后使用迭代器对象来遍历并打印每个元素。

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

标签:桥接,适配器,模式,public,class,int,new,设计模式,void
From: https://blog.csdn.net/weixin_55745942/article/details/140681758

相关文章

  • 【 C语言 】 C语言设计模式
    一、C语言和设计模式(继承、封装、多态)C++有三个最重要的特点,即继承、封装、多态。我发现其实C语言也是可以面向对象的,也是可以应用设计模式的,关键就在于如何实现面向对象语言的三个重要属性。(1)继承性[cpp]viewplaincopytypedefstruct_parent{intdata_parent;......
  • 设计模式之--解释器模式
    解释器模式(InterpreterPattern)是一种行为型设计模式,它定义了一个语言的文法,并且用一个解释器来解释这个语言的语法或表达式。在解释器模式中,通常会有一个抽象表达式类定义解释操作的接口,具体的解释操作由具体的表达式类实现。什么是解释器模式:解释器模式是一种设计模式,用于解......
  • 设计模式之-享元模式
    享元模式(FlyweightPattern)是一种结构型设计模式,旨在有效地支持大量细粒度对象的共享。什么是享元模式:享元模式是一种优化性能的设计模式,其核心思想是共享对象以减少内存使用和提高性能。在享元模式中,共享的对象被称为享元,而非共享的部分被称为外部状态。享元对象包含内部状态......
  • JAVA常见面试题-设计模式(单例模式实现)
    单例模式分为懒汉式与饿汉式,其中饿汉式较为常用。饿汉式publicclassSingleton{   privatestaticSingletoninstance=newSingleton();   privateSingleton(){}   publicstaticSingletongetInstance(){   returninstance; ......
  • 设计模式-代理模式(Proxy Pattern)
    设计模式-代理模式(ProxyPattern) 概要 记忆关键字:代理控制 定义:为其他对象提供一种代理以控制对这个对象的访问 分析: 1)通过代理类,给对象的行为增加辅助功能的解决方案,就是代理模式 2)在程序运行时,动态地为被代理对象生成代理类,借助编程语言当中的"反射"特性。 ......
  • 设计模式-抽象工厂模式(Abstract Factory Pattern)
    设计模式-抽象工厂模式(AbstractFactoryPattern)  概要   记忆关键词:抽象接口  定义:提供一个创建一系列相关或相互依赖对象的接口,而无需指定他们具体的类。  分析:如果待创建的产品非常多,我们不需要为每一个产品类配上一个工厂类,而是可以把这些产品进行分组。抽象......
  • 设计模式-建造者模式(Builder)
    设计模式-建造者模式(Builder)  概要   记忆关键词:类和构造分离  定义:将一个复杂对象的构建与它的表示分离,使得同样的构建过程可以创建不同的表示。  分析:原型模式就是从一个样板对象中复制出一个内部属性一致的对象。它是在内存中拷贝二进制流,比new一个对象的性能......
  • 设计模式-原型模式(Prototype)
    设计模式-原型模式(Prototype)  概要   记忆关键词:原型实例、拷贝  定义:用原型实例指定创建对象的种类,并且通过拷贝这些原型创建新的对象。    分析:原型模式就是从一个样板对象中复制出一个内部属性一致的对象。它是在内存中拷贝二进制流,比new一个对象的性能好很......
  • Java设计模式-单例模式
    Java常用设计模式-单例模式JavaDesignPatterns:创建型模式:工厂方法、抽象方法、建造者、原型、单例结构型模式有:适配器、桥接、组合、装饰器、外观、享元、代理行为型模式有:责任链、命令、解释器、迭代器、中介、备忘录、观察者、状态、策略、模板方法、访问者常用设计模式:......
  • 跟着ChatGPT学习设计模式 - 工厂模式
    1.前言在工作过程中,越发觉得设计模式的重要性。经常会有人说工作5年的人,大学生随便培训1-2月也能做同样的工作,没错,大学生的确可以做。但其写的代码,可维护性、可扩展性、添加新功能时方便还是简单。甚至是软实力的表现,如何沟通、如何推进项目进展、如何做项目排期,其实都是应届生......