Java ファクトリ パターンを使用してオブジェクトを作成し、コードの再利用と柔軟性を向上させる方法

はじめに

Java ファクトリ設計パターンは主に 3 つのタイプに分類されます。

単純なファクトリ パターン: ファクトリ クラスを使用してオブジェクト作成プロセスをカプセル化し、クライアントは別の製品を取得するだけで済みます。

ファクトリ メソッド パターン: ファクトリ クラスを抽象化し、各特定の製品クラスは特定のファクトリ クラスに対応します。ファクトリ クラスは、対応する製品オブジェクトを作成します。ポリモーフィズムを介してクライアントはファクトリ インターフェイスとその実装クラスを知っているだけで済みます。必要に応じてファクトリ実装を動的に切り替えることができ、スケーラビリティが向上します。

抽象ファクトリ パターン: ファクトリ メソッドに基づくパターンでは、ファクトリ クラスが再度抽象化され、複数のファクトリ インターフェイスが 1 つのファクトリ インターフェイスに配置されます。各特定の製品は、特定のファクトリ クラスに対応します。複数のステートフルネスを使用して、対応する製品オブジェクトを作成することで、より優れたスケーラビリティとより高いレベルの抽象化を実現します。ただし、システムの複雑さも増加します

単純なファクトリ パターン

最初に抽象製品クラスを定義します:

package com.fanqiechaodan.factory.simple.product;
/**
 * @Classname Product
 * @Description 抽象产品类
 */
public abstract class Product {
    public abstract void use();
}

次に、特定の製品クラスを定義します

public class ProductA extends Product{
    @Override
    public void use() {
        System.out.println("使用具体产品类A...");
    }
}
public class ProductB extends Product{
    @Override
    public void use() {
        System.out.println("使用具体产品类B...");
    }
}
public class ProductC extends Product{
    @Override
    public void use() {
        System.out.println("使用具体产品类C...");
    }
}

次に、さまざまな製品を作成するためのファクトリ クラスを定義します

package com.fanqiechaodan.factory.simple.factory;
import com.fanqiechaodan.factory.simple.product.Product;
import com.fanqiechaodan.factory.simple.product.ProductA;
import com.fanqiechaodan.factory.simple.product.ProductB;
import com.fanqiechaodan.factory.simple.product.ProductC;
/**
 * @Classname SimpleFactory
 * @Description 工厂类
 */
public class SimpleFactory {
    public static Product createProduct(String type) {
        switch (type) {
            case "A":
                return new ProductA();
            case "B":
                return new ProductB();
            case "C":
                return new ProductC();
            default:
                throw new RuntimeException("不支持的产品类型:" + type);
        }
    }
}

Test:

package com.fanqiechaodan.factory.simple;
import com.fanqiechaodan.factory.simple.factory.SimpleFactory;
import com.fanqiechaodan.factory.simple.product.Product;
/**
 * @Classname Demo
 * @Description 简单工厂模式
 */
public class Demo {
    public static void main(String[] args) {
        Product productA = SimpleFactory.createProduct("A");
        productA.use();
        Product productB = SimpleFactory.createProduct("B");
        productB.use();
        Product productC = SimpleFactory.createProduct("C");
        productC.use();
        Product productD = SimpleFactory.createProduct("D");
        productD.use();
    }
}

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

最初に、 product

package com.fanqiechaodan.factory.method.product;
/**
 * @Classname Product
 * @Description 产品接口
 */
public interface Product {
    void use();
}

次に 2 つの特定の製品実装クラスを定義します

public class ProductA implements Product{
    @Override
    public void use() {
        System.out.println("使用具体产品A...");
    }
}
public class ProductB implements Product{
    @Override
    public void use() {
        System.out.println("使用具体产品B...");
    }
}

次にファクトリを定義します。インターフェイスは製品の作成に使用されます

package com.fanqiechaodan.factory.method.factory;
import com.fanqiechaodan.factory.method.product.Product;
/**
 * @Classname Factory
 * @Description 工厂接口
 */
public interface Factory {
    Product createProduct();
}

次に、2 つの特定のファクトリ実装クラスを定義します。さまざまな製品の作成に使用されます

public class FactoryA implements Factory{
    @Override
    public Product createProduct() {
        return new ProductA();
    }
}
public class FactoryB implements Factory{
    @Override
    public Product createProduct() {
        return new ProductB();
    }
}

テスト

package com.fanqiechaodan.factory.method.factory;
import com.fanqiechaodan.factory.method.product.Product;
import com.fanqiechaodan.factory.method.product.ProductB;
/**
 * @Classname FactoryB
 * @Description 工厂实现类B
 */
public class FactoryB implements Factory{
    @Override
    public Product createProduct() {
        return new ProductB();
    }
}

抽象ファクトリ パターン

最初に抽象製品を定義します

public interface ProductA {
    void doSomething();
}
public interface ProductB {
    void doSomething();
}

次に特定の製品を定義します

public class ProductA1 implements ProductA{
    @Override
    public void doSomething() {
        System.out.println("ProductA1 doSomething ...");
    }
}
public class ProductA2 implements ProductA{
    @Override
    public void doSomething() {
        System.out.println("ProductA2 doSomething ...");
    }
}
public class ProductB1 implements ProductB{
    @Override
    public void doSomething() {
        System.out.println("ProductB1 doSomething ...");
    }
}
public class ProductB2 implements ProductB{
    @Override
    public void doSomething() {
        System.out.println("ProductB2 doSomething ...");
    }
}

次に抽象ファクトリーを定義します

package com.fanqiechaodan.factory.abstractfactory.factory;
import com.fanqiechaodan.factory.abstractfactory.product.ProductA;
import com.fanqiechaodan.factory.abstractfactory.product.ProductB;
/**
 * @Classname AbstractFactory
 * @Description 抽象工厂
 */
public interface AbstractFactory {
    ProductA createProductA();
    ProductB createProductB();
}

次に特定のファクトリーを定義します

public class Factory1 implements AbstractFactory{
    @Override
    public ProductA createProductA() {
        return new ProductA1();
    }
    @Override
    public ProductB createProductB() {
        return new ProductB1();
    }
}
public class Factory2 implements AbstractFactory{
    @Override
    public ProductA createProductA() {
        return new ProductA2();
    }
    @Override
    public ProductB createProductB() {
        return new ProductB2();
    }
}

テスト

package com.fanqiechaodan.factory.abstractfactory;
import com.fanqiechaodan.factory.abstractfactory.factory.AbstractFactory;
import com.fanqiechaodan.factory.abstractfactory.factory.Factory1;
import com.fanqiechaodan.factory.abstractfactory.factory.Factory2;
import com.fanqiechaodan.factory.abstractfactory.product.ProductA;
import com.fanqiechaodan.factory.abstractfactory.product.ProductB;
/**
 * @Classname Demo
 * @Description 抽象工厂模式
 */
public class Demo {
    public static void main(String[] args) {
        // 使用具体工厂1创建产品A和产品B
        AbstractFactory factory1 = new Factory1();
        ProductA productA1 = factory1.createProductA();
        ProductB productB1 = factory1.createProductB();
        productA1.doSomething();
        productB1.doSomething();
        // 使用具体工厂2创建产品A和产品B
        AbstractFactory factory2 = new Factory2();
        ProductA productA2 = factory2.createProductA();
        ProductB productB2 = factory2.createProductB();
        productA2.doSomething();
        productB2.doSomething();
    }
}

以上がJava ファクトリ パターンを使用してオブジェクトを作成し、コードの再利用と柔軟性を向上させる方法の詳細内容です。詳細については、PHP 中国語 Web サイトの他の関連記事を参照してください。