Java设计模式之工厂模式的三种实现方式对比

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

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

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

// 简单工厂
class SimpleProductFactory {
    public static Product createProduct(String type) {
        if ("A".equalsIgnoreCase(type)) {
            return new ConcreteProductA();
        } else if ("B".equalsIgnoreCase(type)) {
            return new ConcreteProductB();
        } else {
            throw new IllegalArgumentException("未知产品类型: " + type);
        }
    }
}

// 客户端使用
public class Client {
    public static void main(String[] args) {
        Product productA = SimpleProductFactory.createProduct("A");
        productA.use(); // 输出: 使用产品A

        Product productB = SimpleProductFactory.createProduct("B");
        productB.use(); // 输出: 使用产品B
    }
}

// 产品接口 (同上)
// interface Product { void use(); }
// class ConcreteProductA implements Product { ... }
// class ConcreteProductB implements Product { ... }

// 抽象工厂接口
interface ProductFactory {
    Product createProduct();
}

// 具体产品A的工厂
class ConcreteProductAFactory implements ProductFactory {
    @Override
    public Product createProduct() {
        return new ConcreteProductA();
    }
}

// 具体产品B的工厂
class ConcreteProductBFactory implements ProductFactory {
    @Override
    public Product createProduct() {
        return new ConcreteProductB();
    }
}

// 客户端使用
public class Client {
    public static void main(String[] args) {
        ProductFactory factoryA = new ConcreteProductAFactory();
        Product productA = factoryA.createProduct();
        productA.use(); // 输出: 使用产品A

        ProductFactory factoryB = new ConcreteProductBFactory();
        Product productB = factoryB.createProduct();
        productB.use(); // 输出: 使用产品B
    }
}

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

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

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

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

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

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

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

// 具体工厂1，生产产品A1和B1
class ConcreteFactory1 implements AbstractFactory {
    @Override
    public AbstractProductA createProductA() {
        return new ConcreteProductA1();
    }

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

// 具体工厂2，生产产品A2和B2
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) {
        AbstractFactory factory1 = new ConcreteFactory1();
        AbstractProductA productA1 = factory1.createProductA();
        AbstractProductB productB1 = factory1.createProductB();
        productA1.showA(); // 输出: 这是产品A1
        productB1.showB(); // 输出: 这是产品B1

        AbstractFactory factory2 = new ConcreteFactory2();
        AbstractProductA productA2 = factory2.createProductA();
        AbstractProductB productB2 = factory2.createProductB();
        productA2.showA(); // 输出: 这是产品A2
        productB2.showB(); // 输出: 这是产品B2
    }
}