java设计模式--抽象工厂模式

抽象工厂模式：提供一个创建一系列相关或相互依赖对象的接口，而无需指定它们具体的类。

我们先回忆一下简单工厂模式的情形，有一个创建产品的接口，需要创建不同的产品时我们就需要创建多个工厂类。

//工厂接口
public interface IFactory {
　　 //创建产品
    Product createProduct();
}

//具体工厂
public class CarFactory implements IFactory {
    @Override
    public Product createProduct() {
　　　　　//创建产品实例对象
        return new Car();
    }
}

public class BicycleFactory implements IFactory {
    @Override
    public Product createProduct() {
        return new Bicycle();
    }
}

public class Customer {
    public static void main(String[] args) {
        IFactory carFactory = new CarFactory();
        Product car = carFactory.createProduct();
        car.run();

        IFactory bicycleFactory = new BicycleFactory();
        Product bicycle = bicycleFactory.createProduct();
        bicycle.run();
    }
}

但是如果是这么一种情形呢，我们要生产的产品是一个类别，并且不再是一个，而是多个时，这种product接口就不符合情况了

我们看一个例子，假设需要不同的方法创建一系列产品

产品接口A以及实现。

public interface  ProductA {
    void Show();
}

public class ProductA1 implements ProductA {
    @Override
    public void Show() {
        System.out.println("使用工厂1生产出了产品A");
    }
}

public class ProductA2 implements ProductA {
    @Override
    public void Show() {
        System.out.println("使用工厂2生产出了产品A");
    }
}

 

　　产品接口B以及实现。

public interface ProductB {
    void Show();
}

public class ProductB1 implements ProductB {
    @Override
    public void Show() {
        System.out.println("使用工厂1生产出了产品B");
    }
}

public class ProductB2 implements ProductB {
    @Override
    public void Show() {
        System.out.println("使用工厂2生产出了产品B");
    }
}

 

　　工厂接口以及实现，两个具体工厂分别对应两种生产该产品的方法。

public interface Factory {
    ProductA ManufactureA();

    ProductB ManufactureB();
}

public class ConcreateFactory1 implements Factory {
    @Override
    public ProductA ManufactureA() {
        return new ProductA1();
    }

    @Override
    public ProductB ManufactureB() {
        return new ProductB1();
    }
}

public class ConcreateFactory2 implements Factory {
    @Override
    public ProductA ManufactureA() {
        return new ProductA2();
    }

    @Override
    public ProductB ManufactureB() {
        return new ProductB2();
    }
}

　　在实际应用中，我们可能只需要某一种方法去创建产品A，B，但是当我们想要切换产品的生产方法时，就只需要将new ConcreateFactory1()替换为new ConcreateFactory2()就可以了，此时无论是哪一个工厂的方法，他生产某一个产品调用的都是同一个方法，例如factory.ManufactureA();但是如果在工厂方法模式中，我们新增一个产品的制作方法，就需要新增工厂，在客户端内去调用不同工厂的createProduct()这样就增加了系统的复杂性。

public class Test {
    public static void main(String[] args){
        Factory factory = new ConcreateFactory1();
        ProductA productA = factory.ManufactureA();
        ProductB productB = factory.ManufactureB();
        productA.Show();
        productB.Show();

        Factory factory2 = new ConcreateFactory2();
        ProductA productA2 = factory2.ManufactureA();
        ProductB productB2 = factory2.ManufactureB();
        productA2.Show();
        productB2.Show();
    }
}