Java工廠模式的三種設計方法探究

探索Java工廠模式的三種設計想法

工廠模式是一種常用的設計模式，用於建立物件而無需指定特定的類別。在Java中，工廠模式可以透過多種方式實現。本文將探討基於不同設計思路的三種Java工廠模式的實作方式，並給出具體的程式碼範例。

1. 簡單工廠模式

簡單工廠模式是最基本的工廠模式，它透過一個工廠類別來建立物件。工廠類別根據客戶端的請求參數來決定應該建立哪種特定物件。以下是一個簡單工廠模式的範例：

// 抽象产品接口
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 SimpleFactory {
    public static Product createProduct(String type) {
        if (type.equals("A")) {
            return new ConcreteProductA();
        } else if (type.equals("B")) {
            return new ConcreteProductB();
        }
        return null;
    }
}

// 客户端代码
public class Client {
    public static void main(String[] args) {
        Product productA = SimpleFactory.createProduct("A");
        productA.use();
        
        Product productB = SimpleFactory.createProduct("B");
        productB.use();
    }
}

2. 工廠方法模式

工廠方法模式透過定義一個建立物件的接口，讓子類別決定具體要實例化的類。工廠方法模式可以實現產品與客戶端的解耦。以下是一個工廠方法模式的範例：

// 抽象产品接口
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");
    }
}

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

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

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

// 客户端代码
public class Client {
    public static void main(String[] args) {
        Factory factoryA = new ConcreteFactoryA();
        Product productA = factoryA.createProduct();
        productA.use();
        
        Factory factoryB = new ConcreteFactoryB();
        Product productB = factoryB.createProduct();
        productB.use();
    }
}

3. 抽象工廠模式

#抽象工廠模式是將多個工廠方法組合在一起的更高層級的設計模式。它提供了一個接口，用於創建不同類型的產品族。以下是一個抽象工廠模式的範例：

// 抽象产品A接口
interface ProductA {
    void useProductA();
}

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

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

// 抽象产品B接口
interface ProductB {
    void useProductB();
}

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

// 具体产品B2
class ConcreteProductB2 implements ProductB {
    @Override
    public void useProductB() {
        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 Client {
    public static void main(String[] args) {
        AbstractFactory factory1 = new ConcreteFactory1();
        ProductA productA1 = factory1.createProductA();
        ProductB productB1 = factory1.createProductB();
        productA1.useProductA();
        productB1.useProductB();
        
        AbstractFactory factory2 = new ConcreteFactory2();
        ProductA productA2 = factory2.createProductA();
        ProductB productB2 = factory2.createProductB();
        productA2.useProductA();
        productB2.useProductB();
    }
}

透過上述範例，我們可以看到不同的設計想法下，Java工廠模式的具體實作方式。簡單工廠模式適合對象較少且簡單的情況，工廠方法模式提供了更高的靈活性，而抽象工廠模式則適合創建多個產品族的情況。在實際應用中，可以根據特定的業務需求選擇適合的工廠模式來建立物件。

以上是Java工廠模式的三種設計方法探究的詳細內容。更多資訊請關注PHP中文網其他相關文章！