세 가지 형태의 Java 팩토리 패턴에 대한 심층 분석

Java 팩토리 패턴은 객체 생성 프로세스를 추상화하여 런타임 시 인스턴스화할 특정 클래스를 결정할 수 있습니다. 클라이언트 코드에서 인스턴스화 논리를 분리하여 코드를 보다 유지 관리하기 쉽고 유연하며 확장 가능하게 만듭니다. 팩토리 패턴에는 세 가지 일반적인 변형, 즉 단순 팩토리 패턴, 팩토리 메소드 패턴 및 추상 팩토리 패턴이 있습니다. 이 세 가지 변형은 아래에서 자세히 분석되며 구체적인 코드 예제가 제공됩니다.

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 팩토리 패턴에 대한 심층 분석의 상세 내용입니다. 자세한 내용은 PHP 중국어 웹사이트의 기타 관련 기사를 참조하세요!