设计模式 (三) 结构型设计模式系列

目录

1.适配器模式

2.桥接模式

3.组合模式

4.装饰器模式

5.外观模式

6.享元模式

7.代理模式

---

结构型设计模式是一组用于处理对象之间关系的模式，包括适配器模式、桥接模式、组合模式、装饰器模式、外观模式、享元模式和代理模式。在这个系列中，我们将介绍这些模式的使用方法和实例。

1.适配器模式

适配器模式将一个类的接口转换成客户希望的另一个接口。这种模式通常用于将不兼容的接口转换成兼容的接口，例如将旧版 API 转换成新版 API。

适配器模式有两种实现方式：类适配器和对象适配器。类适配器使用继承实现，对象适配器使用组合实现。

下面是一个类适配器的实现：

public interface Target {
    void request();
}

public class Adaptee {
    public void specificRequest() {
        System.out.println("Specific request");
    }
}

public class Adapter extends Adaptee implements Target {
    @Override
    public void request() {
        specificRequest();
    }
}

2.桥接模式

桥接模式将抽象部分与它的实现部分分离，使它们都可以独立地变化。这种模式通常用于处理多维度变化的问题，例如不同操作系统和不同窗口系统的组合。

桥接模式的实现方式比较简单，只需要定义一个抽象部分和一个实现部分，然后让抽象部分持有实现部分的引用即可。这样，抽象部分就可以调用实现部分的方法，而实现部分也可以独立地变化，不会影响到抽象部分。

举个例子，假设我们要开发一个图形界面库，支持不同操作系统和不同窗口系统的组合。我们可以定义一个抽象窗口类和一个实现窗口类，然后让抽象窗口类持有实现窗口类的引用。这样，我们就可以在抽象窗口类中调用实现窗口类的方法，而实现窗口类也可以独立地变化，不会影响到抽象窗口类。

下面是一个桥接模式的实现：

public interface WindowImpl {
    void drawWindow();
}

public class XWindowImpl implements WindowImpl {
    @Override
    public void drawWindow() {
        System.out.println("X window");
    }
}

public class PMWindowImpl implements WindowImpl {
    @Override
    public void drawWindow() {
        System.out.println("PM window");
    }
}

public abstract class Window {
    protected WindowImpl windowImpl;

    public Window(WindowImpl windowImpl) {
        this.windowImpl = windowImpl;
    }

    public abstract void draw();
}

public class IconWindow extends Window {
    public IconWindow(WindowImpl windowImpl) {
        super(windowImpl);
    }

    @Override
    public void draw() {
        windowImpl.drawWindow();
        System.out.println("Icon window");
    }
}

public class TransientWindow extends Window {
    public TransientWindow(WindowImpl windowImpl) {
        super(windowImpl);
    }

    @Override
    public void draw() {
        windowImpl.drawWindow();
        System.out.println("Transient window");
    }
}

在这个例子中，我们定义了一个窗口实现类 WindowImpl 和两个窗口类 XWindowImpl 和 PMWindowImpl。然后，我们定义了一个抽象窗口类 Window，让它持有窗口实现类的引用。最后，我们定义了两个具体窗口类 IconWindow 和 TransientWindow，它们继承自抽象窗口类，并实现了 draw 方法。在 draw 方法中，它们先调用窗口实现类的 drawWindow 方法，然后再打印出自己的窗口类型。这样，我们就实现了一个支持不同操作系统和不同窗口系统的图形界面库。

3.组合模式

组合模式将对象组合成树形结构以表示“部分-整体”的层次结构。这种模式通常用于处理对象的递归组合，例如文件系统中的文件和文件夹。

组合模式的实现方式比较简单，只需要定义一个抽象组件和一个容器组件，然后让容器组件持有抽象组件的引用即可。

下面是一个组合模式的实现：

public abstract class Component {
    protected String name;

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

    public abstract void add(Component component);

    public abstract void remove(Component component);

    public abstract void display();
}

public class Leaf extends Component {
    public Leaf(String name) {
        super(name);
    }

    @Override
    public void add(Component component) {
        throw new UnsupportedOperationException();
    }

    @Override
    public void remove(Component component) {
        throw new UnsupportedOperationException();
    }

    @Override
    public void display() {
        System.out.println(name);
    }
}

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

    public Composite(String name) {
        super(name);
    }

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

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

    @Override
    public void display() {
        System.out.println(name);
        for (Component component : children) {
            component.display();
        }
    }
}

4.装饰器模式

装饰器模式动态地给一个对象添加一些额外的职责，而不需要修改原始对象的结构。这种模式通常用于扩展一个类的功能或者给一个类添加多个不同的功能。

装饰器模式的实现方式比较简单，只需要定义一个抽象组件和一个装饰器组件，然后让装饰器组件持有抽象组件的引用即可。

下面是一个装饰器模式的实现：

public interface Component {
    void operation();
}

public class ConcreteComponent implements Component {
    @Override
    public void operation() {
        System.out.println("Concrete component");
    }
}

public abstract class Decorator implements Component {
    protected Component component;

    public Decorator(Component component) {
        this.component = component;
    }

    @Override
    public void operation() {
        component.operation();
    }
}

public class ConcreteDecoratorA extends Decorator {
    public ConcreteDecoratorA(Component component) {
        super(component);
    }

    @Override
    public void operation() {
        super.operation();
        System.out.println("Concrete decorator A");
    }
}

public class ConcreteDecoratorB extends Decorator {
    public ConcreteDecoratorB(Component component) {
        super(component);
    }

    @Override
    public void operation() {
        super.operation();
        System.out.println("Concrete decorator B");
    }
}

5.外观模式

外观模式为子系统中的一组接口提供一个统一的接口。这种模式通常用于简化复杂系统的接口，例如操作系统的 API。

外观模式的实现方式比较简单，只需要定义一个外观类，将子系统的接口封装起来，然后提供一个统一的接口给客户端使用。

下面是一个外观模式的实现：

public class SubsystemA {
    public void operationA() {
        System.out.println("Subsystem A operation");
    }
}

public class SubsystemB {
    public void operationB() {
        System.out.println("Subsystem B operation");
    }
}

public class SubsystemC {
    public void operationC() {
        System.out.println("Subsystem C operation");
    }
}

public class Facade {
    private SubsystemA subsystemA;
    private SubsystemB subsystemB;
    private SubsystemC subsystemC;

    public Facade() {
        subsystemA = new SubsystemA();
        subsystemB = new SubsystemB();
        subsystemC = new SubsystemC();
    }

    public void operation() {
        subsystemA.operationA();
        subsystemB.operationB();
        subsystemC.operationC();
    }
}

6.享元模式

享元模式通过共享对象来减少内存的使用。这种模式通常用于创建大量相似对象的情况，例如文本编辑器中的字符。

享元模式的实现方式比较简单，只需要定义一个享元工厂和一个享元接口，然后让具体享元实现享元接口即可。

下面是一个享元模式的实现：

public interface Flyweight {
    void operation();
}

public class ConcreteFlyweight implements Flyweight {
    private String intrinsicState;

    public ConcreteFlyweight(String intrinsicState) {
        this.intrinsicState = intrinsicState;
    }

    @Override
    public void operation() {
        System.out.println("Concrete flyweight: " + intrinsicState);
    }
}

public class FlyweightFactory {
    private Map<String, Flyweight> flyweights = new HashMap<>();

    public Flyweight getFlyweight(String key) {
        if (flyweights.containsKey(key)) {
            return flyweights.get(key);
        } else {
            Flyweight flyweight = new ConcreteFlyweight(key);
            flyweights.put(key, flyweight);
            return flyweight;
        }
    }
}

7.代理模式

代理模式为一个对象提供一个代理，以控制对该对象的访问。这种模式通常用于控制对象的访问权限，例如网络代理、安全代理等。

代理模式的实现方式比较简单，只需要定义一个抽象主题和一个代理主题，然后让代理主题持有抽象主题的引用即可。

下面是一个代理模式的实现：

public interface Subject {
    void request();
}

public class RealSubject implements Subject {
    @Override
    public void request() {
        System.out.println("Real subject");
    }
}

public class Proxy implements Subject {
    private RealSubject realSubject;

    public Proxy() {
        realSubject = new RealSubject();
    }

    @Override
    public void request() {
        System.out.println("Proxy");
        realSubject.request();
    }
}

以上就是结构型设计模式系列的内容，希望能够帮助你更好地理解结构型设计模式的使用方法和实例。