Java设计模式编程中的工厂方法模式和抽象工厂模式

工厂方法模式

动机
创建一个对象往往需要复杂的过程，所以不适合包含在一个复合工厂中，当有新的产品时，需要修改这个复合的工厂，不利于扩展。

而且，有些对象的创建可以需要用到复合工厂访问不到的信息，所以，定义一个工厂接口，通过实现这个接口来决定实例化那个产品，这就是工厂方法模式，让类的实例化推迟到子类中进行。

目的
1. 定义一个接口，让子类决定实例化哪个产品。
2. 通过通用接口创建对象。

实现

1. 产品接口和具体产品很好理解。
2. 工厂类提供一个工厂方法，返回一个产品对象。但是这个工厂方法是抽象的。
3. 具体工厂类实现工厂方法，完成具体产品的创建。

//几个button类 
class button{/* ...*/} 
class winbutton extends button{/* ...*/} 
class macbutton extends button{/* ...*/} 
  
//它们的工厂类 
interface buttonfactory{ 
  abstract button createbutton(); 
} 
class winbuttonfactory implements buttonfactory{ 
  button createbutton(){ 
    return new winbutton(); 
  } 
} 
class macbuttonfactory implements buttonfactory{ 
  button createbutton(){ 
    return new macbutton(); 
  } 
} 

适用场景
1. 创建对象时有比较多重复的代码时，可以考虑使用工厂方法模式执行这些重复的部分。
2. 创建对象需要访问某些信息，而这些信息不应该包含在工厂类，那么可以让子类来实现对象的创建。
3. 需要集中管理对象的创建，保持程序的一致性时。

抽象工厂模式
定义
抽象工厂模式提供了一种方式，可以将一组具有同一主题的单独的工厂封装起来。在正常使用中，客户端程序需要创建抽象工厂的具体实现，然后使用抽象工厂作为接口来创建这一主题的具体对象。客户端程序不需要知道（或关心）它从这些内部的工厂方法中获得对象的具体类型，因为客户端程序仅使用这些对象的通用接口。抽象工厂模式将一组对象的实现细节与他们的一般使用分离开来。

“工厂”是创建产品（对象）的地方，其目的是将产品的创建与产品的使用分离。抽象工厂模式的目的，是将若干抽象产品的接口与不同主题产品的具体实现分离开。这样就能在增加新的具体工厂的时候，不用修改引用抽象工厂的客户端代码。

使用抽象工厂模式，能够在具体工厂变化的时候，不用修改使用工厂的客户端代码，甚至是在运行时。然而，使用这种模式或者相似的设计模式，可能给编写代码带来不必要的复杂性和额外的工作。正确使用设计模式能够抵消这样的“额外工作”。

实现

1. abstractfactory - 定义创建抽象产品的接口方法。
2. concretefactory - 实现方法创建具体的产品。
3. abstractproduct - 声明不同类型的产品的接口。
4. product - 定义concretefactory对应的具体产品，实现abstractproduct接口。
5. client - 使用abstractfactory和abstractproduct类。

abstract class abstractproducta{ 
  public abstract void operationa1(); 
  public abstract void operationa2(); 
} 
 
class producta1 extends abstractproducta{ 
  producta1(string arg){ 
    system.out.println("hello "+arg); 
  } // implement the code here 
  public void operationa1() { }; 
  public void operationa2() { }; 
} 
 
class producta2 extends abstractproducta{ 
  producta2(string arg){ 
    system.out.println("hello "+arg); 
  } // implement the code here 
  public void operationa1() { }; 
  public void operationa2() { }; 
} 
 
abstract class abstractproductb{ 
  //public abstract void operationb1(); 
  //public abstract void operationb2(); 
} 
 
class productb1 extends abstractproductb{ 
  productb1(string arg){ 
    system.out.println("hello "+arg); 
  } // implement the code here 
} 
 
class productb2 extends abstractproductb{ 
  productb2(string arg){ 
    system.out.println("hello "+arg); 
  } // implement the code here 
} 
 
abstract class abstractfactory{ 
  abstract abstractproducta createproducta(); 
  abstract abstractproductb createproductb(); 
} 
 
class concretefactory1 extends abstractfactory{ 
  abstractproducta createproducta(){ 
    return new producta1("producta1"); 
  } 
  abstractproductb createproductb(){ 
    return new productb1("productb1"); 
  } 
} 
 
class concretefactory2 extends abstractfactory{ 
  abstractproducta createproducta(){ 
    return new producta2("producta2"); 
  } 
  abstractproductb createproductb(){ 
    return new productb2("productb2"); 
  } 
} 
 
//factory creator - an indirect way of instantiating the factories 
class factorymaker{ 
  private static abstractfactory pf=null; 
  static abstractfactory getfactory(string choice){ 
    if(choice.equals("a")){ 
      pf=new concretefactory1(); 
    }else if(choice.equals("b")){ 
            pf=new concretefactory2(); 
        } 
        return pf; 
  } 
} 
 
// client 
public class client{ 
  public static void main(string args[]){ 
    abstractfactory pf=factorymaker.getfactory("a"); 
    abstractproducta product=pf.createproducta(); 
    //more function calls on product 
  } 
} 

factorymaker类使用的是简单工厂模式，而具体工厂的实现用的是工厂方法模式。

适用场景
1. 一个系统要独立于它的产品的创建、组合和表示时。
2. 一个系统要由多个产品系列中的一个来配置时。
3. 需要强调一系列相关的产品对象的设计以便进行联合使用时。
4. 提供一个产品类库，而只想显示它们的接口而不是实现时。

优点
1. 具体产品从客户代码中被分离出来
2. 容易改变产品的系列
3. 将一个系列的产品族统一到一起创建

缺点
1. 在产品族中扩展新的产品是很困难的，它需要修改抽象工厂的接口和具体工厂。