設計模式整理_原廠模式

標籤：

一.簡單原廠模式.

　　通常情況下,在代碼中需要建立一系列對象的時候,如果需要建立新的同類型的對象,就需要對原代碼進行修改,此時就不符合對修改關閉的原則,因此,我們將建立對象於使用對象的代碼分隔開來,在工廠類中建立工廠,然後如果需要新的對象,只需要修改工廠的類即可.

　　

public interface Car /*在這裡定義需要產生的執行個體,針對抽象組件*/{    public void run();}class BenzCar /*執行個體*/ implements Car {    @Override    public void run() {        System.out.println("Benz run.");    }    }class AudiCar /*執行個體*/ implements Car {    @Override    public void run() {        System.out.println("Audi run");    }}

public class CarFactory /*通過工廠產生執行個體*/{    String name;    public Car get(String name) {        if(name.equals("Benz")) {            return new BenzCar();        }        else if(name.equals("Audi")) {            return new AudiCar();        }        return null;    }}

/* * 測試簡單原廠模式. * */public class Test1 {    public static void main(String[] args) {        CarFactory factory=new CarFactory();        //定義工廠        AudiCar audi=(AudiCar) factory.get("Audi"); //產生AudiCar執行個體        BenzCar benz=(BenzCar) factory.get("Benz"); //產生BenzCar執行個體        audi.run();        benz.run();    }}

二.Factory 方法模式.

　　Factory 方法模式定義了一個建立對象的介面,但由子類決定要執行個體化的類是哪一個,Factory 方法讓類把執行個體化延遲到子類.

　　Factory 方法模式需要注意的細節:

　　1.Factory 方法模式將工廠抽象成為介面(建立者類),在編寫建立類是不需要知道實際建立產品的是哪一個,選擇了使用哪個子類工廠就決定了實際建立的產品是什麼.

　　2.對於建立者類如果增加產品或者改變產品的實現,它不會受到任何影響,這實現瞭解耦.

　　3.簡單原廠模式不具備Factory 方法模式的彈性,因為簡單原廠模式不能變更正在建立的產品.

　　Factory 方法模式體現了一個很重要的原則:要依賴抽象,不要依賴具體類.

　　這個原則的具體內容是讓我們在編寫代碼的時候,最好依賴的都是抽象類別,而不依賴具體類,對於高層以及低層模組都應該如此.

　　具體來說,即:變數不可以持有具體的類的引用,如果使用new,就會持有具體類的引用,應當採用工廠來避免這樣的情況發生.不要讓類派生自具體類,應當讓其派生於一個抽象,不要覆蓋基類中已實現的方法,基類已實現的方法應當由所有子類共用.

　　以下是Factory 方法的執行個體,定義了產品介面Car,建立者介面CarFactory,採用具體的子類來產生具體的產品.

public interface Car/*定義產品類*/ {    public void run();}class GoodAudiCar implements Car/*實現具體的產品*/ {    @Override    public void run() {        System.out.println("Good Audi run..zzz");    }    }class BadAudiCar implements Car {    @Override    public void run() {        System.out.println("Bad Audi run...ouch!");    }}

public interface Factory /*定義建立者類,定義一個抽象的Factory 方法,讓子類去實現此方法.*/{public Car produceCar();}class GoodAudiFactory implements Factory /*實現具體的建立者.*/{@Overridepublic Car produceCar() {return new GoodAudiCar();}}class BadAudiFactory implements Factory{@Overridepublic Car produceCar() {return new BadAudiCar();}}

/* *     示範Factory 方法模式. * */public class Test2 {    public static void main(String[] args) {        Factory factory1=new GoodAudiFactory();        Factory factory2=new BadAudiFactory();                Car good=factory1.produceCar();        Car bad= factory2.produceCar();        good.run();        bad.run();    }}

　　類圖如下:

三.抽象原廠模式.

　　抽象原廠模式提供了一個介面,用來建立相關的對象的家族(一系列產品),而不需要明確制定具體類.

　　引用新類型的工廠,也就是所謂的抽象工廠來建立一系列產品,通過抽象工廠所提供的介面,可以建立產品的家族,利用這個介面書寫代碼,可以在不同上下文中,實現各式各樣的工廠,建立出各種類型的產品,因為代碼從實際產品中解耦出來了,所以我們可以替換不同的工廠來取得不同的行為.

　　Factory 方法模式是通過子類來建立具體的對象,負責將客戶從具體類型中,解耦,而抽象原廠模式將一群相關的產品集合起來,提供了一個用於建立一個產品家族的抽象類別型,這個類型的子類定義了產品被產生的方法,要想使用這個方法,必須先執行個體化它,然後將它傳入一些針對抽象類別型所寫的代碼中.

　　下面是Factory 方法模式的執行個體,產品為Engine,Wheel類,抽象工廠Factory定義了產生產品族的方法,而將具體的實現交給其子類來完成,隨後在另一個類中,傳入工廠,擷取產品族.

　　

/* * 定義Wheel產品 * */public interface Wheel {    public void run();}class GoodWheel implements Wheel {    @Override    public void run() {        System.out.println("GoodWheel run.");    }}class BadWheel implements Wheel {    @Override    public void run() {        System.out.println("BadWheel run.");    }    }

/* * 定義Engine產品 * */public interface Engine {    public void start();}class GoodEngine implements Engine{    @Override    public void start() {        System.out.println("GoodEngine start");    }}class BadEngine implements Engine {    @Override    public void start() {        System.out.println("BadEngine start");    }}

//定義抽象工廠來產生產品.public interface Factory {    /*兩個產品*/    public Engine getEngine();    public Wheel getWheel();}class GoodFactory implements Factory {    @Override    public Engine getEngine() {        return new GoodEngine();    }    @Override    public Wheel getWheel() {        return new GoodWheel();    }}class BadFactory implements Factory {    @Override    public Engine getEngine() {        return new BadEngine();    }    @Override    public Wheel getWheel() {        return new BadWheel();    }    }

//擷取產品族public abstract class Car {    Engine en;    Wheel wh;    public abstract void prepareCar();}class BadCar extends Car {    Factory fa;    /*需要傳入一個抽象工廠來擷取產品族*/    public BadCar(Factory fa) {        this.fa = fa;    }    @Override    public void prepareCar() {        en=fa.getEngine();        en.start();        wh=fa.getWheel();        wh.run();    }    }class GoodCar extends Car {    Factory fa;        public GoodCar(Factory fa) {        this.fa = fa;    }        @Override    public void prepareCar() {        en=fa.getEngine();        en.start();        wh=fa.getWheel();        wh.run();    }    }

//測試抽象Factory 方法.public class Test3 {    public static void main(String[] args) {        Factory fa1=new GoodFactory();    //建立一個抽象工廠的具體實作類別        Car c1=new GoodCar(fa1);    //像Car類中傳入工廠以擷取產品族        c1.prepareCar();            //調用擷取產品族的方法        Factory fa2=new BadFactory();        Car c2=new BadCar(fa2);        c2.prepareCar();    }}

　　抽象原廠模式的類圖如下:

 

設計模式整理_原廠模式