设计模式之抽象工厂模式

简介

抽象工厂模式（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();        }    }