結合實例分析簡單工廠模式&工廠方法模式&抽象工廠模式的區別

　　之前寫過一篇關於工廠模式（Factory Pattern）的隨筆，里面分析了簡單工廠模式，但對於工廠方法和抽象工廠的分析較為簡略。這里重新分析分析三者的區別，工廠模式是java設計模式中比較簡單的一個設計模式，但很多地方都用到了工廠模式，（如解析xml中，jdbc連接數據庫等）利用好工廠模式對程序的設計很有用處。工廠模式在一些設計模式的書中分為簡單工廠模式，工廠方法模式和抽象工廠模式三類。也有把工廠方法模式划分到抽象工廠模式的，認為工廠方法是抽象工廠模式的特例的一種，就是只有一個要實現的產品接口。下面結合例子分析三者的區別。

　　首先是簡單工廠模式，這里以工廠生產產品為例。

產品類的共同接口

package factory;
/**
 * 
 * @author CIACs
 *
 */
public interface Product {
    //聲明類所需繼承的共同接口，也可以是抽象類
}

產品類A

package factory;
/**
 * 
 * @author CIACs
 *
 */
public class ProductA implements Product {
    public ProductA() {
        System.out.println("ProductA");
    }
}

產品類B

package factory;
/**
 * 
 * @author CIACs
 *
 */
public class ProductB implements Product {
    public ProductB() {
        System.out.println("ProductB");
    }
}

工廠類

package factory;
/**
 * 
 * @author CIACs
 *
 */
public class Factory {
    //可以在工廠類中添加任何你所需要的邏輯
    public static Product create(String str)
    {
        //生成ProductA
        if(str.equalsIgnoreCase("ProductA"))
        {
            return new ProductA();
        }
        else
            //生成ProductB
            if(str.equalsIgnoreCase("ProductB"))
            {
                return new ProductB();
            }
        return null;
    }

}

客戶端

package factory;
/**
 * 
 * @author CIACs
 *
 */
public class Client {
    public static void main(String[] args) {
        //調用Factory的靜態方法生成所要的類
        Factory.create("productA");
        Factory.create("ProductB");
    }
}

控制台輸出結果：

　　簡單工廠模式實現了生成產品類的代碼跟客戶端代碼分離，在工廠類中你可以添加所需的生成產品的邏輯代碼，但是問題來了，優秀的java代碼是符合“開放-封閉”原則的，也就是說對擴展開發，對修改關閉，如果你要加一個產品類C，你就要修改工廠類里面的生成產品的代碼，在這里你就要增加if-else判斷。對於這個問題，我們的工廠方法模式就可以解決這個問題。

　　接下來是工廠方法模式

 產品類中增加了ProductC（其他產品類的代碼是可以重用上面的，只要把包名更改了就行）。

package factoryMehtod;
/**
 * 
 * @author CIACs
 *
 */

public class ProductC implements Product {
    public ProductC() {
        System.out.println("productC");
    }
}

聲明工廠接口

package factoryMehtod;
/**
 * 
 * @author CIACs
 *
 */
public interface Factory {
    //聲明產生產品類的方法
    public Product createProduct();
}

產生ProductA的FactoryA

package factoryMehtod;
/**
 * 
 * @author CIACs
 *
 */
public class FactoryA implements Factory {
    //實現工廠類的方法生成產品類A
    public Product createProduct()
    {
        return new ProductA();
    }

}

產生ProductB的FactoryB

package factoryMehtod;
/**
 * 
 * @author CIACs
 *
 */
public class FactoryB implements Factory {
    //實現工廠類的方法生成產品類B
    public Product createProduct()
    {
        return new ProductB();
    }
}

產生ProductC的FactoryC

package factoryMehtod;
/**
 * 
 * @author CIACs
 *
 */
public class FactoryC implements Factory {
    //實現工廠類的方法生成產品類C
    public Product createProduct()
    {
        return new ProductC();
    }
}

客戶端

package factoryMehtod;
/**
 * 
 * @author CIACs
 *
 */
public class Client {
    public static void main(String[] args) {
        Factory factory;
        factory = new FactoryA();
        factory.createProduct();
        factory = new FactoryB();
        factory.createProduct();
        factory = new FactoryC();
        factory.createProduct();
    }
}

控制台輸出結果：

 　　工廠方法模式中我們把生成產品類的時間延遲，就是通過對應的工廠類來生成對應的產品類，在這里我們就可以實現“開發-封閉”原則，無論加多少產品類，我們都不用修改原來類中的代碼，而是通過增加工廠類來實現。但是這還是有缺點的，如果產品類過多，我們就要生成很多的工廠類。假如我們要實現的產品接口不止一個，也就是有多個產品接口，不同產品接口有對應的產品族。什么是產品族呢？簡單的理解就是，不同牌子產的車里面會有跑車類型，家庭類型，商用類型等的車，不同牌子的車的跑車類型的車可以組成一個產品族。對於這種情況我們可以采用抽象工廠模式。

　　 最后是抽象工廠模式，在這里我們為不同產品附加上對應的禮物，就是說ProductA中會有GiftA。

增加的Gift接口

package abstractFactory;
/**
 * 
 * @author CIACs
 *
 */
public interface Gift {
    //聲明產品贈品的接口，當然也可以是抽象類，同樣為了簡單就不聲明方法了
}

GiftA類

package abstractFactory;
/**
 * 
 * @author CIACs
 *
 */
public class GiftA implements Gift {
    public GiftA()
    {
        System.out.println("GiftA");
    }
}

GiftB類

package abstractFactory;
/**
 * 
 * @author CIACs
 *
 */
public class GiftB implements Gift {
    public GiftB()
    {
        System.out.println("GiftB");
    }
}

Factory接口

package abstractFactory;
/**
 * 
 * @author CIACs
 *聲明Product類工廠和Gift類工廠的工同工廠接口
 */
public interface Factory {
    public Product createProduct();
    public Gift createGift();

}

生成ProductA和GiftA的FactoryA

package abstractFactory;
/**
 * 
 * @author CIACs
 *FactoryA可以生成ProductA和GiftA
 */
public class FactoryA implements Factory {
    @Override
    public Product createProduct()
    {
        return new ProductA();
    }
    @Override
    public Gift createGift()
    {
        return new GiftA();
    }
}

生成ProductB和GiftB的FactoryB

package abstractFactory;
/**
 * 
 * @author CIACs
 *FactoryB可以生成ProductB和GiftB
 */
public class FactoryB implements Factory {
    @Override
    public Product createProduct() {
        return new ProductB();
    }
    @Override
    public Gift createGift() {
        return new GiftB();
    }

}

客戶端

package abstractFactory;
/**
 * 
 * @author CIACs
 *
 */
public class Client {
    public static void main(String[] args) {
        Factory factory;
        factory = new FactoryA();
        factory.createProduct();
        factory.createGift();
        factory = new FactoryB();
        factory.createProduct();
        factory.createGift();
    }
}

控制台輸出結果：

　　抽象工廠模式中我們可以定義實現不止一個接口，一個工廠也可以生成不止一個產品類，抽象工廠模式較好的實現了“開放-封閉”原則，是三個模式中較為抽象，並具一般性的模式。我們在使用中要注意使用抽象工廠模式的條件。