深入理解Java工廠模式的三種實作方式

深入理解Java工廠模式的三種實作方式

工廠模式是一種創建型設計模式，它提供了創建物件的最佳方式，將物件的建立過程與使用過程分離，能夠幫助我們解耦程式碼，提高程式碼的可維護性和可擴充性。在Java中，工廠模式有著廣泛的應用。本文將介紹Java工廠模式的三種實作方式，並提供具體的程式碼範例。

1. 簡單工廠模式（Simple Factory Pattern）

簡單工廠模式又稱為靜態工廠模式，透過一個工廠類，根據不同的參數創建不同的實例對象。它包含三個角色：工廠類別、抽象產品類別和具體產品類別。

下面是一個簡單工廠模式的範例程式碼：

// 抽象产品类
interface Product {
    void print();
}

// 具体产品类A
class ProductA implements Product {
    @Override
    public void print() {
        System.out.println("Product A");
    }
}

// 具体产品类B
class ProductB implements Product {
    @Override
    public void print() {
        System.out.println("Product B");
    }
}

// 工厂类
class SimpleFactory {
    public static Product createProduct(String type) {
        if (type.equals("A")) {
            return new ProductA();
        } else if (type.equals("B")) {
            return new ProductB();
        } else {
            throw new IllegalArgumentException("Invalid product type.");
        }
    }
}

// 测试代码
public class Main {
    public static void main(String[] args) {
        Product productA = SimpleFactory.createProduct("A");
        productA.print();  // 输出：Product A
        
        Product productB = SimpleFactory.createProduct("B");
        productB.print();  // 输出：Product B
    }
}

在以上程式碼中，抽象產品類別Product定義了一個列印方法，具體產品類別ProductA 和ProductB實作了這個方法。工廠類別SimpleFactory透過靜態方法createProduct根據傳入的參數類型建立對應的產品物件。

2. 工廠方法模式（Factory Method Pattern）

工廠方法模式也稱為工廠模式，它把工廠類別的創建產品的邏輯分發到各個具體的工廠子類別中。它包含四個角色：抽象工廠類別、具體工廠類別、抽象產品類別和具體產品類別。

下面是一個工廠方法模式的範例程式碼：

// 抽象产品类
interface Product {
    void print();
}

// 具体产品类A
class ProductA implements Product {
    @Override
    public void print() {
        System.out.println("Product A");
    }
}

// 具体产品类B
class ProductB implements Product {
    @Override
    public void print() {
        System.out.println("Product B");
    }
}

// 抽象工厂类
interface Factory {
    Product createProduct();
}

// 具体工厂类A
class FactoryA implements Factory {
    @Override
    public Product createProduct() {
        return new ProductA();
    }
}

// 具体工厂类B
class FactoryB implements Factory {
    @Override
    public Product createProduct() {
        return new ProductB();
    }
}

// 测试代码
public class Main {
    public static void main(String[] args) {
        Factory factoryA = new FactoryA();
        Product productA = factoryA.createProduct();
        productA.print();  // 输出：Product A
        
        Factory factoryB = new FactoryB();
        Product productB = factoryB.createProduct();
        productB.print();  // 输出：Product B
    }
}

在以上程式碼中，抽象產品類別Product定義了一個列印方法，具體產品類別ProductA 和ProductB實作了這個方法。抽象工廠類別Factory定義了一個建立產品的抽象方法，具體工廠類別FactoryA和FactoryB分別實作了該方法，建立對應的產品物件。

3. 抽象工廠模式（Abstract Factory Pattern）

抽象工廠模式是工廠方法模式的擴展，它由多個抽象產品類別、多個特定產品類別、一個抽象工廠類別和多個特定工廠類別組成。它提供了一種創建一族相關或相互依賴物件的最佳方式。

下面是一個抽象工廠模式的範例程式碼：

// 抽象产品类A
interface ProductA {
    void print();
}

// 具体产品A1
class ProductA1 implements ProductA {
    @Override
    public void print() {
        System.out.println("Product A1");
    }
}

// 具体产品A2
class ProductA2 implements ProductA {
    @Override
    public void print() {
        System.out.println("Product A2");
    }
}

// 抽象产品类B
interface ProductB {
    void print();
}

// 具体产品B1
class ProductB1 implements ProductB {
    @Override
    public void print() {
        System.out.println("Product B1");
    }
}

// 具体产品B2
class ProductB2 implements ProductB {
    @Override
    public void print() {
        System.out.println("Product B2");
    }
}

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

// 具体工厂类1
class ConcreteFactory1 implements AbstractFactory {
    @Override
    public ProductA createProductA() {
        return new ProductA1();
    }
    
    @Override
    public ProductB createProductB() {
        return new ProductB1();
    }
}

// 具体工厂类2
class ConcreteFactory2 implements AbstractFactory {
    @Override
    public ProductA createProductA() {
        return new ProductA2();
    }
    
    @Override
    public ProductB createProductB() {
        return new ProductB2();
    }
}

// 测试代码
public class Main {
    public static void main(String[] args) {
        AbstractFactory factory1 = new ConcreteFactory1();
        ProductA productA1 = factory1.createProductA();
        productA1.print();  // 输出：Product A1
        
        ProductB productB1 = factory1.createProductB();
        productB1.print();  // 输出：Product B1
        
        AbstractFactory factory2 = new ConcreteFactory2();
        ProductA productA2 = factory2.createProductA();
        productA2.print();  // 输出：Product A2
        
        ProductB productB2 = factory2.createProductB();
        productB2.print();  // 输出：Product B2
    }
}

以上程式碼中，抽象產品類別ProductA和ProductB分別定義了一個列印方法，具體產品類別ProductA1、ProductA2、ProductB1和ProductB2實作了此方法。抽象工廠類別AbstractFactory定義了兩個建立產品的抽象方法，具體工廠類別ConcreteFactory1和ConcreteFactory2分別實作了這兩個方法，建立對應的產品對象。

透過上述三種實作方式的程式碼範例，我們可以更深入地理解Java工廠模式的應用和實作方式。根據不同的場景和需求，選擇適合的工廠模式可以幫助我們提高程式碼的可維護性和可擴展性，從而使我們的程式碼更加靈活和易於維護。

以上是深入理解Java工廠模式的三種實作方式的詳細內容。更多資訊請關注PHP中文網其他相關文章！