工廠模式還不懂？看這裏！

什麼是工廠模式？

工廠模式是建立型設計模式，它是方便咱們更好地建立對象而設計的一種模式。經過工廠模式建立的的對象，不會向客戶端暴露對象建立的邏輯，而且經過一個共同的接口指向建立的對象。

此次咱們主要來介紹簡單工廠模式和抽象工廠模式~

簡單工廠模式

說明：簡單工廠模式的實現就是經過咱們建立一個工廠類，而後經過此工廠爲咱們生產建立對象，從而使用對象。

咱們經過下面的栗子去理解簡單工廠模式的使用：

首先咱們建立一個車輛的接口，以便後面具體車輛的實現（如自行車、摩托車）

// 定義車輛的接口
public interface Vehicle {
    // 定義一個駕駛的接口方法
    void driver();
}

接着讓自行車類和摩托車類都去實現車輛的的接口

自行車類：

// 自行車類實現車輛接口
public class Bicycle extends SimpleFactory implements Vehicle{
    @Override
    public void driver() {
        System.out.println("騎自行車！");
    }
}

摩托車類：

// 摩托車類實現車輛接口
public class Motorcycle extends SimpleFactory implements Vehicle{
    @Override
    public void driver() {
        System.out.println("騎摩托車！");
    }
}

而簡單工廠模式的最主要的即是建立的對象的工廠，經過工廠咱們才能實現生產各類對象，並對這些生產對象進行使用。

建立一個生產車輛的工廠：

// 定義一個工廠類，用於生產車的對象
public class SimpleFactory {

    // 定義一個生產車的方法
    public Vehicle getVehicle(String vehicle){
        if(vehicle.equalsIgnoreCase("bicycle")){
            return new Bicycle();
        }else if (vehicle.equalsIgnoreCase("motorcycle")){
            return new Motorcycle();
        }
        return null;
    }
}

這樣咱們的工廠就能夠去使用了，經過這些工廠中的方法，咱們即可以去實現對車輛對象的建立，而不是直接調用車輛的對象。這樣利用一個工廠去替咱們生產對象的方式也就是咱們說的簡單工廠模式。

調用工廠去生產對象：

public class Main {

    public static void main(String[] args) {
        // 建立一個簡單工廠對象
        SimpleFactory simpleFactory = new SimpleFactory();
        // 經過工廠對象的方法生產須要的車輛(這裏是自行車)
        Vehicle bicycle = simpleFactory.getVehicle("bicycle");
        // 調用工廠生產的車輛的對象的方法
        bicycle.driver();
        
        // 經過工廠對象的方法生產須要的車輛(這裏是摩托車)
        Vehicle Motorcycle = simpleFactory.getVehicle("Motorcycle");
        // 調用工廠生產的車輛的對象的方法
        Motorcycle.driver();
    }
}

運行結果以下：

如此，咱們並無具體去使用車輛的對象(以下代碼)，這樣即可以暴露本身建立對象的邏輯實現對對象的建立。

public class Main {
    public static void main(String[] args) {
        // 這樣使用具體的車輛去建立對象(不使用工廠模式):自行車對象
        Vehicle vehicle1  = new Bicycle();
        vehicle1.driver();

        // 這樣使用具體的車輛去建立對象(不使用工廠模式):摩托車對象
        Vehicle vehicle2  = new Motorcycle();
        vehicle2.driver();
    }
}

抽象工廠模式

說明：抽象工廠模式實現方法簡單來講就是用一個超級工廠去建立多個工廠。咱們使用這個超級工廠去建立工廠對象，而後用咱們建立的工廠爲咱們建立對象。

分析：咱們知道一個工廠不能既生產水果，又生產車輛，因此這時候就須要使用抽象工廠的設計模式，經過一個超級工廠去生產一個水果廠和車輛廠，而後經過車輛廠生產車輛，經過水果廠生產水果。

繼續經過實例來了解抽象工廠模式：

首先咱們建立兩個接口：Vehicle和Fruit

// 定義車輛的接口
public interface Vehicle {
    // 定義一個駕駛的接口方法
    void driver();
}

// 定義一個水果的接口
public interface Fruit {
    // 定義吃的接口方法
    void eat();
}

而後對分別對這兩個接口進行實現：

實現Vehicle的類分別爲：Bicycle和Motorcycle

// 摩托車類實現車輛接口
public class Motorcycle implements Vehicle {
    @Override
    public void driver() {
        System.out.println("騎摩托車！");
    }
}

// 自行車類實現車輛接口
public class Bicycle implements Vehicle {
    @Override
    public void driver() {
        System.out.println("騎自行車！");
    }
}

實現Fruit接口的類分別爲：Apple和Banana

// 實現Fruit的接口: Banana
public class Banana implements Fruit{
    @Override
    public void eat() {
        System.out.println("吃香蕉！");
    }
}

// 實現Fruit的接口: Apple
public class Apple implements Fruit{
    @Override
    public void eat() {
        System.out.println("吃蘋果！");
    }
}

緊接着也就是最主要的就是經過一個抽象類來獲取獲得咱們普通的工廠（水果廠和車輛廠）：

// 定義一個抽象工廠類
public abstract class AbstractFactory{
    abstract Vehicle getVehicle(String vehicle);
    abstract Fruit getFruit(String fruit);
}

經過繼承該抽象類來實現分別實現生產水果的工廠FruitFactory和生產車輛的VehicleFactory：

// 定義一個水果工廠並繼承抽象工廠AbstractFactory
public class FruitFactory extends AbstractFactory{
    @Override
    Vehicle getVehicle(String vehicle) {
        return null;
    }

    @Override
    Fruit getFruit(String fruit) {
        if(fruit.equalsIgnoreCase("apple")){
            return new Apple();
        }else if(fruit.equalsIgnoreCase("banana")){
            return new Banana();
        }
        return null;
    }
}

// 定義一個生產車輛的工廠並繼承抽象工廠
public class VehicleFactory extends AbstractFactory{
    @Override
    Vehicle getVehicle(String vehicle) {
        if(vehicle.equalsIgnoreCase("bicycle")){
            return new Bicycle();
        }else if (vehicle.equalsIgnoreCase("motorcycle")){
            return new Motorcycle();
        }
        return null;
    }

    @Override
    Fruit getFruit(String fruit) {
        return null;
    }
}

這樣咱們就把建立了普通的兩個工廠，咱們須要建立一個生產普通工廠的超級工廠。

// 建立一個生產工廠的超級工廠FactoryProducer
public class FactoryProducer {
    public AbstractFactory getFactory(String factory){
        if(factory.equalsIgnoreCase("fruit")){
            return new FruitFactory();
        }else if (factory.equalsIgnoreCase("vehicle")){
            return new VehicleFactory();
        }
        return null;
    }
}

因而咱們便經過這種方式建立了一個關於工廠模式的實例，如此咱們即可以經過此方式建立不一樣工廠中的對象。

public class Main {
    public static void main(String[] args) {
        // 建立FactoryProducer對象，生產工廠對象
        FactoryProducer factoryProducer = new FactoryProducer();
        // 調用FactoryProducer中的方法生產水果工廠
        AbstractFactory fruitFactory = factoryProducer.getFactory("fruit");
        // 調用水果工廠的方法進而建立Apple對象
        Fruit apple = fruitFactory.getFruit("apple");
        // 調用Apple對象的方法
        apple.eat();

        // 調用FactoryProducer中的方法生產車輛工廠
        AbstractFactory vehicleFactory = factoryProducer.getFactory("vehicle");
        // 調用車輛工廠的方法進而建立bicycle對象
        Vehicle bicycle = vehicleFactory.getVehicle("bicycle");
        // 調用bicycle對象的方法
        bicycle.driver();
    }
}

運行結果以下圖所示：

總結

簡單工廠模式就是經過工廠類去幫助咱們建立對象，咱們只須要建立工廠類的對象，經過接收工廠類傳入的數據進而建立咱們須要的對象，而抽象工廠模式則是因爲一個簡單的工廠只能建立一個類型對象，而其餘類型的對象則須要咱們用其餘的工廠，這就須要一個超級工廠去生產這些工廠對象，進而建立更多類型的對象。

若是本文對你有一些幫助，歡迎點贊收藏關注。更多內容也能夠關注公衆號」IT皮皮蟹「