java设计模式：03-结构型模式-概览

结构型模式（Structural Patterns）

结构型模式（Structural Patterns）主要关注类和对象的组合方式，旨在通过不同的结构组合方式来建立新的功能。结构型模式可以帮助开发者确保即使对象组合方式改变，也能保持系统的整体结构和功能的一致性，提高代码的可扩展性和复用性。

1. 适配器模式 (Adapter Pattern)

定义：将一个类的接口转换成客户希望的另一个接口，使得原本由于接口不兼容而不能一起工作的类可以一起工作。
详细释义：适配器模式通过创建一个适配器类，将一个类的接口转换为客户期望的另一个接口，从而使得原本由于接口不兼容而无法一起工作的类可以一起工作。适配器可以是对象适配器（通过组合实现）或类适配器（通过继承实现）。

// 目标接口
public interface Target {void request();
}// 需要适配的类
public class Adaptee {public void specificRequest() {System.out.println("Specific request");}
}// 对象适配器
public class Adapter implements Target {private Adaptee adaptee;public Adapter(Adaptee adaptee) {this.adaptee = adaptee;}public void request() {adaptee.specificRequest();}
}

2. 桥接模式 (Bridge Pattern)

定义：将抽象部分与实现部分分离，使它们可以独立变化。
详细释义：桥接模式通过将抽象部分与其具体实现分离，使得它们可以独立变化。抽象部分定义高层控制逻辑，而具体实现部分则负责底层具体操作。这种模式通过在抽象部分和实现部分之间引入桥接接口，使得它们之间的依赖关系变得更加灵活和可扩展。

// 实现部分接口
public interface Implementor {void operationImpl();
}// 具体实现部分A
public class ConcreteImplementorA implements Implementor {public void operationImpl() {System.out.println("ConcreteImplementorA operation");}
}// 抽象部分
public abstract class Abstraction {protected Implementor implementor;protected Abstraction(Implementor implementor) {this.implementor = implementor;}public abstract void operation();
}// 扩展抽象部分
public class RefinedAbstraction extends Abstraction {public RefinedAbstraction(Implementor implementor) {super(implementor);}public void operation() {implementor.operationImpl();}
}

3. 组合模式 (Composite Pattern)

定义：将对象组合成树形结构以表示“部分-整体”的层次结构，使得客户可以统一地对待单个对象和组合对象。
详细释义：组合模式允许你将对象组合成树形结构以表示“部分-整体”的层次结构，从而使客户可以统一地对待单个对象和组合对象。这种模式对于那些希望通过递归组合复杂对象的情况特别有效。

// 组件接口
public interface Component {void operation();
}// 叶子组件
public class Leaf implements Component {public void operation() {System.out.println("Leaf operation");}
}// 组合组件
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);}public void operation() {for (Component component : children) {component.operation();}}
}

4. 装饰模式 (Decorator Pattern)

定义：动态地给对象添加职责，通过创建一个装饰类来包装原始类。
详细释义：装饰模式通过创建一个装饰类来包装原始类，从而在不改变原始类的情况下动态地给对象添加职责。装饰模式允许你在运行时扩展对象的功能，并且比继承更灵活。

// 组件接口
public interface Component {void operation();
}// 具体组件
public class ConcreteComponent implements Component {public void operation() {System.out.println("ConcreteComponent operation");}
}// 装饰抽象类
public abstract class Decorator implements Component {protected 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();addedBehavior();}private void addedBehavior() {System.out.println("ConcreteDecorator added behavior");}
}

5. 外观模式 (Facade Pattern)

定义：为子系统中的一组接口提供一个一致的界面，使得子系统更容易使用。
详细释义：外观模式通过为子系统中的一组接口提供一个一致的界面，简化了复杂系统的使用。外观模式使得子系统更容易使用，隐藏了其复杂性，提供了一个简单的接口供客户端调用。

public class SubsystemA {public void operationA() {System.out.println("SubsystemA operation");}
}public class SubsystemB {public void operationB() {System.out.println("SubsystemB operation");}
}public class Facade {private SubsystemA subsystemA;private SubsystemB subsystemB;public Facade() {subsystemA = new SubsystemA();subsystemB = new SubsystemB();}public void operation() {subsystemA.operationA();subsystemB.operationB();}
}

6. 享元模式 (Flyweight Pattern)

定义：使用共享对象来有效地支持大量细粒度的对象。
详细释义：享元模式通过共享来减少大量细粒度对象的数量，从而节省内存。享元模式将对象的状态分为内部状态和外部状态，内部状态是共享的，不会随环境变化，而外部状态是依赖于环境的，可以根据需要进行变化。

public interface Flyweight {void operation(String extrinsicState);
}public class ConcreteFlyweight implements Flyweight {private String intrinsicState;public ConcreteFlyweight(String intrinsicState) {this.intrinsicState = intrinsicState;}public void operation(String extrinsicState) {System.out.println("IntrinsicState: " + intrinsicState + ", ExtrinsicState: " + extrinsicState);}
}public class FlyweightFactory {private Map<String, Flyweight> flyweights = new HashMap<>();public Flyweight getFlyweight(String key) {if (!flyweights.containsKey(key)) {flyweights.put(key, new ConcreteFlyweight(key));}return flyweights.get(key);}
}

7. 代理模式 (Proxy Pattern)

定义：为另一个对象提供一个代理以控制对这个对象的访问。
详细释义：代理模式通过为某个对象提供一个代理对象，控制对这个对象的访问。代理模式可以用于延迟实例化、控制访问权限、记录日志等。代理对象和实际对象实现相同的接口，从而实现对实际对象的控制和管理。

public interface Subject {void request();
}public class RealSubject implements Subject {public void request() {System.out.println("RealSubject request");}
}public class Proxy implements Subject {private RealSubject realSubject;public void request() {if (realSubject == null) {realSubject = new RealSubject();}realSubject.request();}
}