设计模式概述 - 工厂方法 & 原型 & 模板方法 & 外观

工厂方法模式简述

工厂方法模式（Factory Method Pattern）是一种创建型设计模式，它定义了一个用于创建对象的接口，但由子类决定实例化哪个类。工厂方法将类的实例化推迟到子类。

角色

• 产品接口（Product）：定义产品的接口。
• 具体产品（ConcreteProduct）：实现产品接口的具体类。
• 工厂接口（Creator）：定义创建产品的工厂方法。
• 具体工厂（ConcreteCreator）：实现工厂接口，返回具体产品的实例。

优点

• 解耦：客户端不需要知道具体产品的类，只需依赖于产品接口。
• 扩展性：增加新产品时只需新增具体产品和具体工厂，而不需要修改已有代码。

缺点

• 类的数量增加：每增加一种产品，就需要增加一个具体产品和一个具体工厂，可能导致类的数量增加。
• 复杂性：对于简单的场景，使用工厂方法模式可能显得过于复杂。

示例代码

// 产品接口
interface Product {
    void use();
}

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

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

// 工厂接口
abstract class Creator {
    public abstract Product factoryMethod();
}

// 具体工厂A
class ConcreteCreatorA extends Creator {
    @Override
    public Product factoryMethod() {
        return new ConcreteProductA();
    }
}

// 具体工厂B
class ConcreteCreatorB extends Creator {
    @Override
    public Product factoryMethod() {
        return new ConcreteProductB();
    }
}

// 客户端代码
public class Client {
    public static void main(String[] args) {
        Creator creatorA = new ConcreteCreatorA();
        Product productA = creatorA.factoryMethod();
        productA.use();

        Creator creatorB = new ConcreteCreatorB();
        Product productB = creatorB.factoryMethod();
        productB.use();
    }
}

原型模式简述

原型模式（Prototype Pattern）是一种创建型设计模式，它通过复制现有的实例来创建新对象，而不是通过实例化一个新的对象。这种模式适用于创建相似对象的场景，尤其是在创建对象的成本较高时。

角色

• 原型接口（Prototype）：定义克隆方法。
• 具体原型（ConcretePrototype）：实现原型接口，提供具体的克隆方法。
• 客户端（Client）：使用原型对象来创建新的对象。

优点

• 性能提升：通过复制现有对象来创建新对象，避免了重复的初始化过程。
• 简化创建过程：可以通过克隆现有对象来简化对象的创建过程。

缺点

• 复杂性：实现克隆方法可能会增加代码的复杂性，尤其是在对象包含复杂的成员时。
• 深拷贝与浅拷贝：需要关注对象的拷贝方式，深拷贝和浅拷贝的选择可能会影响对象的状态。

示例代码

// 原型接口
interface Prototype {
    Prototype clone();
}

// 具体原型
class ConcretePrototype implements Prototype {
    private String name;

    public ConcretePrototype(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }

    @Override
    public Prototype clone() {
        return new ConcretePrototype(this.name);
    }
}

// 客户端代码
public class Client {
    public static void main(String[] args) {
        ConcretePrototype original = new ConcretePrototype("Original");
        ConcretePrototype clone = (ConcretePrototype) original.clone();

        System.out.println("Original Name: " + original.getName());
        System.out.println("Cloned Name: " + clone.getName());
    }
}

模板方法模式简述

模板方法模式（Template Method Pattern）是一种行为型设计模式，它定义了一个算法的骨架，并允许子类在不改变算法结构的情况下重新定义某些特定步骤。通过这种方式，模板方法模式可以实现代码复用和算法的灵活性。

角色

• 抽象类（AbstractClass）：定义模板方法和一些基本操作的接口。
• 具体类（ConcreteClass）：实现抽象类中的某些操作，完成特定的算法步骤。

优点

• 代码复用：通过将算法的公共部分放在抽象类中，减少了代码重复。
• 灵活性：子类可以根据需要重写某些步骤，灵活定制算法的具体实现。

缺点

• 增加复杂性：模板方法模式可能会导致类的数量增加，从而增加系统的复杂性。
• 限制扩展：子类只能重写抽象类中定义的方法，可能会限制某些灵活性。

示例代码

// 抽象类
abstract class AbstractClass {
    // 模板方法
    public final void templateMethod() {
        stepOne();
        stepTwo();
        stepThree();
    }

    // 基本方法
    protected abstract void stepOne();
    protected abstract void stepTwo();

    // 钩子方法
    protected void stepThree() {
        System.out.println("Default Step Three Implementation.");
    }
}

// 具体类A
class ConcreteClassA extends AbstractClass {
    @Override
    protected void stepOne() {
        System.out.println("ConcreteClassA: Step One Implementation.");
    }

    @Override
    protected void stepTwo() {
        System.out.println("ConcreteClassA: Step Two Implementation.");
    }
}

// 具体类B
class ConcreteClassB extends AbstractClass {
    @Override
    protected void stepOne() {
        System.out.println("ConcreteClassB: Step One Implementation.");
    }

    @Override
    protected void stepTwo() {
        System.out.println("ConcreteClassB: Step Two Implementation.");
    }

    @Override
    protected void stepThree() {
        System.out.println("ConcreteClassB: Custom Step Three Implementation.");
    }
}

// 客户端代码
public class Client {
    public static void main(String[] args) {
        AbstractClass classA = new ConcreteClassA();
        classA.templateMethod();

        System.out.println();

        AbstractClass classB = new ConcreteClassB();
        classB.templateMethod();
    }
}

外观模式简述

外观模式（Facade Pattern）是一种结构型设计模式，它为复杂的子系统提供一个统一的接口，使得子系统更易使用。通过外观模式，客户端可以通过一个简单的接口与复杂的系统进行交互，从而降低系统的复杂性。

角色

• 外观类（Facade）：提供一个简单的接口，封装了复杂的子系统。
• 子系统类（Subsystem）：实现具体的功能，通常由多个类组成。

优点

• 简化接口：通过提供统一的接口，简化了子系统的使用。
• 降低耦合：客户端与子系统之间的依赖关系减少，提高了系统的可维护性。
• 提高可读性：外观模式使得代码的结构更加清晰，易于理解。

缺点

• 可能导致功能膨胀：外观类可能会变得过于复杂，承担过多的责任。
• 不符合开放-封闭原则：如果子系统发生变化，可能需要修改外观类的实现。

示例代码

// 子系统类A
class SubsystemA {
    public void operationA() {
        System.out.println("SubsystemA: Operation A");
    }
}

// 子系统类B
class SubsystemB {
    public void operationB() {
        System.out.println("SubsystemB: Operation B");
    }
}

// 子系统类C
class SubsystemC {
    public void operationC() {
        System.out.println("SubsystemC: Operation C");
    }
}

// 外观类
class Facade {
    private SubsystemA subsystemA;
    private SubsystemB subsystemB;
    private SubsystemC subsystemC;

    public Facade() {
        subsystemA = new SubsystemA();
        subsystemB = new SubsystemB();
        subsystemC = new SubsystemC();
    }

    public void simpleOperation() {
        subsystemA.operationA();
        subsystemB.operationB();
        subsystemC.operationC();
    }
}

// 客户端代码
public class Client {
    public static void main(String[] args) {
        Facade facade = new Facade();
        facade.simpleOperation();
    }
}