设计模式的概念

设计模式是指在软件设计中，经过反复验证证明，被广泛使用的解决某一类问题的经验总结。设计模式不是一种具体的代码实现，而是一种解决问题的方法论，它提供了一套通用的解决方案，可以帮助我们更好地设计出高质量、可复用、易维护的软件系统。

单例模式

单例模式是指在整个系统中只能存在一个实例对象的设计模式。在实际开发中，单例模式常被用于管理资源、配置信息等场景中。

单例模式有两种实现方式：懒汉式和饿汉式。懒汉式在第一次调用getInstance()方法时才创建实例，而饿汉式则在类加载时就创建实例。

以下是懒汉式单例模式的示例代码：

public class Singleton {
    private static Singleton instance;
    
    private Singleton() {}
    
    public static Singleton getInstance() {
        if (instance == null) {
            instance = new Singleton();
        }
        return instance;
    }
}

以下是饿汉式单例模式的示例代码：

public class Singleton {
    private static Singleton instance = new Singleton();
    
    private Singleton() {}
    
    public static Singleton getInstance() {
        return instance;
    }
}

工厂模式

工厂模式是指通过一个工厂类来创建对象的设计模式。工厂模式可以隐藏对象的创建过程，使得客户端代码和具体的类实现解耦，从而提高了代码的可维护性和可扩展性。

工厂模式有三种实现方式：简单工厂模式、工厂方法模式和抽象工厂模式。其中，简单工厂模式将所有的对象创建逻辑都放在一个工厂类中，工厂方法模式则是将每个具体对象的创建逻辑都放在其对应的工厂类中，而抽象工厂模式则是将一组相关的对象的创建逻辑放在一个抽象工厂类中。

以下是简单工厂模式的示例代码：

public class SimpleFactory {
    public static Product createProduct(String type) {
        if (type.equals("A")) {
            return new ConcreteProductA();
        } else if (type.equals("B")) {
            return new ConcreteProductB();
        } else {
            throw new IllegalArgumentException("Invalid product type: " + type);
        }
    }
}

public interface Product {
    void doSomething();
}

public class ConcreteProductA implements Product {
    @Override
    public void doSomething() {
        System.out.println("I am product A.");
    }
}

public class ConcreteProductB implements Product {
    @Override
    public void doSomething() {
        System.out.println("I am product B.");
    }
}

以下是工厂方法模式的示例代码：

public interface Factory {
    Product createProduct();
}

public class ConcreteFactoryA implements Factory {
    @Override
    public Product createProduct() {
        return new ConcreteProductA();
    }
}

public class ConcreteFactoryB implements Factory {
    @Override
    public Product createProduct() {
        return new ConcreteProductB();
    }
}

public interface Product {
    void doSomething();
}

public class ConcreteProductA implements Product {
    @Override
    public void doSomething() {
        System.out.println("I am product A.");
    }
}

public class ConcreteProductB implements Product {
    @Override
    public void doSomething() {
        System.out.println("I am product B.");
    }
}

以下是抽象工厂模式的示例代码：

public interface AbstractFactory {
    ProductA createProductA();
    ProductB createProductB();
}

public interface ProductA {
    void doSomething();
}

public interface ProductB {
    void doSomething();
}

public class ConcreteFactory1 implements AbstractFactory {
    @Override
    public ProductA createProductA() {
        return new ConcreteProductA1();
    }

    @Override
    public ProductB createProductB() {
        return new ConcreteProductB1();
    }
}

public class ConcreteFactory2 implements AbstractFactory {
    @Override
    public ProductA createProductA() {
        return new ConcreteProductA2();
    }

    @Override
    public ProductB createProductB() {
        return new ConcreteProductB2();
    }
}

public class ConcreteProductA1 implements ProductA {
    @Override
    public void doSomething() {
        System.out.println("Product A1.");
    }
}

public class ConcreteProductA2 implements ProductA {
    @Override
    public void doSomething() {
        System.out.println("Product A2.");
    }
}

public class ConcreteProductB1 implements ProductB {
    @Override
    public void doSomething() {
        System.out.println("Product B1.");
    }
}

public class ConcreteProductB2 implements ProductB {
    @Override
    public void doSomething() {
        System.out.println("Product B2.");
    }
}

代理模式

代理模式是指通过一个代理类来控制对另一个对象的访问的设计模式。代理模式可以实现对另一个对象的访问控制、实现延迟加载等功能。

代理模式有两种实现方式：静态代理和动态代理。静态代理是指手动编写一个代理类来实现对另一个对象的访问控制，而动态代理则是在运行时动态生成代理类来实现访问控制。

以下是静态代理模式的示例代码：

public interface Subject {
    void doSomething();
}

public class RealSubject implements Subject {
    @Override
    public void doSomething() {
        System.out.println("RealSubject do something.");
    }
}

public class ProxySubject implements Subject {
    private RealSubject realSubject;
    
    public ProxySubject(RealSubject realSubject) {
        this.realSubject = realSubject;
    }

    @Override
    public void doSomething() {
        System.out.println("Before do something.");
        realSubject.doSomething();
        System.out.println("After do something.");
    }
}

以下是动态代理模式的示例代码：

public interface Subject {
    void doSomething();
}

public class RealSubject implements Subject {
    @Override
    public void doSomething() {
        System.out.println("RealSubject do something.");
    }
}

public class ProxyHandler implements InvocationHandler {
    private Object target;

    public ProxyHandler(Object target) {
        this.target = target;
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("Before do something.");
        Object result = method.invoke(target, args);
        System.out.println("After do something.");
        return result;
    }
}

public class ProxySubject {
    public static Subject createProxySubject() {
        RealSubject realSubject = new RealSubject();
        ProxyHandler handler = new ProxyHandler(realSubject);
        return (Subject) Proxy.newProxyInstance(realSubject.getClass().getClassLoader(),
                realSubject.getClass().getInterfaces(), handler);
    }
}

观察者模式

观察者模式是指一个对象状态的改变会通知其它多个对象，从而实现对象间的松耦合的设计模式。观察者模式可以用于实现事件处理、消息通知等功能。

观察者模式包含两个角色：被观察者和观察者。被观察者负责维护一个观察者列表，并在状态发生改变时通知所有的观察者。观察者则负责接收被观察者的通知，并进行相应的处理。

以下是观察者模式的示例代码：

public interface Observer {
    void update(String message);
}

public interface Subject {
    void registerObserver(Observer observer);
    void removeObserver(Observer observer);
    void notifyObservers(String message);
}

public class ConcreteSubject implements Subject {
    private List<Observer> observers = new ArrayList<>();

    @Override
    public void registerObserver(Observer observer) {
        observers.add(observer);
    }

    @Override
    public void removeObserver(Observer observer) {
        observers.remove(observer);
    }

    @Override
    public void notifyObservers(String message) {
        for (Observer observer : observers) {
            observer.update(message);
        }
    }
}

public 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);
    }
}

装饰器模式

装饰器模式是指在不改变原有对象的基础上，通过包装（装饰）的方式来扩展对象的功能的设计模式。装饰器模式可以动态地添加、移除功能，从而实现对对象的动态扩展。

装饰器模式包含三个角色：抽象组件、具体组件和装饰器。抽象组件是被装饰的对象的抽象表示，具体组件则是被装饰的对象的具体实现，而装饰器则是扩展组件功能的装饰对象。

以下是装饰器模式的示例代码：

public interface Component {
    void operation();
}

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

public abstract class Decorator implements Component {
    private Component component;

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

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

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

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

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

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

适配器模式

适配器模式是指将一个类的接口转换成另一个类的接口，从而实现不兼容接口之间的适配的设计模式。适配器模式可以用于解决接口不兼容的问题，从而实现系统的集成。

适配器模式包含两个角色：适配器和被适配者。适配器负责将被适配者的接口转换成目标接口，被适配者则是需要被适配的对象。

以下是适配器模式的示例代码：

public interface Target {
    void request();
}

public class Adaptee {
    public void specificRequest() {
        System.out.println("Adaptee specificRequest.");
    }
}

public class Adapter implements Target {
    private Adaptee adaptee;

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

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

模板方法模式

模板方法模式是指定义一个算法框架，将一些具体步骤的实现延迟到子类中，从而实现算法的复用的设计模式。模板方法模式可以用于实现一些固定的流程或规则，从而提高代码的可维护性和可扩展性。

模板方法模式包含两个角色：抽象模板和具体模板。抽象模板定义了算法框架，具体模板则实现了具体的步骤。

以下是模板方法模式的示例代码：

public abstract class AbstractTemplate {
    public void templateMethod() {
        doStep1();
        doStep2();
        doStep3();
    }

    protected abstract void doStep1();
    protected abstract void doStep2();
    protected abstract void doStep3();
}

public class ConcreteTemplate extends AbstractTemplate {
    @Override
    protected void doStep1() {
        System.out.println("ConcreteTemplate do step1.");
    }

    @Override
    protected void doStep2() {
        System.out.println("ConcreteTemplate do step2.");
    }

    @Override
    protected void doStep3() {
        System.out.println("ConcreteTemplate do step3.");
    }
}

策略模式

策略模式是指定义一组算法，将每个算法封装起来，并使它们之间可以相互替换的设计模式。策略模式可以用于实现动态选择算法、减少代码重复等功能。

策略模式包含三个角色：策略、具体策略和上下文。策略定义了一组算法的抽象接口，具体策略实现了具体的算法，而上下文负责维护一个策略的引用，并在需要时调用具体策略的算法。

以下是策略模式的示例代码：

public interface Strategy {
    void doSomething();
}

public class ConcreteStrategyA implements Strategy {
    @Override
    public void doSomething() {
        System.out.println("ConcreteStrategyA do something.");
    }
}

public class ConcreteStrategyB implements Strategy {
    @Override
    public void doSomething() {
        System.out.println("ConcreteStrategyB do something.");
    }
}

public class Context {
    private Strategy strategy;

    public Context(Strategy strategy) {
        this.strategy = strategy;
    }

    public void doSomething() {
        strategy.doSomething();
    }
}

建造者模式

建造者模式是指将一个复杂对象的构建过程与其表示分离，从而使得同样的构建过程可以创建不同的表示的设计模式。建造者模式可以用于创建一些复杂的对象，从而提高代码的可读性和可维护性。

建造者模式包含四个角色：抽象建造者、具体建造者、指挥者和产品。抽象建造者定义了构建对象的抽象接口，具体建造者实现了具体的构建过程，指挥者负责调用具体建造者的接口来构建产品，而产品则是最终构建出来的结果。

以下是建造者模式的示例代码：

public class Product {
    private String part1;
    private String part2;

    public String getPart1() {
        return part1;
    }

    public void setPart1(String part1) {
        this.part1 = part1;
    }

    public String getPart2() {
        return part2;
    }

    public void setPart2(String part2) {
        this.part2 = part2;
    }

    @Override
    public String toString() {
        return "Product{" +
                "part1='" + part1 + '\'' +
                ", part2='" + part2 + '\'' +
                '}';
    }
}

public interface Builder {
    void buildPart1(String part1);
    void buildPart2(String part2);
    Product getResult();
}

public class ConcreteBuilder implements Builder {
    private Product product = new Product();

    @Override
    public void buildPart1(String part1) {
        product.setPart1(part1);
    }

    @Override
    public void buildPart2(String part2) {
        product.setPart2(part2);
    }

    @Override
    public Product getResult() {
        return product;
    }
}

public class Director {
    public void construct(Builder builder) {
        builder.buildPart1("part1");
        builder.buildPart2("part2");
    }
}