常见的设计模式结构+例子

一、工厂模式

（一）简单工厂模式

结构：

• 工厂类：负责创建产品对象，通常有一个创建产品的方法，根据传入的参数决定创建哪种具体产品。
• 抽象产品类：定义产品的公共接口。
• 具体产品类：实现抽象产品类，代表具体的产品类型。

Java代码例子：

// 抽象产品类
interface Product {
    void operation();
}

// 具体产品类A
class ConcreteProductA implements Product {
    @Override
    public void operation() {
        System.out.println("ConcreteProductA operation");
    }
}

// 具体产品类B
class ConcreteProductB implements Product {
    @Override
    public void operation() {
        System.out.println("ConcreteProductB operation");
    }
}

// 简单工厂类
class SimpleFactory {
    public static Product createProduct(String type) {
        if ("A".equals(type)) {
            return new ConcreteProductA();
        } else if ("B".equals(type)) {
            return new ConcreteProductB();
        }
        return null;
    }
}

（二）抽象工厂模式

结构：

• 抽象工厂接口：定义创建一系列相关或相互依赖对象的方法。
• 具体工厂类：实现抽象工厂接口，负责创建具体的产品对象组合。
• 抽象产品接口：有多个，分别对应不同类型的产品。
• 具体产品类：实现相应的抽象产品接口。

Java代码例子：

// 抽象产品A接口
interface AbstractProductA {
    void operationA();
}

// 抽象产品B接口
interface AbstractProductB {
    void operationB();
}

// 具体产品A1类
class ConcreteProductA1 implements AbstractProductA {
    @Override
    public void operationA() {
        System.out.println("ConcreteProductA1 operationA");
    }
}

// 具体产品A2类
class ConcreteProductA2 implements AbstractProductA {
    @Override
    public void operationA() {
        System.out.println("ConcreteProductA2 operationA");
    }
}

// 具体产品B1类
class ConcreteProductB1 implements AbstractProductB {
    @Override
    public void operationB() {
        System.out.println("ConcreteProductB1 operationB");
    }
}

// 具体产品B2类
class ConcreteProductB2 implements AbstractProductB {
    @Override
    public void operationB() {
        System.out.println("ConcreteProductB2 operationB");
    }
}

// 抽象工厂接口
interface AbstractFactory {
    AbstractProductA createProductA();
    AbstractProductB createProductB();
}

// 具体工厂1
class ConcreteFactory1 implements AbstractFactory {
    @Override
    public AbstractProductA createProductA() {
        return new ConcreteProductA1();
    }

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

// 具体工厂2
class ConcreteFactory2 implements AbstractFactory {
    @Override
    public AbstractProductA createProductA() {
        return new ConcreteProductA2();
    }

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

二、代理模式

结构：

• 抽象主题类：定义了真实主题和代理主题的公共接口。
• 真实主题类：实现抽象主题类，完成实际的业务功能。
• 代理类：实现抽象主题类，内部包含对真实主题类的引用，在调用真实主题类的方法前后可以添加额外的逻辑，如权限验证、日志记录等。

Java代码例子：

// 抽象主题类
interface Subject {
    void doSomething();
}

// 真实主题类
class RealSubject implements Subject {
    @Override
    public void doSomething() {
        System.out.println("RealSubject is doing something");
    }
}

// 代理类
class ProxySubject implements Subject {
    private RealSubject realSubject;

    public ProxySubject(RealSubject realSubject) {
        this.realSubject = realSubject;
    }

    @Override
    public void doSomething() {
        // 可以在调用真实主题方法前添加逻辑，比如权限验证
        System.out.println("Proxy checking permissions...");
        realSubject.doSomething();
        // 也可以在调用后添加逻辑，比如日志记录
        System.out.println("Proxy logged the operation.");
    }
}

这样的格式是否更清晰一些呢？你还想了解关于这些设计模式的其他方面吗？