深入剖析Java工厂模式让你的代码更灵活

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

//具体产品类A
class ConcreteProductA implements Product {
    public void show() {
        System.out.println("This is product A");
    }
}

//具体产品类B
class ConcreteProductB implements Product {
    public void show() {
        System.out.println("This is product B");
    }
}

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

//客户端
public class Client {
    public static void main(String[] args) {
        Product productA = SimpleFactory.createProduct("A");
        productA.show();

        Product productB = SimpleFactory.createProduct("B");
        productB.show();
    }
}

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

//具体产品类A
class ConcreteProductA implements Product {
    public void show() {
        System.out.println("This is product A");
    }
}

//具体产品类B
class ConcreteProductB implements Product {
    public void show() {
        System.out.println("This is product B");
    }
}

//抽象工厂类
interface Factory {
    Product createProduct();
}

//具体工厂类A
class ConcreteFactoryA implements Factory {
    public Product createProduct() {
        return new ConcreteProductA();
    }
}

//具体工厂类B
class ConcreteFactoryB implements Factory {
    public Product createProduct() {
        return new ConcreteProductB();
    }
}

//客户端
public class Client {
    public static void main(String[] args) {
        Factory factoryA = new ConcreteFactoryA();
        Product productA = factoryA.createProduct();
        productA.show();

        Factory factoryB = new ConcreteFactoryB();
        Product productB = factoryB.createProduct();
        productB.show();
    }
}

//抽象产品类1
interface Product1 {
    void show();
}

//具体产品类1A
class ConcreteProduct1A implements Product1 {
    public void show() {
        System.out.println("This is product 1A");
    }
}

//具体产品类1B
class ConcreteProduct1B implements Product1 {
    public void show() {
        System.out.println("This is product 1B");
    }
}

//抽象产品类2
interface Product2 {
    void show();
}

//具体产品类2A
class ConcreteProduct2A implements Product2 {
    public void show() {
        System.out.println("This is product 2A");
    }
}

//具体产品类2B
class ConcreteProduct2B implements Product2 {
    public void show() {
        System.out.println("This is product 2B");
    }
}

//抽象工厂类
interface Factory {
    Product1 createProduct1();
    Product2 createProduct2();
}

//具体工厂类A
class ConcreteFactoryA implements Factory {
    public Product1 createProduct1() {
        return new ConcreteProduct1A();
    }

    public Product2 createProduct2() {
        return new ConcreteProduct2A();
    }
}

//具体工厂类B
class ConcreteFactoryB implements Factory {
    public Product1 createProduct1() {
        return new ConcreteProduct1B();
    }

    public Product2 createProduct2() {
        return new ConcreteProduct2B();
    }
}

//客户端
public class Client {
    public static void main(String[] args) {
        Factory factoryA = new ConcreteFactoryA();
        Product1 product1A = factoryA.createProduct1();
        Product2 product2A = factoryA.createProduct2();
        product1A.show();
        product2A.show();

        Factory factoryB = new ConcreteFactoryB();
        Product1 product1B = factoryB.createProduct1();
        Product2 product2B = factoryB.createProduct2();
        product1B.show();
        product2B.show();
    }
}