深度剖析Java工廠模式的三種不同形式

Java工廠模式是一種建立物件的設計模式，它將物件的建立過程抽象化出來，以便在執行時決定實例化哪個特定的類別。它透過將實例化邏輯從客戶端程式碼中分離出來，使得程式碼更加可維護、靈活和可擴展。工廠模式有三種常見的變體，分別是簡單工廠模式、工廠方法模式和抽象工廠模式。以下將對這三種變體進行詳細解析，並提供具體的程式碼範例。

一、簡單工廠模式

簡單工廠模式（Simple Factory Pattern）又稱為靜態工廠模式，它是工廠模式的最簡單的形式。在簡單工廠模式中，我們將創建物件的邏輯放在一個簡單的工廠類別中，透過呼叫工廠類別的靜態方法來建立物件。簡單工廠模式適用於創建的物件種類相對較少且不會經常發生變化的情況。

// 抽象产品类
public abstract class Product {
    public abstract void use();
}

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

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

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

// 测试代码
public class Client {
    public static void main(String[] args) {
        Product productA = SimpleFactory.createProduct("A");
        productA.use(); // Output: Product A is used.

        Product productB = SimpleFactory.createProduct("B");
        productB.use(); // Output: Product B is used.
    }
}

二、工廠方法模式

工廠方法模式（Factory Method Pattern）將實例化邏輯委託給子類別來完成，將物件的建立延遲到子類別中。每個特定的產品都對應一個特定的工廠，客戶端透過呼叫特定工廠的方法來建立產品。工廠方法模式適用於創建的物件種類較多，且需要彈性擴充的情況。

// 抽象产品类
public abstract class Product {
    public abstract void use();
}

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

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

// 抽象工厂类
public abstract class Factory {
    public abstract Product createProduct();
}

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

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

// 测试代码
public class Client {
    public static void main(String[] args) {
        Factory factoryA = new FactoryA();
        Product productA = factoryA.createProduct();
        productA.use(); // Output: Product A is used.

        Factory factoryB = new FactoryB();
        Product productB = factoryB.createProduct();
        productB.use(); // Output: Product B is used.
    }
}

三、抽象工廠模式

抽象工廠模式（Abstract Factory Pattern）是工廠方法模式的進一步擴展，在抽象工廠模式中，一個具體的工廠可以創建一系列相關的產品。客戶端透過呼叫特定工廠的方法來創建產品，不同的特定工廠可以創建不同的產品組合。抽象工廠模式適用於需要創建一系列相關的產品，且需要保持一致性的情況。

// 抽象产品类A
public abstract class ProductA {
    public abstract void use();
}

// 具体产品类A1
public class ProductA1 extends ProductA {
    @Override
    public void use() {
        System.out.println("Product A1 is used.");
    }
}

// 具体产品类A2
public class ProductA2 extends ProductA {
    @Override
    public void use() {
        System.out.println("Product A2 is used.");
    }
}

// 抽象产品类B
public abstract class ProductB {
    public abstract void use();
}

// 具体产品类B1
public class ProductB1 extends ProductB {
    @Override
    public void use() {
        System.out.println("Product B1 is used.");
    }
}

// 具体产品类B2
public class ProductB2 extends ProductB {
    @Override
    public void use() {
        System.out.println("Product B2 is used.");
    }
}

// 抽象工厂类
public abstract class AbstractFactory {
    public abstract ProductA createProductA();

    public abstract ProductB createProductB();
}

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

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

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

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

// 测试代码
public class Client {
    public static void main(String[] args) {
        AbstractFactory factory1 = new ConcreteFactory1();
        ProductA productA1 = factory1.createProductA();
        productA1.use(); // Output: Product A1 is used.
        ProductB productB1 = factory1.createProductB();
        productB1.use(); // Output: Product B1 is used.

        AbstractFactory factory2 = new ConcreteFactory2();
        ProductA productA2 = factory2.createProductA();
        productA2.use(); // Output: Product A2 is used.
        ProductB productB2 = factory2.createProductB();
        productB2.use(); // Output: Product B2 is used.
    }
}

透過上述程式碼範例，可以清楚地看到簡單工廠模式、工廠方法模式和抽象工廠模式的具體實現方式及應用場景。在實際開發中，我們可以根據特定的需求來選擇適合的工廠模式來創建對象，以達到程式碼的可維護性、靈活性和可擴展性。

以上是深度剖析Java工廠模式的三種不同形式的詳細內容。更多資訊請關注PHP中文網其他相關文章！