设计模式之抽象工厂模式

简介

抽象工厂模式（Abstract Factory Pattern）是围绕一个超级工厂创建其他工厂。该超级工厂又称为其他工厂的工厂。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。
在抽象工厂模式中，接口是负责创建一个相关对象的工厂，不需要显式指定它们的类。每个生成的工厂都能按照工厂模式提供对象。

优点：当一个产品族中的多个对象被设计成一起工作时，它能保证客户端始终只使用同一个产品族中的对象。
缺点：产品族扩展非常困难，要增加一个系列的某一产品，既要在抽象的 Creator 里加代码，又要在具体的里面加代码。

通用类图

例如：有两个不同的产品，每个产品都可能有不同的工厂生产实现，每个工厂的实现方法不同；而且每个厂家生产的产品的等级可能不同，比如一号生产者生产的产品为2号等级，二号生产者生产的产的等级为二号。画出类图：

Java实现

创建抽象产品A和B

  public abstract class AbstractProductA {
        public abstract void A();
    }

    public abstract class AbstractProductB {
        public abstract void B();
    }

产品A的实现类

    public class AbstractProductA1 extends AbstractProductA{
        @Override
        public void A() {
            System.out.println("产品A1的实现方法");
        }
    }

    public class AbstractProductA2 extends AbstractProductA{
        @Override
        public void A() {
            System.out.println("产品A2的实现方法");
        }
    }

产品B的实现类

   public class AbstractProductB1 extends AbstractProductB{
        @Override
        public void B() {
            System.out.println("产品B1的实现方法");
        }
    }

public class AbstractProductB2 extends AbstractProductB{
        @Override
        public void B() {
            System.out.println("产品B2的实现方法");
        }
    }

创建抽象工厂类

public abstract class AbstractCreator {
        public abstract AbstractProductA CreateA();
        public abstract AbstractProductB CreateB();
    }

创建两个产品不同的等级的实现类

    public class Creator1 extends AbstractCreator {
        @Override
        public AbstractProductA CreateA() {
            return new AbstractProductA1();
        }

        @Override
        public AbstractProductB CreateB() {
            return new AbstractProductB1();
        }
    }

public class Creator2 extends AbstractCreator {
        @Override
        public AbstractProductA CreateA() {
            return new AbstractProductA2();
        }

        @Override
        public AbstractProductB CreateB() {
            return new AbstractProductB2();
        }
    }

场景类

    public class Client {
        public static  void main(String[] args){
            //先定义两个工厂
            AbstractCreator creator1 = new Creator1();
            AbstractCreator creator2 = new Creator2();
            //产生A1对象
            AbstractProductA abstractProductA1 = creator1.CreateA();
            abstractProductA1.A();
            //产生A2对象
            AbstractProductA abstractProductA2 = creator2.CreateA();
            abstractProductA2.A();
            //产生B1对象
            AbstractProductB abstractProductB1 = creator1.CreateB();
            abstractProductB1.B();
            //产生B2对象
            AbstractProductB abstractProductB2 = creator2.CreateB();
            abstractProductB2.B();
        }
    }