Java 팩토리 패턴을 사용하여 객체를 생성하고 코드 재사용 및 유연성을 향상시키는 방법

소개

Java 팩토리 디자인 패턴은 주로 세 가지 유형으로 나뉩니다.

간단한 팩토리 패턴: 팩토리 클래스를 사용하여 개체 생성 프로세스를 캡슐화하고 클라이언트는 다른 매개변수만 전달하여 다른 제품 개체를 얻으면 됩니다. 클라이언트가 직접 제품 객체 생성

Factory 메소드 패턴: 팩토리 클래스를 추상화하고, 각 특정 제품 클래스는 특정 팩토리 클래스에 대응하며, 팩토리 클래스는 다형성을 통해 해당 클래스를 생성합니다. 제품 객체의 경우 클라이언트는 팩토리만 알면 됩니다.

추상 팩토리 패턴: 팩토리 메서드 패턴을 기반으로 팩토리 클래스를 다시 추상화하고 여러 팩터리 인터페이스를 각각 하나의 팩토리 인터페이스에 넣습니다. 특정 제품은 특정 팩토리 클래스에 대응하고 다형성을 통해 해당 제품 객체를 생성합니다. 이는 확장성이 더 좋고 더 높습니다. 추상화 정도는 높지만 시스템 복잡성도 증가합니다

간단한 팩토리 패턴

먼저 추상 제품 클래스를 정의합니다.

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);
        }
    }
}

테스트:

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();
    }
}

Factory 메서드 패턴

먼저 제품을 나타내는 인터페이스를 정의합니다

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

두 번째로 두 가지 특정 제품을 정의합니다. 제품 구현 클래스

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();
}

다음으로, 서로 다른 제품을 생성하는 데 사용되는 두 개의 특정 팩토리 구현 클래스를 정의합니다.

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

Test

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();
    }
}

Test

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 중국어 웹사이트의 기타 관련 기사를 참조하세요!