如何使用Java實作工廠模式和抽象工廠？

工廠模式和抽象工廠是建立型設計模式，它們都旨在解決對象的建立過程，并提供了一種靈活、可擴充的方式來建立相關的對象。

一、工廠模式（Factory Pattern）

工廠模式是簡單工廠模式的一種形式，它定義了一個用于建立對象的接口，但是具體建立哪個類的執行個體由子類決定。工廠模式包含以下角色：

1、抽象産品（Product）：定義了産品的公共接口，也可以是一個抽象類。

2、具體産品（Concrete Product）：實作了抽象産品接口的具體類。

3、工廠（Factory）：定義了一個用于建立産品的工廠方法。

下面以一個簡單的示例來示範如何使用Java實作工廠模式。

// 抽象産品
interface Product {
    void use();
}

// 具體産品A
class ConcreteProductA implements Product {
    @Override
    public void use() {
        System.out.println("使用産品A");
    }
}

// 具體産品B
class ConcreteProductB implements Product {
    @Override
    public void use() {
        System.out.println("使用産品B");
    }
}

// 工廠
class Factory {
    public static Product createProduct(String type) {
        if ("A".equals(type)) {
            return new ConcreteProductA();
        } else if ("B".equals(type)) {
            return new ConcreteProductB();
        } else {
            throw new IllegalArgumentException("Unsupported product type: " + type);
        }
    }
}

// 使用工廠建立産品
public class FactoryPatternExample {
    public static void main(String[] args) {
        Product productA = Factory.createProduct("A");
        productA.use();

        Product productB = Factory.createProduct("B");
        productB.use();
    }
}
           

上述示例中，抽象産品Product定義了産品的公共接口，具體産品ConcreteProductA和ConcreteProductB實作了該接口。工廠Factory負責根據參數建立對應的具體産品，并傳回抽象産品。在FactoryPatternExample類中，我們通過工廠建立了兩個具體産品并使用。

工廠模式的優點在于用戶端代碼隻需要知道産品的抽象接口，而無需關心具體産品的實作細節。這樣可以降低代碼的耦合性，提高代碼的可維護性和可擴充性。

二、抽象工廠（Abstract Factory）

抽象工廠是一個超級工廠，它可以建立一組相關或依賴的對象。抽象工廠允許用戶端使用抽象接口來建立一組對象，而不需要知道具體的實作類。抽象工廠包含以下角色：

1、抽象工廠（Abstract Factory）：定義了建立一組産品的接口。

2、具體工廠（Concrete Factory）：實作了抽象工廠接口，用于建立一組具體産品。每個具體工廠負責建立一組相關的産品。

3、抽象産品（Abstract Product）：定義了産品的公共接口。

4、具體産品（Concrete Product）：實作了抽象産品接口的具體類。

下面以一個簡單的示例來示範如何使用Java實作抽象工廠。

// 抽象産品A
interface ProductA {
    void useA();
}

// 具體産品A1
class ConcreteProductA1 implements ProductA {
    @Override
    public void useA() {
        System.out.println("使用産品A1");
    }
}

// 具體産品A2
class ConcreteProductA2 implements ProductA {
    @Override
    public void useA() {
        System.out.println("使用産品A2");
    }
}

// 抽象産品B
interface ProductB {
    void useB();
}

// 具體産品B1
class ConcreteProductB1 implements ProductB {
    @Override
    public void useB() {
        System.out.println("使用産品B1");
    }
}

// 具體産品B2
class ConcreteProductB2 implements ProductB {
    @Override
    public void useB() {
        System.out.println("使用産品B2");
    }
}

// 抽象工廠
interface AbstractFactory {
    ProductA createProductA();
    ProductB createProductB();
}

// 具體工廠1
class ConcreteFactory1 implements AbstractFactory {
    @Override
    public ProductA createProductA() {
        return new ConcreteProductA1();
    }

    @Override
    public ProductB createProductB() {
        return new ConcreteProductB1();
    }
}

// 具體工廠2
class ConcreteFactory2 implements AbstractFactory {
    @Override
    public ProductA createProductA() {
        return new ConcreteProductA2();
    }

    @Override
    public ProductB createProductB() {
        return new ConcreteProductB2();
    }
}

// 使用抽象工廠建立産品
public class AbstractFactoryPatternExample {
    public static void main(String[] args) {
        AbstractFactory factory1 = new ConcreteFactory1();
        ProductA productA1 = factory1.createProductA();
        productA1.useA();
        ProductB productB1 = factory1.createProductB();
        productB1.useB();

        AbstractFactory factory2 = new ConcreteFactory2();
        ProductA productA2 = factory2.createProductA();
        productA2.useA();
        ProductB productB2 = factory2.createProductB();
        productB2.useB();
    }
}
           

上述示例中，抽象産品ProductA和ProductB定義了産品的公共接口，具體産品ConcreteProductA1、ConcreteProductA2、ConcreteProductB1和ConcreteProductB2實作了這些接口。抽象工廠AbstractFactory定義了建立一組産品的方法，具體工廠ConcreteFactory1和ConcreteFactory2分别實作了抽象工廠接口，并負責建立一組相關的産品。

在AbstractFactoryPatternExample類中，我們使用具體工廠1建立了産品A1和産品B1，使用具體工廠2建立了産品A2和産品B2。

抽象工廠模式使得用戶端代碼與具體産品的實作相分離，用戶端隻需要使用抽象接口和抽象工廠來建立産品。這種設計使得系統更具有靈活性，可以友善地切換不同的産品組合。

工廠模式和抽象工廠都是用于對象的建立過程，通過封裝和抽象來解耦用戶端代碼與具體産品的實作。工廠模式适用于單個産品族的情況，而抽象工廠适用于多個相關産品族的情況。在實際開發中，我們可以根據需求選擇合适的設計模式來實作靈活、可擴充的對象建立機制。