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

什么是工廠模式？

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

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

簡單工廠模式

說明：簡單工廠模式的實現就是通過我們創建一個工廠類，然后通過此工廠為我們生產創建對象，從而使用對象。

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

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

// 定義車輛的接口
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皮皮蟹“