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. Factory 메소드 패턴

팩토리 메소드 패턴은 객체 생성을 위한 인터페이스를 정의하고 하위 클래스가 인스턴스화할 클래스를 결정할 수 있도록 합니다. 팩토리 메소드 패턴은 제품과 클라이언트의 분리를 달성할 수 있습니다. 다음은 팩토리 메소드 패턴의 예입니다.

// 抽象产品接口
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 중국어 웹사이트의 기타 관련 기사를 참조하세요!