【软件设计模式——工厂方法和抽象工厂】

工厂方法模式

1. 模式简述

工厂方法模式（Factory Method Pattern）是一种创建型设计模式，它定义了一个用于创建对象的接口，但将实际创建对象的过程延迟到子类中。这样，工厂方法模式允许子类决定实例化哪个具体类。

2. UML类图

@startuml
interface Product {
    + operation(): void
}

class ConcreteProductA {
    + operation(): void
}

class ConcreteProductB {
    + operation(): void
}

abstract class Creator {
    + abstract factoryMethod(): Product
    + anOperation(): void
}

class ConcreteCreatorA {
    + factoryMethod(): Product
}

class ConcreteCreatorB {
    + factoryMethod(): Product
}

Creator <|-- ConcreteCreatorA
Creator <|-- ConcreteCreatorB
Product <|.. ConcreteProductA
Product <|.. ConcreteProductB
@enduml

3. 详细说明

• Product：抽象产品接口，定义了产品的通用操作方法。
• ConcreteProductA、ConcreteProductB：具体产品类，实现了抽象产品接口，是工厂方法模式所创建的目标产品。
• Creator：抽象创建者，声明了一个工厂方法用于返回一个产品对象，并可以提供一个默认的实现，通常会包含一些公共的业务逻辑。
• ConcreteCreatorA、ConcreteCreatorB：具体创建者，实现了工厂方法，负责实际创建具体产品对象。

4. Java代码示例

// 抽象产品接口
public interface Product {
    void operation();
}

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

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

// 抽象创建者
public abstract class Creator {
    public abstract Product factoryMethod();

    public void anOperation() {
        // 公共的业务逻辑
        System.out.println("anOperation");
        // 使用工厂方法创建产品
        Product product = factoryMethod();
        // 调用产品的操作方法
        product.operation();
    }
}

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

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

// 客户端代码
public class Client {
    public static void main(String[] args) {
        Creator creatorA = new ConcreteCreatorA();
        creatorA.anOperation();  // 输出：anOperation  ConcreteProductA operation

        Creator creatorB = new ConcreteCreatorB();
        creatorB.anOperation();  // 输出：anOperation  ConcreteProductB operation
    }
}

以上是一个简单的工厂方法模式的示例。通过抽象创建者和具体创建者来实现产品的创建，客户端只需要与抽象接口进行交互，而不需要直接依赖于具体产品类。通过具体创建者的实现来决定创建哪种具体产品对象。

抽象工厂模式

1. 模式简述

抽象工厂模式（Abstract Factory Pattern）是一种创建型设计模式，它提供了一个创建一系列相关或相互依赖对象的接口，而无需指定具体的类。抽象工厂模式允许客户端使用抽象接口来创建一组相关的产品，而无需关心具体的实现。

2. UML类图

@startuml
interface AbstractProductA {
    + operation(): void
}

interface AbstractProductB {
    + operation(): void
}

class ConcreteProductA1 {
    + operation(): void
}

class ConcreteProductA2 {
    + operation(): void
}

class ConcreteProductB1 {
    + operation(): void
}

class ConcreteProductB2 {
    + operation(): void
}

interface AbstractFactory {
    + createProductA(): AbstractProductA
    + createProductB(): AbstractProductB
}

class ConcreteFactory1 {
    + createProductA(): AbstractProductA
    + createProductB(): AbstractProductB
}

class ConcreteFactory2 {
    + createProductA(): AbstractProductA
    + createProductB(): AbstractProductB
}

AbstractFactory <|.. ConcreteFactory1
AbstractFactory <|.. ConcreteFactory2
AbstractProductA <|.. ConcreteProductA1
AbstractProductA <|.. ConcreteProductA2
AbstractProductB <|.. ConcreteProductB1
AbstractProductB <|.. ConcreteProductB2
@enduml

3. 详细说明

• AbstractProductA、AbstractProductB：抽象产品接口，定义了一系列相关产品的通用操作方法。
• ConcreteProductA1、ConcreteProductA2、ConcreteProductB1、ConcreteProductB2：具体产品类，实现了抽象产品接口，属于某个产品族的产品实现。
• AbstractFactory：抽象工厂接口，声明了一组用于创建产品的工厂方法。
• ConcreteFactory1、ConcreteFactory2：具体工厂类，实现了抽象工厂接口，负责创建某个产品族的具体产品。

4. Java代码示例

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

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

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

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

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

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

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

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

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

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

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

// 客户端代码
public class Client {
    public static void main(String[] args) {
        // 创建具体工厂1
        AbstractFactory factory1 = new ConcreteFactory1();
        // 使用工厂1创建产品A、B
        AbstractProductA productA1 = factory1.createProductA();
        AbstractProductB productB1 = factory1.createProductB();
        productA1.operation();  // 输出：ConcreteProductA1 operation
        productB1.operation();  // 输出：ConcreteProductB1 operation

        // 创建具体工厂2
        AbstractFactory factory2 = new ConcreteFactory2();
        // 使用工厂2创建产品A、B
        AbstractProductA productA2 = factory2.createProductA();
        AbstractProductB productB2 = factory2.createProductB();
        productA2.operation();  // 输出：ConcreteProductA2 operation
        productB2.operation();  // 输出：ConcreteProductB2 operation
    }
}

以上是一个简单的抽象工厂模式的示例。通过抽象工厂和具体工厂来创建一系列相关的产品，同时客户端只需要与抽象接口进行交互，而不需要关心具体的产品类。抽象工厂模式允许在运行时切换具体工厂，从而实现不同产品族的替换。