Factory pattern is a creative design pattern used to create objects. It hides the specific implementation of the object and only provides a unified interface to the client to create the object. By delegating the creation logic of the object to the factory class, the client can avoid directly instantiating the object, thereby improving the maintainability and flexibility of the code. Applicable scenarios: When a class does not know or care about the class of the object it needs to create, the factory pattern can be used. For example, the client only needs to know the abstract product class interface without knowing the specific product class implementation. When a class wishes to have subclasses specify the creation of objects, the factory pattern can be used, for example, the product creation process can be moved to subclasses. When a class needs to create different objects based on runtime conditions, factory mode can be used. Benefits: 1. The factory mode separates the creation and use of objects, so that the client only needs to care about the use of objects and does not need to care about the object creation process. 2. The factory model meets the open closed principle, which is open for expansion and closed for modification. You can extend the factory by adding new specific product classes without modifying the client code. 3. The factory mode can effectively encapsulate the details of creating objects, making the client code more concise and readable. The following is a complete sample code for implementing the factory pattern using the Java language: ```java //Abstract Product Class interface Product { void operation(); } //Specific product category A class ConcreteProductA implements Product { @Override public void operation() { System.out.println("ConcreteProductA"); } } //Specific product category B class ConcreteProductB implements Product { @Override public void operation() { System.out.println("ConcreteProductB"); } } //Factory class 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"); } } } //Client 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(); } } ``` In the above code, 'Product' represents an abstract product class, 'ConcreteProductA' and 'ConcreteProductB' represent specific product classes, and 'Factory' represents factory classes` The 'createProduct' method in the Factory class creates corresponding specific product objects based on the passed in product type. In the client code, create a specific product object through the 'createProduct' method of the factory class and call its' operation 'method. Based on the incoming product type, the factory class returns the corresponding specific product object. The output result is: ``` ConcreteProductA ConcreteProductB ```

The Singleton pattern is a creative design pattern, which aims to ensure that there is only one instance of a class and provide a global access point. Applicable scenario: 1. When it is necessary to ensure that there is only one instance of a class in the system, the Singleton pattern can be used. For example, database Connection pool, Thread pool and other shared resources. 2. When you need to instantiate an object frequently, you can use the Singleton pattern to improve performance. Because the Singleton pattern can only create one instance, multiple calls will not repeat the creation. Benefits: 1. Singleton pattern can reduce memory expenditure because it only creates one instance and reduces the generation of objects. 2. The Singleton pattern can avoid multiple occupation of resources, such as Thread pool, database Connection pool, etc. 3. The Singleton pattern can provide a global access point in the whole system to facilitate the operation of instances. The following is the complete sample code for implementing the Singleton pattern in Java: ```java public class Singleton { //Privatizing constructors to prevent external instantiation of objects private Singleton() { } //Create a static private instance private static Singleton instance; //Provide global access points to obtain singleton instances public static Singleton getInstance() { if (instance == null) { synchronized (Singleton.class) { if (instance == null) { instance = new Singleton(); } } } return instance; } } ``` In the above code, the constructor of the Singleton class is privatized, ensuring that other classes cannot create Singleton instances through the new keyword. The getInstance method can obtain a unique instance of Singleton. If the instance is empty, it is created through double check locking. Double check locking is to ensure normal operation in a multithreaded environment.

Observer pattern is a behavioral design pattern used to establish one to many dependencies between objects. When an object's state changes, its related dependent objects will be automatically notified and updated. This mode includes the following roles: 1. Subject: The observed, that is, the object being observed. It maintains a list of observers that can be added or removed, and notifies observers when the state changes. 2. Observer: The observer interface defines the general methods of the observer for being called by the topic. 3. Concrete Subject: A specific class of the observed object that implements the subject interface and maintains the current state. 4. Concrete Observer: A specific observer class that implements the observer interface and updates its own state when notified. Applicable scenarios: 1. When the state change of an object needs to be notified to multiple other objects, and the specific number of these objects is unknown in advance or changes dynamically, the Observer pattern can be used. 2. When an object needs to notify other objects of its changes, but does not want to form a tight coupling relationship with the notified object, the Observer pattern can be used. The benefits of this design pattern are as follows: 1. Low coupling: The Observer pattern can decouple the subject and the observer, making the relationship between them loose. 2. Scalability: New observers can be added at any time, making the system easier to scale. 3. Notify at any time: When there is a change in the status of the topic, the observer can be notified at any time to ensure that the observer can update their own status in a timely manner. The following is a simple code example for implementing the Observer pattern in Java: ```java import java.util.ArrayList; import java.util.List; //Observer Interface interface Observer { void update(String message); } //Observer Interface interface Subject { void attach(Observer observer); void detach(Observer observer); void notifyObservers(String message); } //Specific Observer Class 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); } } //Specific categories of observed individuals 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); } } //Sample code 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"); } } ``` The above code represents the relationship between a Concrete Subject and two Concrete Observers. When the status of the topic changes, all observers are notified and their status is updated. Run the sample code and the output is as follows: ``` Subject state changed to: New State Observer1 received message: New State Observer2 received message: New State ``` The above code is just a simple example of the Observer pattern, which can be expanded and customized according to specific requirements in practical applications.

The Adapter pattern belongs to the structural design pattern. It converts the interface of a class into another interface expected by the client, so that two classes that could not work together because of interface mismatch can work together. The Adapter pattern can solve the compatibility problem of the system, so that the incompatible interfaces can work together seamlessly. Applicable scenario: 1. When the system needs to use existing classes, and the interfaces of these classes do not meet the requirements of the system, the Adapter pattern can be used. 2. When you need to reuse some existing classes, but the interfaces of these classes do not meet the current system requirements, you can use the Adapter pattern. 3. When you need to create a reusable class that works with some incompatible classes, you can use the Adapter pattern. The Adapter pattern has three main roles: 1. Target interface: Define the interface that the client expects to use. 2. Adapter: The adapter implements the target interface, which contains an adapted object. 3. Adaptee: An existing class or object that needs to be adapted. The following is the sample code of a Java Adapter pattern: ```java //Target interface interface Target { void request(); } //Adapted class Adaptee { public void specificRequest() { System. out. println ("The method of the adapter is called"); } } //Adapter class Adapter implements Target { private Adaptee adaptee; public Adapter(Adaptee adaptee) { this.adaptee = adaptee; } public void request() { adaptee.specificRequest(); } } //Client public class Client { public static void main(String[] args) { Adaptee adaptee = new Adaptee(); Target target = new Adapter(adaptee); target.request(); } } ``` In the above code, 'Target' is the interface that the client expects to use, 'Adaptee' is an existing adapted class, and 'Adapter' is an adapter that implements the 'Target' interface and includes an 'Adaptee' object. In the client code, first create a 'Adaptee' object, and then convert it into an object available to the target interface 'Target' through the adapter 'Adapter', and call the 'request()' method. The execution result is printed as' the method of the adapted person has been called '.

Strategy pattern is a behavioral design pattern that allows the algorithm to be changed independently of the client using it. This pattern defines a series of algorithm classes and encapsulates each algorithm into a class, allowing them to replace each other, allowing the client to dynamically select the desired algorithm. Applicable scenario: When a system needs to select one of several algorithms to execute, and these algorithms have a common behavioral interface, Strategy pattern can be considered. It can isolate algorithm changes from the clients using the algorithm, facilitating the addition, replacement, or deletion of policies without affecting the clients. The benefits of this design pattern are as follows: By encapsulating the changing parts, the algorithm is decoupled from the client, improving the flexibility and maintainability of the code. 2. The expansion and changes of the algorithm will not affect the client, just add a specific policy class. 3. The Strategy pattern transfers the selection of algorithms from the client to the environment class, which makes the selection of algorithms more flexible and can be dynamically changed at runtime. Here is a simple Java code example: Firstly, define a policy interface that includes the algorithms that need to be replaced: ```java public interface Strategy { public void execute(); } ``` Then, implement specific policy classes, each of which encapsulates specific algorithms: ```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"); } } ``` Next, create an environment class to maintain policy objects and select policies on the client as needed: ```java public class Context { private Strategy strategy; public Context(Strategy strategy) { this.strategy = strategy; } public void executeStrategy() { strategy.execute(); } } ``` Finally, use the Strategy pattern in the client code: ```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(); } } ``` In this way, according to different choices, the client can flexibly choose and switch different strategies without modifying the original code.

The Builder pattern is a creative design pattern that aims to separate the construction process of a complex object from its representation, so that the same construction process can create different representations. Applicable scenario: When the construction process of an object is complex and requires multiple steps to be executed in a specific order, the builder pattern can be used. For example, the construction process of a car includes multiple steps such as creating a body, installing an engine, and installing tires, each with a specific sequence. When the same construction process can create different representations, it is also suitable to use the builder pattern. For example, the construction process of a car can create different types such as sedans, SUVs, sports cars, etc. Benefits: The benefits of the builder mode include: 1. Decouple the construction process and representation, making the code structure clearer. 2. Different presentation objects can be created by controlling different builders. 3. The builder pattern can reuse the same build process to build different objects. Here is a simple Java code example: ``` //Product class, which is the complex object to be constructed 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 builder class, defining abstract methods for the construction process 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; } } //Specific builder classes, specific methods for implementing the construction process 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"); } } //Commander class, responsible for building objects 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(); } } //Client code 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); } } ``` Output results: ``` Sedan Car: Car{engine='Sedan Engine', tire='Sedan Tire'} SUV Car: Car{engine='SUV Engine', tire='SUV Tire'} ``` In the above example, Car is the complex object to be constructed, and CarBuilder is the abstract builder class that defines the abstract methods for the construction process. SedanCarBuilder and SUVCarBuilder are specific builder classes that implement specific methods for the construction process. Director is the director class responsible for building objects. The client code constructs different types of Car objects by setting different builders.

Prototype pattern is a creative design pattern, which allows to create new objects by copying (cloning) existing objects. This pattern hides the creation logic of new objects, making the code more flexible and scalable. Applicable scenario: 1. When the process of creating objects is complex or time-consuming, you can use the Prototype pattern to copy an existing object to create a new object. This can avoid complex object initialization processes. 2. When you need to create an object similar to an existing object, you can use the Prototype pattern to copy the properties and methods of the existing object. This can reduce the repeatability of the code. Benefits: 1. Simplify the process of creating objects and hide the creation logic. Users only need to call the clone method to create a new object without needing to know the details of the creation process. 2. Improve performance. Cloning objects avoids the overhead of creating objects by copying the properties and methods of existing objects. 3. You can dynamically add or modify the properties of the prototype to achieve personalized object creation. The following is a complete sample code for Java: ```java //Define prototype interfaces public interface Prototype { Prototype clone()// Cloning method } //Specific prototype class public class ConcretePrototype implements Prototype { private String property; public ConcretePrototype(String property) { this.property = property; } //Implementing cloning methods @Override public Prototype clone() { return new ConcretePrototype(this.property); } //Method for Setting and Obtaining Properties public String getProperty() { return property; } public void setProperty(String property) { this.property = property; } } //The client uses Prototype pattern public class Client { public static void main(String[] args) { ConcretePrototype prototype = new ConcretePrototype("test"); Concrete Prototype clone=(Concrete Prototype) prototype. clone ()// Clone Objects System. out. println (prototype. getProperty())// Output the properties of the prototype object System. out. println (clone. getProperty())// Output properties of cloned objects } } ``` In the above code, we defined a prototype interface called 'Prototype', which includes a 'clone' method. Next, a specific prototype class' ConcretePrototype 'was defined, the prototype interface was implemented, and the' clone 'method was implemented to create new objects. In the client, we created a prototype object 'prototype' and created a clone object 'clone' by calling the 'clone' method. Finally, the attributes of the prototype object and the cloned object were output.

The Proxy pattern is a structural design pattern that allows you to control access to another object by creating a proxy object. The proxy object acts as a mediator between the client and the target object, allowing for additional behavior to be added. This pattern provides a more Loose coupling way to control access to target objects. Applicable scenarios: 1. Accessing a remote object: By using a proxy object, the specific implementation details of the remote object can be hidden, and the client only needs to interact with the proxy object. 2. Accessing an object that takes a long time to obtain: The proxy object can provide some other operations before the client waits for the target object to be ready. 3. Implement permission control: Proxy objects can perform permission checks before clients request access to the target object to ensure that only legitimate users can access it. Benefits: 1. The Proxy pattern enhances the security of the system, and the access to the target object can be controlled through the proxy object. 2. Proxy pattern can improve the performance of the system. By implementing some caching mechanisms in proxy objects, it can reduce direct access to target objects and improve response speed. 3. The Proxy pattern can enhance the target object and expand its behavior. The following is a complete sample code for implementing the Proxy pattern using Java: ```java //Defined target interface interface Image { void display(); } //Target object class RealImage implements Image { private String filename; public RealImage(String filename) { this.filename = filename; LoadFromDisk()// Load images during initialization } private void loadFromDisk() { System.out.println("Loading image from disk: " + filename); } public void display() { System.out.println("Displaying image: " + filename); } } //Proxy Object 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(); } } //Client code public class ProxyPatternExample { public static void main(String[] args) { Image image = new ImageProxy("sample.jpg"); image.display(); } } ``` In the above code, the 'Image' interface is the target interface, the 'RealImage' is the specific implementation of the target object, and the 'ImageProxy' is the proxy object. The client code accesses the target object by creating a proxy object, which creates the real object when needed and calls its methods. The advantage of doing so is that the client does not directly interact with the target object, but instead controls access and enhances functionality through proxy objects.

The Template method pattern pattern is a behavior design pattern that defines an algorithm framework and delays the specific steps of the algorithm to subclasses. The Template method pattern pattern defines an abstract class, which contains the skeleton of the algorithm and a series of abstract methods for operation steps. These abstract methods can be implemented by specific subclasses to achieve different implementations of algorithms. The Template method pattern mode is applicable to the following situations: 1. When multiple classes have similar behavior logic, but the specific implementation steps of each class may be different, the Template method pattern pattern can be used. By placing common behavioral logic in abstract classes, specific implementation steps are deferred to subclasses for implementation. 2. When you want to control the flow of an algorithm and allow subclasses to provide custom implementations for certain steps, you can use the Template method pattern pattern. By defining a skeleton algorithm that includes various steps of the process, but some steps can be rewritten by subclasses. The benefits of the Template method pattern mode include: 1. It can provide a unified algorithm framework to avoid duplicate code. By placing common behavioral logic in abstract classes, repetitive code writing can be reduced and the maintainability of the code can be improved. 2. Some steps of the algorithm can be flexibly extended and customized. Subclasses can choose to override certain methods of the parent class to achieve custom behavior. The following is a complete sample code of Java, showing the implementation of the Template method pattern pattern: ```java //Skeleton of Abstract Class Definition Algorithm abstract class AbstractClass { //The Template method pattern defines the skeleton of the algorithm public final void templateMethod() { //Call specific operation steps operation1(); operation2(); operation3(); } //Operation Step 1, Abstract Method, Implemented by Subclass abstract protected void operation1(); //Operation Step 2, Abstract Method, Implemented by Subclass abstract protected void operation2(); //Operation Step 3, Abstract Method, Implemented by Subclass abstract protected void operation3(); } //Specific Implementation Class 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"); } } //Specific Implementation Class 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) { //Create specific implementation class object 1 AbstractClass obj1 = new ConcreteClass1(); //Call Template method pattern obj1.templateMethod(); //Create specific implementation class object 2 AbstractClass obj2 = new ConcreteClass2(); //Call Template method pattern obj2.templateMethod(); } } ``` In the sample code, the abstract class' AbstractClass' defines the skeleton of the algorithm and includes three operational steps and methods. The specific implementation classes' ConcreteClass1 'and' ConcreteClass2 'inherit from the abstract class and implement their respective operation step logic. In the 'Main' class, we created two objects of specific implementation classes, called the Template method pattern respectively, and implemented the specific implementation of the algorithm.

Facade pattern is a structural design mode, which encapsulates a complex subsystem combination by providing a unified interface, so that the client can simplify the interaction with the subsystem through this interface. Applicable scenarios: -When there is a complex subsystem and a simplified interface needs to be provided to the outside, Facade pattern can be used. -When the subsystem needs to be completely decoupled from the client, Facade pattern can be used. -Facade pattern can be used when following the principle of least knowledge (also known as Dimit's Law). Benefits: -Simplify the interaction between clients and complex subsystems, and reduce the complexity of client code. -The complexity of hidden subsystems makes it easier for clients to use them. -Reduced the coupling between subsystems and clients, minimizing the impact of subsystem changes on clients. The following is a sample code of a simple Java Facade pattern: ```java //Subsystem A class SubsystemA { public void operationA() { System.out.println("SubsystemA operation"); } } //Subsystem B class SubsystemB { public void operationB() { System.out.println("SubsystemB operation"); } } //Subsystem C class SubsystemC { public void operationC() { System.out.println("SubsystemC operation"); } } //Appearance class 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(); } } //Client public class Client { public static void main(String[] args) { Facade facade = new Facade(); facade.operationOne(); facade.operationTwo(); } } ``` In the above example code, subsystem A, subsystem B, and subsystem C each provide different operations. The facade class encapsulates these operations and provides two simplified operations, operationOne and operationTwo, externally. In this way, the client only needs to interact with the subsystem through Facade without understanding the specific implementation details of the subsystem, thus simplifying the use of the client.