設計模式2——Factory設計模式

Factory工廠設計模式爲建立對象提供了一種抽象，而對使用者屏蔽了對象建立的具體細節過程，工廠模式有三種：簡單工廠模式，抽象工廠模式和工廠方法模式。

1. 簡單工廠模式：

又叫靜態工廠模式，簡單工廠只包括一個抽象產品類（該類能夠是接口，也能夠是具體的類），全部須要的產品類都是該抽象產品類的子類。簡單工廠模式中工廠爲具體產品工廠，產品爲抽象產品，由工廠實例建立產品實例：

一個生成圓形和矩形的圖形工廠，例子以下：

//圖形接口
interface Shape(){
    public void draw();
}

//圓形
class Circle implements Shape{
    public void draw(){
        System.out.println(「Circle is drawing」);
    }
}

//矩形
class Rectangle implements Shape{
    public void draw(){
        System.out.println(「Rectangle is drawing」);
    }
}

//圖形工廠
class ShapeFactory{
    public static Shape createShape(String name) throws InstantiationException, 
                                      IllegalAccessException, 
                                      ClassNotFoundException {
        //使用java的反射機制來產生對象實例
        return (Shape)class.forName(name).newInstance();
    }
} 

public class ShapeDemo{
    public static void draw(Shape shape){
        shape.draw();
    }
    public static void main(String[] args){
        draw(ShapeFactory.createShape(「Circle」));
        draw(ShapeFactory.createShape(「Rectangle」));
    }
}

圖形工廠負責具體圖形的對象實例化工做，圖形使用者使用時不須要關心圖形對象的具體產生過程。

2. 抽象工廠模式：

抽象工廠模式中能夠包括多個抽象產品類，每一個抽象產品類能夠產生出多個具體產品類，一個抽象工廠用於定義所需產品的組合形式，抽象工廠派生具體工廠類，這些具體工廠類就是簡單工廠模式中的工廠類，具體工廠類負責具體產品實例的建立：

以軟件皮膚爲例，軟件皮膚由樣式style和顏色color組成，實現一套IOS風格的軟件皮膚，一套Android風格的軟件皮膚，經過抽象工廠實現軟件皮膚自由切換例子以下：

//軟件皮膚類 
class Skin{
    private SkinFactory skinFactory;
    public Skin(SkinFactory factory){
        setSkinFactory(factory);
    }
    public void setSkinFactory(SkinFactory factory){
        this.skinFactory = factory
    }
    public void showSkin(){
        System.out.println(「Style=」 + factory.getStyle().showStyle() + 「, color=」 + factory.getColor().showColor());
    }
}

//軟件Style
interface Style(){
    public void showStyle();
}

//IOS style
class IOSStyle implements Style{
    public void showStyle(){
        System.out.println(「This is IOS style」);
    }
}

//Android style
class AndroidStyle implements Style{
    public void showStyle(){
        System.out.println(「This is Android style」);
    }
}

//軟件Color
interface Color(){
    public void showColor();
}

//IOS color
class IOSColor implements Color{
    public void showColor(){
        System.out.println(「This is IOS color」);
    }
}

//Android color
class AndroidColor implements Color{
    public void showColor(){
        System.out.println(「This is Android color」);
    }
}

//抽象皮膚工廠
interface SkinFactory{
    public Style getStyle();
    public Color getColor();
}

//IOS皮膚工廠
class IOSSkinFactory implements SkinFactory{
    public Style getStyle(){
        return new IOSStyle();
    }
    public Color getColor(){
        return new IOSColor();
    }
}

//Android皮膚工廠
class AndroidSkinFactory implements SkinFactory{
    public Style getStyle(){
        return new AndroidStyle();
    }
    public Color getColor(){
        return new AndroidColor();
    }
}

public class SkinDemo{
    public static void main(String[] args){
        //顯示一套IOS皮膚
        Skin skin = new Skin(new IOSSkinFactory());
        skin.showSkin();
        //換一套Android的皮膚
        skin.setSkinFactory(new AndroidSkinFactory());
        skin.showSkin();
    }
}

抽象工廠指定了產品組合形式，具體的工廠產生具體的產品，抽象工廠適用於多個產品相互組合的狀況。

3. 工廠方法模式：

工廠方法中也只包含一個抽象產品類，抽象產品類能夠派生出多個具體產品類。工廠方法定義一個用於建立產品的接口，讓子類決定實例化哪個類，使得類的實例化延遲到子類。

工廠方法模式例子以下：

//汽車接口
interface ICar{
    public void run();
}

//奔馳車
class BenzCar implements ICar{
    public void run(){
        System.out.println(「Benz car run」);
    }
}

//寶馬車
class BMWCar implements ICar{
    public void run(){
        System.out.println(「BMW car run」);
    }
}

//抽象汽車工廠
abstract class CarFactory{
    public abstract ICar createCar();
}

//奔馳車工廠
class BenzCarFactory extends CarFactory{
    public ICar createCar(){
        return new BenzCar();
    }
}

//寶馬車工廠
class BMWCarFactory extends CarFactory{
    public ICar createCar(){
        return new BMWCar();
    }
}

public class FactoryMethodDemo{
    public static void main(String[] args){
        CarFactory factory = new BenzCarFactory();
        ICar car = factory.createCar();
        car.run();
        factory = new BMWCarFactory();
        car = factory.createCar();
        car.run();
    }
}

工廠模式中，重要的是工廠類，而不是產品類。產品類能夠是多種形式，多層繼承或者是單個類都是能夠的。但要明確的，工廠模式的接口只會返回一種類型的實例，這是在設計產品類的時候須要注意的，最好是有父類或者共同實現的接口。

使用工廠模式，返回的實例必定是工廠建立的，而不是從其餘對象中獲取的。工廠模式返回的實例能夠不是新建立的，返回由工廠建立好的實例也是能夠的。

三種工廠模式的區別：

簡單工廠 ： 用來生產同一等級結構中的任意產品，對於增長新的產品，無能爲力。

抽象工廠 ：用來生產不一樣產品族(由不一樣產品組合成的一套產品)的所有產品，對於增長新的產品，無能爲力；支持增長產品族。

工廠方法 ：用來生產同一等級結構中的固定產品，支持增長任意產品。