1. 适配器模式（Adapter Pattern）

1.2 定义

适配器模式用于将一个类的接口转换成客户端希望的另一个接口，使得原本接口不兼容的类可以一起工作。

1.3 侧重点

将不兼容的接口转换为可兼容接口。
提供了中间层，使得原有系统可以复用，同时兼容新的接口。
复制

1.4 使用场景

需要使用已存在的类，但其接口不符合系统要求时。
需要创建一个可以复用的类，该类可以与其他不相关的类或不可预见的类（即适配的类）协同工作。
复制

1.5 示例代码（Java）

interface Target {
    void request();
}

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

class Adapter implements Target {
    private Adaptee adaptee;

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

    @Override
    public void request() {
        adaptee.specificRequest();
    }
}
复制

2. 桥接模式（Bridge Pattern）

2.1 定义

桥接模式将抽象部分与实现部分分离，使它们可以独立变化，达到解耦的目的。

2.2 侧重点

分离抽象和实现，降低耦合度。 提高系统的灵活性，可以独立地变化抽象部分和实现部分。

2.3 使用场景

需要避免抽象和实现部分固定绑定在一起，可以独立变化时。 一个类存在多个独立变化的维度，且这些维度需要独立扩展。

2.4 示例代码（Java）

interface Implementor {
    void operationImpl();
}

class ConcreteImplementorA implements Implementor {
    @Override
    public void operationImpl() {
        System.out.println("ConcreteImplementorA operation");
    }
}

class ConcreteImplementorB implements Implementor {
    @Override
    public void operationImpl() {
        System.out.println("ConcreteImplementorB operation");
    }
}

abstract class Abstraction {
    protected Implementor implementor;

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

    public abstract void operation();
}

class RefinedAbstraction extends Abstraction {
    @Override
    public void operation() {
        System.out.print("RefinedAbstraction: ");
        implementor.operationImpl();
    }
}
复制

3. 组合模式（Composite Pattern）

3.1 定义

组合模式用于将对象组合成树形结构以表示“部分-整体”的层次结构，使得用户对单个对象和组合对象的使用具有一致性。

3.2 侧重点

将对象组合成树形结构，用户可以一致对待单个对象和组合对象。
客户端可以忽略组合对象和单个对象之间的差异，简化了客户端代码。
复制

3.3 使用场景

当你想表示对象的部分-整体层次结构时。
希望客户端能够以一致的方式处理个别对象和对象的组合。
复制

3.4 示例代码（Java）

import java.util.ArrayList;
import java.util.List;

interface Component {
    void operation();
}

class Leaf implements Component {
    private String name;

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

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

class Composite implements Component {
    private List<Component> components = new ArrayList<>();

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

    @Override
    public void operation() {
        System.out.println("Composite operation:");
        for (Component component : components) {
            component.operation();
        }
    }
}
复制

4. 装饰器模式（Decorator Pattern）

4.1 定义

装饰器模式动态地给一个对象添加一些额外的职责，而不改变其结构。

4.2 侧重点

不改变原有对象的结构，而是给对象动态地增加一些功能。
以透明的方式扩展对象的功能，避免继承带来的静态特性。
复制

4.3 使用场景

在不改变现有对象结构的情况下，动态地给一个对象增加功能。
需要扩展一个类的功能，或者给一个类添加附加职责。
复制

4.4 示例代码（Java）

interface Component {
    void operation();
}

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

abstract class Decorator implements Component {
    protected Component component;

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

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

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

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

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

    @Override
    public void operation() {
        super.operation();
        System.out.println("ConcreteDecoratorB operation");
    }
}
复制

5. 外观模式（Facade Pattern）

5.1 定义

外观模式为子系统中的一组接口提供一个一致的界面，外观模式定义了一个高层接口。

5.2 侧重点

提供一个简单的接口，隐藏系统的复杂性，方便客户端使用。
将客户端与子系统解耦，降低了客户端对子系统的依赖。
复制

5.3 使用场景

当需要为复杂子系统提供一个简单接口时。
当客户端与多个子系统交互时，通过外观模式封装子系统的交互，降低耦合度。
复制

5.4 示例代码（Java）

class Subsystem1 {
    public void operation1() {
        System.out.println("Subsystem1 operation1");
    }
}

class Subsystem2 {
    public void operation2() {
        System.out.println("Subsystem2 operation2");
    }
}

class Subsystem3 {
    public void operation3() {
        System.out.println("Subsystem3 operation3");
    }
}

class Facade {
    private Subsystem1 subsystem1;
    private Subsystem2 subsystem2;
    private Subsystem3 subsystem3;

    public Facade() {
        subsystem1 = new Subsystem1();
        subsystem2 = new Subsystem2();
        subsystem3 = new Subsystem3();
    }

    public void operate() {
        subsystem1.operation1();
        subsystem2.operation2();
        subsystem3.operation3();
    }
}
复制

6. 享元模式（Flyweight Pattern）

6.1 定义

享元模式通过共享技术实现相同或相似对象的重用，减少内存占用和提高性能。

6.2 侧重点

尽量减少对象的创建，通过共享现有对象实现复用。
区分内部状态和外部状态，减少存储内部状态造成的内存消耗。
复制

6.3 使用场景

系统中存在大量相似对象，可以共享对象来减少内存占用。
对象的大部分状态可以外部化，可以将外部状态传入对象。
复制

6.4 示例代码（Java）

import java.util.HashMap;
import java.util.Map;

class Flyweight {
    private String intrinsicState;

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

    public void operation(String extrinsicState) {
        System.out.println("Intrinsic State: " + intrinsicState);
        System.out.println("Extrinsic State: " + extrinsicState);
    }
}

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

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

7. 代理模式（Proxy Pattern）

7.1 定义

代理模式为其他对象提供一种代理以控制对这个对象的访问。

7.2 侧重点

控制对原始对象的访问，可以在访问时进行一些控制或附加操作。
通过代理类来间接访问目标对象，保护目标对象、增强目标对象或控制访问目标对象。
复制

7.3 使用场景

需要控制对对象的访问，可以在代理类中增加控制逻辑。
需要在访问对象时附加一些额外操作，比如权限验证、缓存等。
复制

7.4 示例代码（Java）

interface Subject {
    void request();
}

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

class Proxy implements Subject {
    private RealSubject realSubject;

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

    @Override
    public void request() {
        // Perform some additional operations
        System.out.println("Proxy handles the request.");
        realSubject.request();
    }
}
复制

以上是结构型模式的详解和示例代码。每种模式都有其特定的用途和适用场景，根据具体的开发需求选择合适的模式来提高代码质量。