什么是结构型模式

前言：

结构型模式是软件设计模式中的一种类型，目的是通过将对象组合成更大的结构来解决复杂系统中的设计问题。它主要关注对象之间的组合、关联以及如何通过简化对象间的交互来实现系统的灵活性和可维护性。结构型模式主要有类结构型模式和对象结构型模式两种。

类结构型模式：

类结构型模式通过继承和实现接口来定义类之间的关系，主要包括适配器模式、桥接模式、装饰器模式和代理模式。

适配器模式是将一个类的接口转换成客户希望的另一个接口，使得原本由于接口不兼容而无法一起工作的类能够协同工作。适配器模式通常会包含一个适配器类，该类实现了客户需要的目标接口，同时在内部持有一个被适配对象。

// 适配器类
public class Adapter implements Target {
    private Adaptee adaptee;

    public Adapter(Adaptee adaptee) {
        this.adaptee = adaptee;
    }

    public void request() {
        adaptee.specificRequest();
    }
}

桥接模式是将抽象部分和实现部分分离，使它们可以独立变化。桥接模式的核心思想是将抽象与实现解耦，通过组合的方式实现各种不同的功能。桥接模式通常会包括一个抽象化角色和一个实现化角色，抽象化角色中定义了一些基本操作，具体实现化角色则负责实现这些操作。

// 抽象化角色
public abstract class Abstraction {
    protected Implementor implementor;

    public void setImplementor(Implementor implementor) {
        this.implementor = implementor;
    }

    public abstract void operation();
}

// 实现化角色
public interface Implementor {
    void operationImpl();
}

// 具体实现化角色
public class ConcreteImplementorA implements Implementor {
    public void operationImpl() {
        // 具体实现
    }
}

装饰器模式用于给对象动态地增加额外的功能，而不需要修改原有的代码。装饰器模式通过将对象放入包含具有相同接口的装饰器对象中，来实现对对象的增强。通过装饰器的嵌套，可以实现多个功能的叠加，同时每个装饰器只关注自己的功能实现。

// 抽象构件角色
public interface Component {
    void operation();
}

// 具体构件角色
public class ConcreteComponent implements Component {
    public void operation() {
        // 基本操作
    }
}

// 抽象装饰角色
public abstract class Decorator implements Component {
    private Component component;

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

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

// 具体装饰角色
public class ConcreteDecorator extends Decorator {
    public ConcreteDecorator(Component component) {
        super(component);
    }

    public void operation() {
        super.operation();
        // 装饰操作
    }
}

代理模式是通过一个代理对象来控制对原始对象的访问，可以在不改变原始对象的情况下，为其添加额外的逻辑。代理模式通常会包括一个抽象主题角色，一个真实主题角色和一个代理主题角色。代理主题角色通过持有真实主题角色的引用来代表真实主题角色。

// 抽象主题角色
public interface Subject {
    void request();
}

// 真实主题角色
public class RealSubject implements Subject {
    public void request() {
        // 真实主题操作
    }
}

// 代理主题角色
public class Proxy implements Subject {
    private RealSubject realSubject;

    public void request() {
        preRequest();
        if (realSubject == null) {
            realSubject = new RealSubject();
        }
        realSubject.request();
        postRequest();
    }

    private void preRequest() {
        // 前置操作
    }

    private void postRequest() {
        // 后置操作
    }
}

对象结构型模式：

对象结构型模式通过对象的组合，形成一个更大的对象结构，然后通过此结构实现对整个对象集合的操作，主要包括组合模式、享元模式和代理模式。

组合模式通过将对象组合成树形结构来表示部分-整体的层次关系，使得用户对单个对象和组合对象的使用具有一致性。组合模式通常会包括一个抽象构件角色和两个具体构件角色，其中抽象构件定义了基本的操作方法，具体构件实现了这些方法。

// 抽象构件角色
public abstract class Component {
    public abstract void operation();
    public abstract void add(Component component);
    public abstract void remove(Component component);
    public abstract Component getChild(int index);
}

// 叶子构件角色
public class Leaf extends Component {
    public void operation() {
        // 叶子构件操作
    }

    public void add(Component component) {
        // 叶子构件无此方法
    }

    public void remove(Component component) {
        // 叶子构件无此方法
    }

    public Component getChild(int index) {
        // 叶子构件无此方法
        return null;
    }
}

// 容器构件角色
public class Composite extends Component {
    private List components = new ArrayList();

    public void operation() {
        // 容器构件操作
        for (Component component : components) {
            component.operation();
        }
    }

    public void add(Component component) {
        components.add(component);
    }

    public void remove(Component component) {
        components.remove(component);
    }

    public Component getChild(int index) {
        return components.get(index);
    }
}

享元模式通过共享细粒度对象来减少内存的使用量，提高系统的性能。享元模式通常会包含一个享元工厂角色和一个享元角色，享元工厂角色负责创建和管理享元对象，享元角色则负责描述对象的内部状态。

// 享元角色
public interface Flyweight {
    void operation();
}

// 具体享元角色
public class ConcreteFlyweight implements Flyweight {
    private String intrinsicState;

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

    public void operation() {
        // 具体享元操作
    }
}

// 享元工厂角色
public class FlyweightFactory {
    private Map flyweights = new HashMap();

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

代理模式在对象结构型模式中的作用与类结构型模式中相似，同样可以通过代理对象来控制对原始对象的访问。它通常包括一个抽象主题角色（或接口），一个真实主题角色和一个代理主题角色。代理主题角色通过持有真实主题角色的引用来代表真实主题角色。

// 抽象主题角色
public interface Subject {
    void request();
}

// 真实主题角色
public class RealSubject implements Subject {
    public void request() {
        // 真实主题操作
    }
}

// 代理主题角色
public class Proxy implements Subject {
    private Subject realSubject;

    public void request() {
        preRequest();
        if (realSubject == null) {
            realSubject = new RealSubject();
        }
        realSubject.request();
        postRequest();
    }

    private void preRequest() {
        // 前置操作
    }

    private void postRequest() {
        // 后置操作
    }
}

总结：

结构型模式是一种常见的设计模式类型，旨在解决复杂系统中的设计问题。类结构型模式关注对象的组合、关联和交互，通过继承和接口实现不同类之间的联系，包括适配器模式、桥接模式、装饰器模式和代理模式。对象结构型模式关注对象之间的组合和整体-部分关系，通常通过组合形成更大的对象结构来实现对对象集合的操作，包括组合模式、享元模式和代理模式。