Java 기반 팩토리 패턴의 기본 개념 및 원리-java지도 시간-php.cn

Java 기반 팩토리 패턴의 기본 개념 및 원리

王林

풀어 주다： 2023-12-27 09:17:52

원래의

1197명이 탐색했습니다.

Java 기반 팩토리 패턴의 기본 개념 및 원리

Java의 팩토리 패턴의 기본 개념과 원리

팩토리 패턴은 구체적인 구현 세부 사항을 알지 못한 채 공통 인터페이스를 통해 객체를 생성하는 것을 목표로 하는 공통 디자인 패턴입니다. 이 패턴은 보다 유연하고 확장 가능한 코드 구조를 제공할 수 있습니다. Java에는 간단한 팩토리 패턴, 팩토리 메소드 패턴, 추상 팩토리 패턴 등 팩토리 패턴을 구현하는 방법이 많이 있습니다.

심플 팩토리 패턴

심플 팩토리 패턴은 팩토리 클래스를 통해 객체를 생성하는 팩토리 패턴의 가장 기본적인 형태입니다. 이 팩토리 클래스에는 일반적으로 다양한 매개변수를 기반으로 다양한 객체 인스턴스를 생성하는 정적 메서드가 포함되어 있습니다. 다음은 간단한 예입니다.

public 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 interface Product {
    void doSomething();
}

public class ConcreteProductA implements Product {
    @Override
    public void doSomething() {
        System.out.println("Product A do something.");
    }
}

public class ConcreteProductB implements Product {
    @Override
    public void doSomething() {
        System.out.println("Product B do something.");
    }
}

public class Main {
    public static void main(String[] args) {
        Product productA = SimpleFactory.createProduct("A");
        productA.doSomething();

        Product productB = SimpleFactory.createProduct("B");
        productB.doSomething();
    }
}

로그인 후 복사

위 코드에서 SimpleFactory는 전달된 매개변수를 기반으로 해당 제품 객체를 생성하는 간단한 팩토리 클래스입니다. 제품은 제품 개체의 기본 동작을 정의하는 추상 인터페이스입니다. ConcreteProductA 및 ConcreteProductB는 각각 Product 인터페이스를 구현하는 특정 제품 클래스입니다. SimpleFactory是一个简单的工厂类，根据传入的参数创建相应的产品对象。Product是一个抽象接口，定义了产品对象的基本行为。ConcreteProductA和ConcreteProductB是具体的产品类，分别实现了Product接口。

工厂方法模式

工厂方法模式是在简单工厂模式的基础上进行了一定改进，它将具体的产品创建移到各自的工厂类中。这种模式通过定义一个抽象的工厂接口和多个具体的工厂类来实现对象的创建。以下是一个示例：

public interface Factory {
    Product createProduct();
}

public class ConcreteFactoryA implements Factory {
    @Override
    public Product createProduct() {
        return new ConcreteProductA();
    }
}

public class ConcreteFactoryB implements Factory {
    @Override
    public Product createProduct() {
        return new ConcreteProductB();
    }
}

public class Main {
    public static void main(String[] args) {
        Factory factoryA = new ConcreteFactoryA();
        Product productA = factoryA.createProduct();
        productA.doSomething();

        Factory factoryB = new ConcreteFactoryB();
        Product productB = factoryB.createProduct();
        productB.doSomething();
    }
}

로그인 후 복사

在上述代码中，Factory是一个抽象的工厂接口，定义了创建产品的方法。ConcreteFactoryA和ConcreteFactoryB是具体的工厂类，分别创建ConcreteProductA和ConcreteProductB产品对象。

抽象工厂模式

抽象工厂模式是工厂方法模式的进一步扩展，它对一组相关或有依赖关系的产品进行创建。这种模式提供了一个抽象的工厂接口和多个具体的工厂类，每个工厂类负责创建一组相关的产品。以下是一个示例：

public interface AbstractFactory {
    ProductA createProductA();
    ProductB createProductB();
}

public class ConcreteFactory1 implements AbstractFactory {
    @Override
    public ProductA createProductA() {
        return new ConcreteProductA1();
    }

    @Override
    public ProductB createProductB() {
        return new ConcreteProductB1();
    }
}

public class ConcreteFactory2 implements AbstractFactory {
    @Override
    public ProductA createProductA() {
        return new ConcreteProductA2();
    }

    @Override
    public ProductB createProductB() {
        return new ConcreteProductB2();
    }
}

public interface ProductA {
    void doSomething();
}

public class ConcreteProductA1 implements ProductA {
    @Override
    public void doSomething() {
        System.out.println("ProductA1 do something.");
    }
}

public class ConcreteProductA2 implements ProductA {
    @Override
    public void doSomething() {
        System.out.println("ProductA2 do something.");
    }
}

public interface ProductB {
    void doSomething();
}

public class ConcreteProductB1 implements ProductB {
    @Override
    public void doSomething() {
        System.out.println("ProductB1 do something.");
    }
}

public class ConcreteProductB2 implements ProductB {
    @Override
    public void doSomething() {
        System.out.println("ProductB2 do something.");
    }
}

public class Main {
    public static void main(String[] args) {
        AbstractFactory factory1 = new ConcreteFactory1();
        ProductA productA1 = factory1.createProductA();
        productA1.doSomething();
        ProductB productB1 = factory1.createProductB();
        productB1.doSomething();

        AbstractFactory factory2 = new ConcreteFactory2();
        ProductA productA2 = factory2.createProductA();
        productA2.doSomething();
        ProductB productB2 = factory2.createProductB();
        productB2.doSomething();
    }
}

로그인 후 복사

在上述代码中，AbstractFactory是一个抽象的工厂接口，定义了创建多个产品的方法。ConcreteFactory1和ConcreteFactory2是具体的工厂类，分别创建ProductA和ProductB一组产品对象。ProductA和ProductB是抽象的产品接口，定义了产品的基本行为。ConcreteProductA1、ConcreteProductA2、ConcreteProductB1和ConcreteProductB2是具体的产品类，分别实现了ProductA和ProductB