Java工廠模式

 工廠模式是我們最常用的執行個體化對象模式了，是用工廠方法代替new操作的一種模式,工廠模式在Java程式中可以說是随處可見。本文來給大家詳細介紹下工廠模式

面向對象設計的基本原則：

OCP（開閉原則，Open-Closed Principle）：一個軟體的實體應當對擴充開放，對修改關閉。

DIP（依賴倒轉原則，Dependence Inversion Principle）：要針對接口程式設計，不要針對實作程式設計。

LoD（迪米特法則，Law of Demeter）：隻與你直接的朋友通信，而避免和陌生人通信

三種工廠模式的差別

實作了建立者和調用者的分離

核心本質：

   執行個體化對象，用工廠方法代替new操作。

   将選擇實作類、建立對象統一管理和控制。進而将調用者跟我們的實作類解耦

簡單工廠模式

接口定義

public interface Car {
    void run();
}      

Car實作類

public class Audi implements Car {
    @Override
    public void run() {
        System.out.println("奧迪再跑...");
    }
}
public class Byd implements Car {
    @Override
    public void run() {
        System.out.println("比亞迪再跑！");
    }
}      

簡單工廠類

public class CarFactory {
    public static  Car createCar(String type){
        if("奧迪".equals(type)){
            return new Audi();
        }else if("比亞迪".equals(type)){
            return new Byd();
        }else{
            return null;
        }
    }
}

public class CarFactory2 {
    
    public static  Car createAudi(){
        return new Audi();
    }
    public static  Car createByd(){
        return new Byd();
    }
}      

測試

public class Client02 {   //調用者
    public static void main(String[] args) {
        Car c1 =CarFactory.createCar("奧迪");
        Car c2 = CarFactory.createCar("比亞迪");
        
        c1.run();
        c2.run();
    }
}      

小結:

   簡單工廠模式也叫靜态工廠模式，就是工廠類一般是使用靜态方法，通過接收的參數的不同來傳回不同的對象執行個體。

   對于增加新産品無能為力！不修改代碼的話，是無法擴充的。

工廠方法模式

工廠方法模式要點：

   為了避免簡單工廠模式的缺點，不完全滿足OCP。

   工廠方法模式和簡單工廠模式最大的不同在于，簡單工廠模式隻有一個（對于一個項目工廠方法模式和簡單工廠模式最大的不同在于，簡單工廠模式隻有一個（對于一個項目或者一個獨立子產品而言）工廠類，而工廠方法模式有一組實作了相同接口的工廠類

業務接口

public interface Car {
    void run();
}      

car實作類

public class Audi implements Car {
    @Override
    public void run() {
        System.out.println("奧迪再跑！");
    }
}
public class Benz implements Car {
    @Override
    public void run() {
        System.out.println("奔馳再跑！");
    }
}      

工廠接口

public interface Car {
    void run();
}      

每個car實作類對應建立一個工廠類

public class AudiFactory implements CarFactory {
    @Override
    public Car createCar() {
        return new Audi();
    }
}
public class BenzFactory implements CarFactory {
    @Override
    public Car createCar() {
        return new Benz();
    }
}      

public class Client {
    public static void main(String[] args) {
        Car c1 = new AudiFactory().createCar();
        Car c2 = new BydFactory().createCar();
        
        c1.run();
        c2.run();
    }
}      

簡單工廠模式和工廠方法模式PK:

結構複雜度

 從這個角度比較，顯然簡單工廠模式要占優。簡單工廠模式隻需一個工廠類，而工廠方法模式的工廠類随着産品類個數增加而增加，這無疑會使類的個數越來越多，進而增加了結構的複雜程度。

代碼複雜度

 代碼複雜度和結構複雜度是一對沖突，既然簡單工廠模式在結構方面相對簡潔，那麼它在代碼方面肯定是比工廠方法模式複雜的了。簡單工廠模式的工廠類随着産品類的增加需要增加很多方法（或代碼），而工廠方法模式每個具體工廠類隻完成單一任務，代碼簡潔。

用戶端程式設計難度

 工廠方法模式雖然在工廠類結構中引入了接口進而滿足了OCP，但是在用戶端編碼中需要對工廠類進行執行個體化。而簡單工廠模式的工廠類是個靜态類，在用戶端無需執行個體化，這無疑是個吸引人的優點。

管理上的難度

這是個關鍵的問題。

我們先談擴充。衆所周知，工廠方法模式完全滿足OCP，即它有非常良好的擴充性。那是否就說明了簡單工廠模式就沒有擴充性呢？答案是否定的。簡單工廠模式同樣具備良好的擴充性——擴充的時候僅需要修改少量的代碼（修改工

廠類的代碼）就可以滿足擴充性的要求了。盡管這沒有完全滿足OCP，但我們不需要太拘泥于設計理論，要知道，sun提供的java官方工具包中也有想到多沒有滿足OCP的例子啊。然後我們從維護性的角度分析下。假如某個具體産品類需要進行一定的修改，很可能需要修改對應的工廠類。當同時需要修改多個産品類的時候，對工廠類的修改會變得相當麻煩（對号入座已經是個問題了）。反而簡單工廠沒有這些麻煩，當多個産品類需要修改是，簡單工廠模式仍然僅僅需要修改唯一的工廠類（無論怎樣都能改到滿足要求吧？大不了把這個類重寫）。

根據設計理論建議：工廠方法模式。但實際上，我們一般都用簡單工廠模式。

抽象工廠模式

   用來生産不同産品族的全部産品。（對于增加新的産品，無能為力；支援增加産品族）

   抽象工廠模式是工廠方法模式的更新版本，在有多個業務品種、業務分類時，通過抽象工廠模式産生需要的對象是一種非常好的解決方式。

類圖

案例代碼

public interface Engine {
    void run();
    void start();
}


class LuxuryEngine implements Engine{

    @Override
    public void run() {
        System.out.println("轉的快！");
    }

    @Override
    public void start() {
        System.out.println("啟動快!可以自動啟停！");
    }
    
}

class LowEngine implements Engine{
    
    @Override
    public void run() {
        System.out.println("轉的慢！");
    }
    
    @Override
    public void start() {
        System.out.println("啟動慢!");
    }
    
}      

public interface Seat {
    void massage();
}

class LuxurySeat implements Seat {

    @Override
    public void massage() {
        System.out.println("可以自動按摩！");
    }
    
}
class LowSeat implements Seat {

    @Override
    public void massage() {
        System.out.println("不能按摩！");
    }
}      

public interface Tyre {
    void revolve();
}

class LuxuryTyre implements Tyre {

    @Override
    public void revolve() {
        System.out.println("旋轉不磨損！");
    }
}

class LowTyre implements Tyre {

    @Override
    public void revolve() {
        System.out.println("旋轉磨損快！");
    }
}      

工廠模式

public interface CarFactory {
    Engine createEngine();
    Seat createSeat();
    Tyre createTyre();
}      

public class LowCarFactory implements CarFactory {

    @Override
    public Engine createEngine() {
        return new LowEngine();
    }

    @Override
    public Seat createSeat() {
        return new LowSeat();
    }

    @Override
    public Tyre createTyre() {
        return new LowTyre();
    }
}      

public class LuxuryCarFactory implements CarFactory {

    @Override
    public Engine createEngine() {
        return new LuxuryEngine();
    }

    @Override
    public Seat createSeat() {
        return new LuxurySeat();
    }

    @Override
    public Tyre createTyre() {
        return new LuxuryTyre();
    }
}      

public class Client {

    public static void main(String[] args) {
        CarFactory  factory = new LuxuryCarFactory();
        Engine e = factory.createEngine();
        e.run();
        e.start();
    }
}      

工廠模式要點：

   簡單工廠模式(靜态工廠模式)

   • 雖然某種程度不符合設計原則，但實際使用最多。

   工廠方法模式

   • 不修改已有類的前提下，通過增加新的工廠類實作擴充。

   抽象工廠模式

   • 不可以增加産品，可以增加産品族！

應用場景