工厂型设计模式对比

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

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

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

// 工厂类
public class SimpleFactory {
    public static Product createProduct(String type) {
        if (type == null) {
            throw new IllegalArgumentException("产品类型不能为空");
        }
        switch (type.toUpperCase()) {
            case "A":
                return new ConcreteProductA();
            case "B":
                return new ConcreteProductB();
            default:
                throw new IllegalArgumentException("未知的产品类型: " + type);
        }
    }
}

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

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

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

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

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

// 工厂接口
public abstract class Creator {
    public abstract Product factoryMethod();
    
    public void someOperation() {
        Product product = factoryMethod();
        product.use();
    }
}

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

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

// 客户端代码
public class Client {
    public static void main(String[] args) {
        Creator creatorA = new ConcreteCreatorA();
        creatorA.someOperation(); // 输出: 使用具体产品A

        Creator creatorB = new ConcreteCreatorB();
        creatorB.someOperation(); // 输出: 使用具体产品B
    }
}

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

// 具体产品类A1
public class ConcreteProductA1 implements AbstractProductA {
    public void doSomethingA() {
        System.out.println("ConcreteProductA1 的操作A");
    }
}

// 具体产品类A2
public class ConcreteProductA2 implements AbstractProductA {
    public void doSomethingA() {
        System.out.println("ConcreteProductA2 的操作A");
    }
}

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

// 具体产品类B1
public class ConcreteProductB1 implements AbstractProductB {
    public void doSomethingB() {
        System.out.println("ConcreteProductB1 的操作B");
    }
}

// 具体产品类B2
public class ConcreteProductB2 implements AbstractProductB {
    public void doSomethingB() {
        System.out.println("ConcreteProductB2 的操作B");
    }
}

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

// 具体工厂类1
public class ConcreteFactory1 implements AbstractFactory {
    public AbstractProductA createProductA() {
        return new ConcreteProductA1();
    }
    
    public AbstractProductB createProductB() {
        return new ConcreteProductB1();
    }
}

// 具体工厂类2
public class ConcreteFactory2 implements AbstractFactory {
    public AbstractProductA createProductA() {
        return new ConcreteProductA2();
    }
    
    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.doSomethingA(); // 输出: ConcreteProductA1 的操作A
        productB1.doSomethingB(); // 输出: ConcreteProductB1 的操作B

        AbstractFactory factory2 = new ConcreteFactory2();
        AbstractProductA productA2 = factory2.createProductA();
        AbstractProductB productB2 = factory2.createProductB();
        productA2.doSomethingA(); // 输出: ConcreteProductA2 的操作A
        productB2.doSomethingB(); // 输出: ConcreteProductB2 的操作B
    }
}