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

IT皮皮蟹發表於2021-04-14
模式

什麼是工廠模式？

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

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

簡單工廠模式

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

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

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

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

相關文章