Java ファクトリ パターンの 3 つの異なる形式の詳細な分析

Java ファクトリ パターンは、オブジェクトを作成するための設計パターンであり、実行時にどの特定のクラスをインスタンス化するかを決定できるように、オブジェクト作成プロセスを抽象化します。インスタンス化ロジックをクライアント コードから分離することで、コードの保守性、柔軟性、拡張性が向上します。ファクトリ パターンには、単純なファクトリ パターン、ファクトリ メソッド パターン、および抽象ファクトリ パターンという 3 つの一般的なバリアントがあります。これら 3 つの亜種については以下で詳細に分析し、具体的なコード例を示します。

1. シンプル ファクトリ パターン

シンプル ファクトリ パターン (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.
    }
}

2. ファクトリ メソッド パターン

ファクトリ メソッド パターンは、インスタンス化ロジックをサブクラスに委任し、サブクラスへのオブジェクトの作成を遅らせます。それぞれの特定のプロダクトは特定のファクトリに対応し、クライアントは特定のファクトリのメソッドを呼び出すことによってプロダクトを作成します。ファクトリ メソッド パターンは、作成されるオブジェクトの種類が多く、柔軟な拡張が必要な​​状況に適しています。

// 抽象产品类
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.
    }
}

3. 抽象ファクトリ パターン

抽象ファクトリ パターンは、ファクトリ メソッド パターンをさらに拡張したもので、特定のファクトリが一連の関連製品を作成できます。クライアントは特定のファクトリのメソッドを呼び出すことで製品を作成し、特定のファクトリが異なれば、異なる製品の組み合わせを作成できます。抽象ファクトリー パターンは、一連の関連製品を作成する必要があり、一貫性を維持する必要がある状況に適しています。

// 抽象产品类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 ファクトリ パターンの 3 つの異なる形式の詳細な分析の詳細内容です。詳細については、PHP 中国語 Web サイトの他の関連記事を参照してください。