**8. Abstract Factory - 관련 부품을 조합하여 제품을 만든다

8. Abstract Factory - 관련 부품을 조합하여 제품을 만든다

Abstract Factory 패턴은 객체 생성과 관련된 디자인 패턴 중 하나로, 객체 생성 프로세스를 추상화하여 서로 관련된 객체들을 생성하는 인터페이스를 제공합니다. 이 패턴은 클라이언트 코드가 구체적인 클래스를
직접 생성하는 것을 피하고, 추상적인 팩토리를 통해 객체를 생성하도록 합니다. 이를 통해 시스템의 유연성과 확장성을 향상시킬 수 있습니다.

Abstract Factory 패턴의 주요 구성 요소는 다음과 같습니다:

1. Abstract Factory (추상 팩토리): 인터페이스로 정의되며, 관련된 객체를 생성하기 위한 메서드들을 선언합니다. 이 팩토리 인터페이스는 구체적인 팩토리 클래스들이 구현해야 합니다.

2. Concrete Factory (구체적인 팩토리): Abstract Factory 인터페이스를 구현하는 클래스로, 특정 유형의 관련 객체를 생성합니다. 예를 들어, GUI 구성 요소를 생성하는 팩토리,
   데이터베이스 연결을 처리하는 팩토리 등이 될 수 있습니다.

3. Abstract Product (추상 제품): 인터페이스로 정의되며, 생성될 객체의 타입에 대한 메서드를 선언합니다.

4. Concrete Product (구체적인 제품): Abstract Product 인터페이스를 구현한 클래스로, 팩토리가 생성하는 실제 객체입니다.

Abstract Factory 패턴을 사용하면 클라이언트 코드는 구체적인 클래스에 의존하지 않고, 추상 팩토리를 통해 객체를 생성할 수 있으므로, 시스템의 유지보수와 확장이 용이해집니다. 또한, 다양한 팩토리를
생성하여 서로 다른 구현을 제공하면서, 동일한 클라이언트 코드를 사용하여 다양한 환경에 적응시킬 수 있습니다.

예를 들어, GUI 라이브러리에서는 Abstract Factory 패턴을 사용하여 버튼, 텍스트 상자, 창 등의 구성 요소를 생성하고, 플랫폼에 따라 Windows용 또는 macOS용 구현을 제공할 수 있습니다.

예제

자바로 구현된 간단한 Abstract Factory 패턴 예제를 제공하겠습니다. 이 예제에서는 도형(Shape)을 생성하는 추상 팩토리와 원(Circle) 및 사각형(Rectangle)과 같은 구체적인 제품을
생성하는 팩토리를 만들어 보겠습니다.

1. 도형(Shape) 및 구체적인 제품 클래스 정의:

// 추상 도형
interface Shape {
    void draw();
}

// 구체적인 원 클래스
class Circle implements Shape {
    @Override
    public void draw() {
        System.out.println("원을 그립니다.");
    }
}

// 구체적인 사각형 클래스
class Rectangle implements Shape {
    @Override
    public void draw() {
        System.out.println("사각형을 그립니다.");
    }
}

2. Abstract Factory 인터페이스 정의:

// 도형을 생성하는 추상 팩토리 인터페이스
interface ShapeFactory {
    Shape createShape();
}

3. 구체적인 팩토리 클래스 구현:

// 원을 생성하는 팩토리
class CircleFactory implements ShapeFactory {
    @Override
    public Shape createShape() {
        return new Circle();
    }
}

// 사각형을 생성하는 팩토리
class RectangleFactory implements ShapeFactory {
    @Override
    public Shape createShape() {
        return new Rectangle();
    }
}

4. 클라이언트 코드를 작성하여 Abstract Factory를 사용:

public class Client {
    public static void main(String[] args) {
        // 원을 생성하는 팩토리를 사용
        ShapeFactory circleFactory = new CircleFactory();
        Shape circle = circleFactory.createShape();
        circle.draw();

        // 사각형을 생성하는 팩토리를 사용
        ShapeFactory rectangleFactory = new RectangleFactory();
        Shape rectangle = rectangleFactory.createShape();
        rectangle.draw();
    }
}

이 예제에서, ShapeFactory 인터페이스를 사용하여 다양한 도형을 생성할 수 있으며, 클라이언트 코드는 구체적인 클래스에 의존하지 않고도 원과 사각형을 생성할 수 있습니다. Abstract Factory
패턴을 활용하면 동일한 인터페이스를 사용하여 다양한 종류의 객체를 생성할 수 있어 시스템의 확장성과 유연성이 향상됩니다.

Factory, Factory Method, Abstract Factory 패턴의 차이

Factory, Factory Method, 및 Abstract Factory 패턴은 객체 생성에 관한 디자인 패턴으로, 각각 다른 목적과 구조를 가지고 있습니다. 이들 패턴 간의 주요 차이점은 다음과 같습니다:

1. Factory 패턴 (Simple Factory):

   • Factory 패턴은 하나의 팩토리 클래스가 객체를 생성하는 방식으로, 클라이언트 코드는 해당 팩토리 클래스를 통해 객체를 생성합니다.
   • 팩토리 클래스는 객체 생성 및 초기화를 처리하고, 클라이언트 코드는 이 팩토리 클래스를 호출하여 원하는 객체를 받습니다.
   • Factory 패턴은 단일 클래스를 통해 객체 생성을 처리하므로 간단하고 직관적인 디자인을 가집니다.

2. Factory Method 패턴:

   • Factory Method 패턴은 객체 생성을 서브 클래스로 미루는 방식으로, 추상 팩토리 클래스를 정의하고 이를 구현하는 여러 서브 클래스에서 객체 생성 메서드를 구현합니다.
   • 클라이언트 코드는 추상 팩토리 클래스를 사용하며, 어떤 구체적인 서브 클래스가 선택되느냐에 따라 다른 객체가 생성됩니다.
   • Factory Method 패턴은 상속을 통한 확장에 용이하며, 객체 생성에 대한 결정을 서브 클래스로 미룸으로써 유연성을 확보합니다.

3. Abstract Factory 패턴:

   • Abstract Factory 패턴은 관련된 객체의 패밀리를 생성하기 위한 인터페이스를 정의하며, 이 인터페이스를 구현한 여러 개별 팩토리 클래스를 생성합니다.
   • 클라이언트 코드는 추상 팩토리를 통해 객체를 생성하며, 서로 관련된 객체들의 조합을 유지하기 위한 팩토리 패턴입니다.
   • Abstract Factory 패턴은 객체 패밀리 간의 일관성을 유지하고 다양한 환경에서 서로 다른 객체 조합을 제공하는 데 사용됩니다.

간단히 말해, Factory 패턴은 하나의 클래스를 통해 객체 생성을 처리하고, Factory Method 패턴은 객체 생성을 서브 클래스로 위임하며, Abstract Factory 패턴은 관련된 객체 패밀리를
생성하기 위한 추상적인 인터페이스를 정의하고 여러 구체적인 팩토리 클래스로 구현하여 다양한 객체 조합을 제공합니다.

Factory, Factory Method, Abstract Factory 예제 코드

Factory, Factory Method, 및 Abstract Factory 패턴 각각의 차이를 보다 명확히 이해하기 위해 각 패턴에 대한 구체적인 예제를 제공하겠습니다.

Factory 패턴 (Simple Factory):

이 패턴은 하나의 팩토리 클래스가 객체를 생성하는 패턴입니다. 다음은 Factory 패턴의 간단한 예제입니다.

// Factory 패턴: 하나의 팩토리 클래스
class ShapeFactory {
    public Shape createShape(String shapeType) {
        if (shapeType.equals("Circle")) {
            return new Circle();
        } else if (shapeType.equals("Rectangle")) {
            return new Rectangle();
        }
        return null;
    }
}

    // 클라이언트 코드
    ShapeFactory factory = new ShapeFactory();
    Shape shape1 = factory.createShape("Circle");
    Shape shape2 = factory.createShape("Rectangle");

이 패턴은 하나의 팩토리 클래스(ShapeFactory)를 통해 객체를 생성합니다.

Factory Method 패턴:

Factory Method 패턴은 객체 생성을 서브 클래스로 미루는 패턴으로, 각 객체 타입에 대한 팩토리 메서드를 정의하는 것이 특징입니다.

// Factory Method 패턴: 추상 팩토리와 서브 클래스 팩토리 메서드
interface ShapeFactory {
    Shape createShape();
}

// 구체적인 팩토리 서브 클래스
class CircleFactory implements ShapeFactory {
    public Shape createShape() {
        return new Circle();
    }
}

class RectangleFactory implements ShapeFactory {
    public Shape createShape() {
        return new Rectangle();
    }
}

    // 클라이언트 코드
    ShapeFactory circleFactory = new CircleFactory();
    ShapeFactory rectangleFactory = new RectangleFactory();
    Shape shape1 = circleFactory.createShape();
    Shape shape2 = rectangleFactory.createShape();

Factory Method 패턴은 팩토리 메서드를 정의하는 추상 팩토리(ShapeFactory)와 각 객체 타입에 대한 구체적인 서브 클래스 팩토리를 제공합니다.

Abstract Factory 패턴:

Abstract Factory 패턴은 관련된 객체 패밀리를 생성하기 위한 인터페이스를 정의하고, 여러 개별 팩토리 클래스를 생성하는 패턴입니다.

// Abstract Factory 패턴: 팩토리 인터페이스와 여러 구체적인 팩토리 클래스
interface ShapeFactory {
    Shape createShape();

    Color createColor();
}

// 구체적인 팩토리 클래스
class RedCircleFactory implements ShapeFactory {
    public Shape createShape() {
        return new Circle();
    }

    public Color createColor() {
        return new RedColor();
    }
}

class BlueRectangleFactory implements ShapeFactory {
    public Shape createShape() {
        return new Rectangle();
    }

    public Color createColor() {
        return new BlueColor();
    }
}

    // 클라이언트 코드
    ShapeFactory factory1 = new RedCircleFactory();
    ShapeFactory factory2 = new BlueRectangleFactory();
    Shape shape1 = factory1.createShape();
    Color color1 = factory1.createColor();
    Shape shape2 = factory2.createShape();
    Color color2 = factory2.createColor();

Abstract Factory 패턴은 관련된 객체 패밀리를 생성하기 위한 인터페이스를 정의하고, 각 객체 패밀리에 대한 구체적인 팩토리 클래스를 생성합니다. 클라이언트 코드는 원하는 팩토리를 선택하여 객체를 생성할
수 있습니다.

이것들은 각 패턴의 핵심 아이디어를 나타내는 예제입니다. Factory 패턴은 단일 팩토리 클래스를 사용하고, Factory Method 패턴은 팩토리 메서드를 서브 클래스에서 구현하여 객체를 생성하며,
Abstract Factory 패턴은 관련된 객체 패밀리를 생성하기 위한 인터페이스와 여러 구체적인 팩토리 클래스를 제공합니다.