工厂模式是一种创建型设计模式，用于创建对象。它隐藏了对象的具体实现，只向客户端提供一个统一的接口来创建对象。通过将对象的创建逻辑委托给工厂类，客户端可以避免直接实例化对象，从而提高代码的可维护性和灵活性。 适用的场景： 1. 当一个类不知道或不关心它需要创建的对象的类时，可以使用工厂模式，例如，客户端只需要知道抽象产品类接口，而不需要知道具体产品类的实现。 2. 当一个类希望由子类来指定创建对象时，可以使用工厂模式，例如，可以将产品的创建过程移到子类中。 3. 当一个类需要根据运行时的条件创建不同的对象时，可以使用工厂模式。 好处： 1. 工厂模式将对象的创建与使用分离，使得客户端只需要关心对象的使用，而不需要关心对象的创建过程。 2. 工厂模式满足了开放-封闭原则，即对扩展开放，对修改封闭。可以通过添加新的具体产品类来扩展工厂，而不需要修改客户端代码。 3. 工厂模式可以很好地封装创建对象的细节，使得客户端代码更加简洁、可读性更高。 下面是一个使用Java语言实现工厂模式的完整样例代码： ```java // 抽象产品类 interface Product { void operation(); } // 具体产品类A class ConcreteProductA implements Product { @Override public void operation() { System.out.println("ConcreteProductA"); } } // 具体产品类B class ConcreteProductB implements Product { @Override public void operation() { System.out.println("ConcreteProductB"); } } // 工厂类 class Factory { public Product createProduct(String productType) { if (productType.equals("A")) { return new ConcreteProductA(); } else if (productType.equals("B")) { return new ConcreteProductB(); } else { throw new IllegalArgumentException("Invalid product type"); } } } // 客户端 class Client { public static void main(String[] args) { Factory factory = new Factory(); Product productA = factory.createProduct("A"); productA.operation(); Product productB = factory.createProduct("B"); productB.operation(); } } ``` 在上述代码中，`Product`表示抽象产品类，`ConcreteProductA`和`ConcreteProductB`表示具体产品类，`Factory`表示工厂类。`Factory`类中的`createProduct`方法根据传入的产品类型来创建相应的具体产品对象。 在客户端代码中，通过工厂类的`createProduct`方法来创建具体产品对象，并调用其`operation`方法。根据传入的产品类型，工厂类返回对应的具体产品对象。输出结果为： ``` ConcreteProductA ConcreteProductB ```

单例模式是一种创建型设计模式，其目的是确保一个类只有一个实例，并且提供一个全局访问点。 适用场景： 1. 当需要保证系统中某个类只有一个实例时，可以使用单例模式。例如，数据库连接池、线程池等共享资源。 2. 当需要频繁实例化一个对象时，可以使用单例模式来提高性能。因为单例模式只会创建一个实例，多次调用不会重复创建。 好处： 1. 单例模式可以减少内存开支，因为它只会创建一个实例，减少对象的产生。 2. 单例模式可以避免资源的多重占用，例如线程池、数据库连接池等。 3. 单例模式可以在整个系统中提供一个全局的访问点，方便对实例进行操作。 以下是Java中实现单例模式的完整样例代码： ```java public class Singleton { // 私有化构造函数，防止外部实例化对象 private Singleton() { } // 创建静态私有实例 private static Singleton instance; // 提供全局访问点，以获取单例实例 public static Singleton getInstance() { if (instance == null) { synchronized (Singleton.class) { if (instance == null) { instance = new Singleton(); } } } return instance; } } ``` 上述代码中，Singleton类的构造函数被私有化，确保其他类不能通过new关键字创建Singleton实例。通过getInstance方法可以获取Singleton的唯一实例，如果实例为空，则通过双重检查加锁方式创建实例。双重检查加锁是为了保证在多线程环境下也能正常工作。

观察者模式（Observer Pattern）是一种行为型设计模式，用于在对象之间建立一对多的依赖关系，当一个对象的状态发生变化时，其相关依赖对象将自动被通知和更新。 该模式包含以下几个角色： 1. 主题（Subject）：被观察者，即被观察的对象。它维护了一个观察者列表，可以增加或删除观察者，并在状态发生改变时通知观察者。 2. 观察者（Observer）：观察者接口，定义了观察者的通用方法，以便被主题调用。 3. 具体主题（ConcreteSubject）：具体的被观察者类，实现主题接口，并维护当前的状态。 4. 具体观察者（ConcreteObserver）：具体的观察者类，实现观察者接口，在被通知时更新自身状态。 适用的场景： 1. 当一个对象的状态变化需要通知其他多个对象，并且这些对象的具体个数事先未知或动态变化时，可以使用观察者模式。 2. 当一个对象需要将自己的变化通知给其他对象，但是又不希望与被通知的对象形成紧耦合关系时，可以使用观察者模式。 该设计模式的好处如下： 1. 低耦合：观察者模式可以将主题和观察者解耦，使它们之间的关系变得松散。 2. 可扩展性：可以在任何时候增加新的观察者，使系统更易于扩展。 3. 随时通知：主题在状态发生变化时，可以随时通知观察者，确保观察者能及时更新自己的状态。 下面是一个简单的Java实现观察者模式的代码示例： ```java import java.util.ArrayList; import java.util.List; // 观察者接口 interface Observer { void update(String message); } // 被观察者接口 interface Subject { void attach(Observer observer); void detach(Observer observer); void notifyObservers(String message); } // 具体的观察者类 class ConcreteObserver implements Observer { private String name; public ConcreteObserver(String name) { this.name = name; } @Override public void update(String message) { System.out.println(name + " received message: " + message); } } // 具体的被观察者类 class ConcreteSubject implements Subject { private List<Observer> observers = new ArrayList<>(); @Override public void attach(Observer observer) { observers.add(observer); } @Override public void detach(Observer observer) { observers.remove(observer); } @Override public void notifyObservers(String message) { for (Observer observer : observers) { observer.update(message); } } public void changeState(String newState) { System.out.println("Subject state changed to: " + newState); notifyObservers(newState); } } // 示例代码 public class ObserverPatternExample { public static void main(String[] args) { ConcreteSubject subject = new ConcreteSubject(); Observer observer1 = new ConcreteObserver("Observer1"); subject.attach(observer1); Observer observer2 = new ConcreteObserver("Observer2"); subject.attach(observer2); subject.changeState("New State"); } } ``` 以上代码表示了一个被观察者主题（ConcreteSubject）和两个观察者（ConcreteObserver）的关系。当主题的状态发生改变时，会通知所有的观察者，并更新它们的状态。运行示例代码，输出如下： ``` Subject state changed to: New State Observer1 received message: New State Observer2 received message: New State ``` 以上代码只是观察者模式的一个简单示例，实际应用中可以根据具体需求进行扩展和定制。

适配器模式（Adapter Pattern）属于结构型设计模式，它将一个类的接口转换成客户端所期望的另一个接口，从而让原本因接口不匹配而无法一起工作的两个类能够协同工作。适配器模式可以解决系统的兼容问题，使得原本不兼容的接口能够无缝协同工作。 适用场景： 1. 当系统需要使用已经存在的类，而这些类的接口不符合系统的要求时，可以使用适配器模式。 2. 当需要重用一些现有的类，但是这些类的接口不符合当前系统要求时，可以使用适配器模式。 3. 当需要创建一个可复用的类，这个类与一些不兼容的类协同工作时，可以使用适配器模式。 适配器模式主要有三个角色： 1. 目标接口（Target）：定义客户端所期待使用的接口。 2. 适配器（Adapter）：适配器实现目标接口，它包含一个被适配的对象。 3. 被适配者（Adaptee）：已经存在的需要被适配的类或者对象。 以下是一个Java的适配器模式的样例代码： ```java // 目标接口 interface Target { void request(); } // 被适配者 class Adaptee { public void specificRequest() { System.out.println("被适配者的方法被调用"); } } // 适配器 class Adapter implements Target { private Adaptee adaptee; public Adapter(Adaptee adaptee) { this.adaptee = adaptee; } public void request() { adaptee.specificRequest(); } } // 客户端 public class Client { public static void main(String[] args) { Adaptee adaptee = new Adaptee(); Target target = new Adapter(adaptee); target.request(); } } ``` 在上述代码中，`Target`是客户端所期待使用的接口，`Adaptee`是已经存在的被适配的类，`Adapter`是适配器，它实现了`Target`接口，同时包含了一个`Adaptee`对象。在客户端代码中，先创建一个`Adaptee`对象，然后通过适配器`Adapter`将其转换为目标接口`Target`可用的对象，并调用`request()`方法。执行结果为打印出“被适配者的方法被调用”。

策略模式（Strategy Pattern）是一种行为型设计模式，它允许将算法独立于使用它的客户端进行变化。该模式通过定义一系列算法类，并且将每个算法封装到一个类中，使得它们可以互相替换，从而使客户端可以动态选择所需的算法。 适用场景：当一个系统需要在多个算法中选择一个执行时，并且这些算法具有共同的行为接口时，可以考虑使用策略模式。它可以将算法的变化与使用算法的客户端隔离开来，方便增加、替换或者删除策略，而不影响客户端。 该设计模式的好处如下： 1. 通过封装变化的部分，将算法和客户端解耦，提高了代码的灵活性和可维护性。 2. 算法的扩展和变化不会影响到客户端，只需要新增一个具体策略类即可。 3. 策略模式将算法的选择从客户端转移至环境类中，使得算法的选择更加灵活，并且可以在运行时动态改变。 下面是一个简单的Java代码示例： 首先，定义一个策略接口，其中包含需要被替换的算法： ```java public interface Strategy { public void execute(); } ``` 然后，实现具体的策略类，每个策略类都封装了具体的算法： ```java public class ConcreteStrategy1 implements Strategy { public void execute() { System.out.println("Executing Strategy 1"); } } public class ConcreteStrategy2 implements Strategy { public void execute() { System.out.println("Executing Strategy 2"); } } ``` 接下来，创建一个环境类，用于维护策略对象，并在客户端根据需要选择策略： ```java public class Context { private Strategy strategy; public Context(Strategy strategy) { this.strategy = strategy; } public void executeStrategy() { strategy.execute(); } } ``` 最后，在客户端代码中使用策略模式： ```java public class Main { public static void main(String[] args) { Strategy strategy1 = new ConcreteStrategy1(); Context context1 = new Context(strategy1); context1.executeStrategy(); Strategy strategy2 = new ConcreteStrategy2(); Context context2 = new Context(strategy2); context2.executeStrategy(); } } ``` 这样，根据不同的选择，客户端可以灵活地选择和切换不同的策略，而无需修改原有的代码。

建造者模式是一种创建型设计模式，它的目的是将一个复杂的对象的构建过程与其表示分离，使得同样的构建过程可以创建不同的表示。 适用场景： 1. 当一个对象的构建过程比较复杂，需要多个步骤以特定顺序执行时，可以使用建造者模式。例如，一个汽车的构建过程包括创建车身、安装发动机、安装轮胎等多个步骤，每个步骤都有特定的顺序。 2. 当相同的构建过程可以创建不同表示时，也适合使用建造者模式。例如，汽车的构建过程可以创建轿车、SUV、跑车等不同的类型。 好处： 建造者模式的好处包括： 1. 解耦构建过程和表示，使得代码结构更加清晰。 2. 可以通过控制不同的建造者，创建不同的表示对象。 3. 建造者模式可以复用相同的构建过程来构建不同的对象。 下面是一个简单的Java代码示例： ``` // 产品类，即要构建的复杂对象 class Car { private String engine; private String tire; public void setEngine(String engine) { this.engine = engine; } public void setTire(String tire) { this.tire = tire; } @Override public String toString() { return "Car{" + "engine='" + engine + '\'' + ", tire='" + tire + '\'' + '}'; } } // 抽象建造者类，定义构建过程的抽象方法 abstract class CarBuilder { protected Car car; public void createCar() { car = new Car(); } public abstract void buildEngine(); public abstract void buildTire(); public Car getCar() { return car; } } // 具体建造者类，实现构建过程的具体方法 class SedanCarBuilder extends CarBuilder { @Override public void buildEngine() { car.setEngine("Sedan Engine"); } @Override public void buildTire() { car.setTire("Sedan Tire"); } } class SUVCarBuilder extends CarBuilder { @Override public void buildEngine() { car.setEngine("SUV Engine"); } @Override public void buildTire() { car.setTire("SUV Tire"); } } // 指挥者类，负责构建对象 class Director { private CarBuilder carBuilder; public void setCarBuilder(CarBuilder carBuilder) { this.carBuilder = carBuilder; } public Car construct() { carBuilder.createCar(); carBuilder.buildEngine(); carBuilder.buildTire(); return carBuilder.getCar(); } } // 客户端代码 public class BuilderPatternExample { public static void main(String[] args) { Director director = new Director(); CarBuilder sedanCarBuilder = new SedanCarBuilder(); director.setCarBuilder(sedanCarBuilder); Car sedanCar = director.construct(); System.out.println("Sedan Car: " + sedanCar); CarBuilder suvCarBuilder = new SUVCarBuilder(); director.setCarBuilder(suvCarBuilder); Car suvCar = director.construct(); System.out.println("SUV Car: " + suvCar); } } ``` 输出结果： ``` Sedan Car: Car{engine='Sedan Engine', tire='Sedan Tire'} SUV Car: Car{engine='SUV Engine', tire='SUV Tire'} ``` 以上示例中，Car为要构建的复杂对象，CarBuilder为抽象建造者类，定义了构建过程的抽象方法。SedanCarBuilder和SUVCarBuilder为具体建造者类，实现了构建过程的具体方法。Director为指挥者类，负责构建对象。客户端代码通过设置不同的建造者来构建不同类型的Car对象。

原型模式（Prototype Pattern）是一种创建型设计模式，它允许通过复制（克隆）已有的对象来创建新的对象。这种模式隐藏了新对象的创建逻辑，使代码更加灵活和可扩展。 适用场景： 1. 当创建对象的过程比较复杂或耗时时，可以使用原型模式来复制一个已有的对象来创建新对象。这样可以避免复杂的对象初始化过程。 2. 当需要创建一个和已有对象相似的对象时，可以使用原型模式来复制已有对象的属性和方法。这样可以减少代码的重复性。 好处： 1. 简化对象的创建过程，隐藏创建逻辑。用户只需要调用克隆方法即可创建新对象，无需了解创建过程的细节。 2. 提高性能。克隆对象通过复制已有对象的属性和方法，避免了创建对象的开销。 3. 可以动态的添加或修改原型的属性，实现个性化对象的创建。 下面是一个Java的完整样例代码： ```java // 定义原型接口 public interface Prototype { Prototype clone(); // 克隆方法 } // 具体原型类 public class ConcretePrototype implements Prototype { private String property; public ConcretePrototype(String property) { this.property = property; } // 实现克隆方法 @Override public Prototype clone() { return new ConcretePrototype(this.property); } // 设置和获取属性的方法 public String getProperty() { return property; } public void setProperty(String property) { this.property = property; } } // 客户端使用原型模式 public class Client { public static void main(String[] args) { ConcretePrototype prototype = new ConcretePrototype("test"); ConcretePrototype clone = (ConcretePrototype) prototype.clone(); // 克隆对象 System.out.println(prototype.getProperty()); // 输出原型对象的属性 System.out.println(clone.getProperty()); // 输出克隆对象的属性 } } ``` 在上面的代码中，我们定义了一个原型接口 `Prototype`，其中包含一个 `clone` 方法。接着定义了一个具体的原型类 `ConcretePrototype`，实现了原型接口，并实现了 `clone` 方法来创建新的对象。 在客户端中，我们创建了一个原型对象 `prototype`，并通过调用 `clone` 方法创建了一个克隆对象 `clone`。最后输出了原型对象和克隆对象的属性。

代理模式是一种结构型设计模式，它允许通过创建一个代理对象来控制访问另一个对象。代理对象充当客户端和目标对象之间的中介，允许增加额外的行为。该模式提供了一种更加松耦合的方式，以便对目标对象的访问进行控制。 适用的场景： 1. 访问一个远程对象：通过代理对象可以隐藏远程对象的具体实现细节，客户端只需要与代理对象进行交互。 2. 访问一个需要很长时间才能获取的对象：代理对象可以在客户端等待目标对象准备好之前提供一些其他的操作。 3. 实现权限控制：代理对象可以在客户端请求访问目标对象之前进行权限检查，以确保只有合法的用户可以访问。 好处： 1. 代理模式增强了系统的安全性，可以通过代理对象控制对目标对象的访问。 2. 代理模式可以提高系统的性能，通过在代理对象中实现一些缓存机制，减少对目标对象的直接访问，提高响应速度。 3. 代理模式可以实现对目标对象的增强功能，扩展目标对象的行为。 下面是一个使用Java实现代理模式的完整样例代码： ```java // 定义了目标接口 interface Image { void display(); } // 目标对象 class RealImage implements Image { private String filename; public RealImage(String filename) { this.filename = filename; loadFromDisk(); // 初始化时加载图片 } private void loadFromDisk() { System.out.println("Loading image from disk: " + filename); } public void display() { System.out.println("Displaying image: " + filename); } } // 代理对象 class ImageProxy implements Image { private String filename; private RealImage image; public ImageProxy(String filename) { this.filename = filename; } public void display() { if (image == null) { image = new RealImage(filename); } image.display(); } } // 客户端代码 public class ProxyPatternExample { public static void main(String[] args) { Image image = new ImageProxy("sample.jpg"); image.display(); } } ``` 在上面的代码中，`Image`接口是目标接口，`RealImage`是目标对象的具体实现，`ImageProxy`是代理对象。客户端代码通过创建代理对象来访问目标对象，代理对象在需要的时候创建真实对象，并调用其方法。这样做的好处是客户端不直接与目标对象交互，而是通过代理对象进行访问控制和功能增强。

模板方法模式是一种行为设计模式，它定义了一个算法的框架，将算法的具体步骤延迟到子类中实现。模板方法模式通过定义一个抽象类，其中包含了算法的骨架，以及一系列操作步骤的抽象方法。这些抽象方法可以由具体的子类进行实现，从而实现算法的不同实现方式。 模板方法模式适用于以下情况： 1. 当多个类有相似的行为逻辑，但每个类的具体实现步骤可能有所不同时，可以使用模板方法模式。通过将通用的行为逻辑放在抽象类中，将具体的实现步骤延迟到子类中进行实现。 2. 当想要控制一个算法的流程，并允许子类为某些步骤提供自定义实现时，可以使用模板方法模式。通过定义一个骨架算法，其中包含了流程的各个步骤，但某些步骤可以由子类进行重写。 模板方法模式的好处包括： 1. 可以提供统一的算法框架，避免了重复的代码。通过将通用的行为逻辑放在抽象类中，可以减少重复代码的编写，并提高代码的可维护性。 2. 可以灵活地扩展和定制算法的某些步骤。子类可以选择重写父类的某些方法，以实现自定义的行为。 以下是一个Java的完整样例代码，展示了模板方法模式的实现： ```java // 抽象类定义算法的骨架 abstract class AbstractClass { // 模板方法，定义算法的骨架 public final void templateMethod() { // 调用具体的操作步骤 operation1(); operation2(); operation3(); } // 操作步骤1，抽象方法，由子类实现 abstract protected void operation1(); // 操作步骤2，抽象方法，由子类实现 abstract protected void operation2(); // 操作步骤3，抽象方法，由子类实现 abstract protected void operation3(); } // 具体实现类1 class ConcreteClass1 extends AbstractClass { @Override protected void operation1() { System.out.println("ConcreteClass1 operation1"); } @Override protected void operation2() { System.out.println("ConcreteClass1 operation2"); } @Override protected void operation3() { System.out.println("ConcreteClass1 operation3"); } } // 具体实现类2 class ConcreteClass2 extends AbstractClass { @Override protected void operation1() { System.out.println("ConcreteClass2 operation1"); } @Override protected void operation2() { System.out.println("ConcreteClass2 operation2"); } @Override protected void operation3() { System.out.println("ConcreteClass2 operation3"); } } public class Main { public static void main(String[] args) { // 创建具体实现类对象1 AbstractClass obj1 = new ConcreteClass1(); // 调用模板方法 obj1.templateMethod(); // 创建具体实现类对象2 AbstractClass obj2 = new ConcreteClass2(); // 调用模板方法 obj2.templateMethod(); } } ``` 在样例代码中，抽象类`AbstractClass`定义了算法的骨架，包含了三个操作步骤方法。具体的实现类`ConcreteClass1`和`ConcreteClass2`继承自抽象类，并实现了各自的操作步骤逻辑。在`Main`类中，我们创建了两个具体实现类的对象，分别调用了模板方法，从而执行了算法的具体实现。

外观模式是一种结构型设计模式，它通过提供一个统一的接口，封装了一个复杂子系统的组合，使得客户端可以通过该接口简化与子系统之间的交互。 适用的场景： - 当存在一个复杂子系统并且需要向外部提供一个简化的接口时，可以使用外观模式。 - 当需要将子系统与客户端彻底解耦时，可以使用外观模式。 - 当要遵循最少知识原则（也称为迪米特法则）时，可以使用外观模式。 好处： - 简化客户端与复杂子系统之间的交互，减少客户端代码的复杂性。 - 隐藏子系统的复杂性，使得客户端更容易使用子系统。 - 降低了子系统与客户端之间的耦合，使得子系统的更改对客户端的影响降到最低。 下面是一个简单的Java外观模式的示例代码： ```java // 子系统A class SubsystemA { public void operationA() { System.out.println("SubsystemA operation"); } } // 子系统B class SubsystemB { public void operationB() { System.out.println("SubsystemB operation"); } } // 子系统C class SubsystemC { public void operationC() { System.out.println("SubsystemC operation"); } } // 外观类 class Facade { private SubsystemA subsystemA; private SubsystemB subsystemB; private SubsystemC subsystemC; public Facade() { subsystemA = new SubsystemA(); subsystemB = new SubsystemB(); subsystemC = new SubsystemC(); } public void operationOne() { subsystemA.operationA(); subsystemB.operationB(); } public void operationTwo() { subsystemB.operationB(); subsystemC.operationC(); } } // 客户端 public class Client { public static void main(String[] args) { Facade facade = new Facade(); facade.operationOne(); facade.operationTwo(); } } ``` 在上述示例代码中，子系统A、子系统B和子系统C分别提供了不同的操作，外观类Facade封装了这些操作，并对外提供了operationOne和operationTwo两个简化的操作。这样，客户端只需要通过Facade与子系统进行交互，而无需了解子系统的具体实现细节，从而简化了客户端的使用。