Java 之工厂方法和抽象工厂模式（Abstract Factory）

1. 概念

    工厂方法：一抽象产品类派生出多个具体产品类；一抽象工厂类派生出多个具体工厂类；每个具体工厂类只能创建一个具体产品类的实例。

    即定义一个创建对象的接口（即抽象工厂类），让其子类（具体工厂类）决定实例化哪一个类（具体产品类）。“一对一”的关系。

 

    抽象工厂：多个抽象产品类，派生出多个具体产品类；一个抽象工厂类，派生出多个具体工厂类；每个具体工厂类可创建多个具体产品类的实例。

    即提供一个创建一系列相关或相互依赖对象的接口，而无需指定他们的具体的类。“一对多”的关系。

2. UML

 工厂方法：

 

 

抽象工厂：

3. 代码

工厂方法：

 

public interface Product{       }public interface Creator{       public Product factory();}public class ConcreteProduct1 implements Product{       public ConcreteProduct1()       {              System.out.println("ConcreteProduct1被创建");       }}public class ConcreteProduct2 implements Product{       public ConcreteProduct2()       {              System.out.println("ConcreteProduct2被创建");       } }public class ConcreteCreator1 implements Creator{       public Product factory()       {              return new ConcreteProduct1();       }}public class ConcreteCreator2 implements Creator{       public Product factory()       {              return new ConcreteProduct2();       }} public class Client{       private static Creator creator1, creator2;       private static Product prod1, prod2;       public static void main(String[] args)       {              creator1 = new ConcreteCreator1();              prod1 = creator1.factory();              System.out.println("----------------------------");              creator2 = new ConcreteCreator2();              prod2 = creator2.factory();       }}

抽象工厂：

 

//定义不同的产品之间的一定具备的标准，用interface实现 //其中的method()方法可看作提取出不同产品的共性，如手机都有类似的功能 interface IProductA{   public void method(); } interface IProductB{   public void method(); } //实现了产品标准实现的一系列具体产品 //由于已经设计好A1由厂商1生产，故以下输出代码有“厂商x” class ProductA1 implements IProductA{   public void method() {     System.out.println("厂商1    生产ProductA1 ...");   } } class ProductA2 implements IProductA{   public void method() {     System.out.println("厂商2    生产ProductA2 ...");   } } class ProductB1 implements IProductB{   public void method() {     System.out.println("厂商1    生产ProductB1 ...");   } } class ProductB2 implements IProductB{   public void method() {     System.out.println("厂商2    生产ProductB2 ...");   } } //每一种牌子的产品生产工厂，即不同的厂商负责自己牌子产品的生产 abstract class Factory1{   abstract IProductA getProductA1();   abstract IProductB getProductB1(); } abstract class Factory2{   abstract IProductA getProductA2();   abstract IProductB getProductB2(); } //具体的工厂用来生产相关的产品 class ConcreteFactory1 extends Factory1{   public IProductA getProductA1() {     return new ProductA1();   }   public IProductB getProductB1() {     return new ProductB1();   } } class ConcreteFactoryB extends Factory2{   public IProductA getProductA2() {     return new ProductA2();   }   public IProductB getProductB2() {     return new ProductB2();   } } //测试类 public class Client {   public static void main(String[] args) {     //厂商1负责生产产品A1、B1     Factory1 factory1 = new ConcreteFactory1();     IProductA productA1 = factory1.getProductA1();     IProductB productB1 = factory1.getProductB1();          productA1.method();     productB1.method();          //厂商2负责生产产品A2、B2     Factory2 factory2 = new ConcreteFactoryB();     IProductA productA2 = factory2.getProductA2();     IProductB productB2 = factory2.getProductB2();          productA2.method();     productB2.method();   } }

4. 应用场景

工厂方法：

在以下情况下，适用于工厂方法模式：

(1) 当一个类不知道它所必须创建的对象的类的时候。

(2) 当一个类希望由它的子类来指定它所创建的对象的时候。

(3) 当类将创建对象的职责委托给多个帮助子类中的某一个，并且你希望将哪一个帮助子类是代理者这一信息局部化的时候。

抽象工厂：

(1) 一个系统不应当依赖于产品类实例如何被创建、组合和表达的细节，这对于所有形态的工厂模式都是重要的。

(2) 这个系统有多于一个的产品族，而系统只消费其中某一产品族。

(3) 同属于同一个产品族的产品是在一起使用的，这一约束必须在系统的设计中体现出来。

(4) 系统提供一个产品类的库，所有的产品以同样的接口出现，从而使客户端不依赖于实现。

5、简单工厂

简单工厂(StaticFactory Method)

简单工厂模式是由一个工厂对象决定创建出哪一种产品类的实例。简单工厂模式是工厂模式家族中最简单实用的模式，可以理解为是不同工厂模式的一个特殊实现。

Output，接口

publicinterface Output

{

    //接口里定义的属性只能是常量

    intMAX_CACHE_LINE = 50;

    //接口里定义的只能是public的抽象实例方法

    void out();

    voidgetData(String msg);

}

Printer，Output的一个实现

//让Printer类实现Output

publicclassPrinterimplements Output

{

    private String[]printData =new String[MAX_CACHE_LINE];

    //用以记录当前需打印的作业数

    privateintdataNum = 0;

    publicvoid out()

    {

       //只要还有作业，继续打印

       while(dataNum > 0)

       {

           System.out.println("打印机打印：" + printData[0]);

           //把作业队列整体前移一位，并将剩下的作业数减1

           System.arraycopy(printData , 1,printData, 0, --dataNum);

       }

    }

    publicvoid getData(String msg)

    {

       if (dataNum >=MAX_CACHE_LINE)

       {

           System.out.println("输出队列已满，添加失败");

       }

       else

       {

           //把打印数据添加到队列里，已保存数据的数量加1。

           printData[dataNum++] = msg;

       }

    }

}

BetterPrinter，Output的一个实现

publicclass BetterPrinterimplements Output

{

    private String[]printData =new String[MAX_CACHE_LINE * 2];

    //用以记录当前需打印的作业数

    privateintdataNum = 0;

    publicvoid out()

    {

       //只要还有作业，继续打印

       while(dataNum > 0)

       {

           System.out.println("高速打印机正在打印：" + printData[0]);

           //把作业队列整体前移一位，并将剩下的作业数减1

           System.arraycopy(printData , 1,printData, 0, --dataNum);

       }

    }

    publicvoid getData(String msg)

    {

       if (dataNum >=MAX_CACHE_LINE * 2)

       {

           System.out.println("输出队列已满，添加失败");

       }

       else

       {

           //把打印数据添加到队列里，已保存数据的数量加1。

           printData[dataNum++] = msg;

       }

    }

}

OutputFactory，简单工厂类

    public Output getPrinterOutput(String type) {

       if (type.equalsIgnoreCase("better")) {

           returnnew BetterPrinter();

       } else {

           returnnew Printer();

       }

    }

Computer

publicclass Computer

{

    private Outputout;

 

    public Computer(Output out)

    {

       this.out = out;

    }

    //定义一个模拟获取字符串输入的方法

    publicvoid keyIn(String msg)

    {

       out.getData(msg);

    }

    //定义一个模拟打印的方法

    publicvoid print()

    {

       out.out();

    }

    publicstaticvoid main(String[] args)

    {

       //创建OutputFactory

       OutputFactory of = new OutputFactory();

       //将Output对象传入，创建Computer对象

       Computer c = new Computer(of.getPrinterOutput("normal"));

       c.keyIn("建筑永恒之道");

       c.keyIn("建筑模式语言");

       c.print();

      

 

       c = new Computer(of.getPrinterOutput("better"));

       c.keyIn("建筑永恒之道");

       c.keyIn("建筑模式语言");

       c.print();

    }

 

使用简单工厂模式的优势：让对象的调用者和对象创建过程分离，当对象调用者需要对象时，直接向工厂请求即可。从而避免了对象的调用者与对象的实现类以硬编码方式耦合，以提高系统的可维护性、可扩展性。工厂模式也有一个小小的缺陷：当产品修改时，工厂类也要做相应的修改。