设计模式（1）——抽象工厂模式

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

抽象工厂模式用于：

1. 系统需要独立于产品创建、组合和表示时。

2. 系统需要多个产品系列中的一个来配置时。

3. 当要强调一系列相关的产品对象的设计以便进行联合使用时。

3. 当提供一个产品类库，只想显示它们的接口而不是实现时。

举例来说：

1. 中国和美国的电话号码和地址规则不一样，AbstractFactory 可以创建一个电话号码和地址，AbstractProduct定义电话号码和地址的方法，然后由CNConcreteFactory中包含CNConcreteProduct的产品，然后由CNConcreteProduct中的方法处理中国的电话号码和地址。这样，如果添加一个国家，我们只要添加一个Concrete的工厂和产品。

2. 第二个例子就是不同系统用不同的UI风格，比如MAC和WINDOWS的风格不一样，也可以用不同的工厂来创建。

3. 第三个例子就是披萨饼。不同的味道和调料用不同的工厂生产。

UML图

具体的JAVA实现如下：

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
    }
}

UI的例子

按钮 Interface:

public interface Button {     public void paint(); }

Windows button implementation class:

public class WindowsButton implements Button {     @Override     public void paint() {         /** add code to paint windows button **/         System.out.println("painting windows button...");     } }

Mac Button 实现类:

public class MacButton implements Button {     @Override     public void paint() {         /** add code to paint MAC OS button **/         System.out.println("painting MAC OS button...");     } }

Common Button Factory Interface:

public interface ButtonFactory {     public Button createButton(); }

Windows Factory 实现:

public class WindowsFactory implements ButtonFactory {     @Override     public Button createButton() {                   /**          * this method creates a button for windows          * button          */         System.out.println("creating windows button...");         return new WindowsButton();     } }

Mac Button Factory 实现类:

public class MacOsFactory implements ButtonFactory {     @Override     public Button createButton() {         /**          * this method creates a button for MAC OS          * button          */         System.out.println("creating mac os button...");         return new MacButton();     } }

GUI Factory Class:

public class GUIFactory {     private GUIFactory(){         //make private constructor..     }           public static Button createButton(){                   String os = null;         /**          * 根据不同操作系统选择风格。          *          * 本例子，采用硬编码的方式。          */                   os = "windows"; //硬编码的数值，本来应该动态变化                                 if("windows".equalsIgnoreCase(os)){             return new WindowsFactory().createButton();         } else if("mac".equalsIgnoreCase(os)){             return new MacOsFactory().createButton();         }                   return null;     } }

测试:

public class AbstractFactoryTest {     public static void main(String a[]){         Button btn = GUIFactory.createButton();         btn.paint();     } }

输出:

creating windows button... painting windows button...

摘抄自：http://www.oodesign.com/abstract-factory-pattern.html

http://java2novice.com/java-design-patterns/abstract-factory-pattern/