Design Pattern

GoF의 디자인 패턴

• Gang of Four

  • Erich Gamma, Richard Helm, Ralph Johnson, John Vlissides 라는 네명의 저자를 뜻함

• 소프트웨어 디자인에서 자주 발생하는 문제들에 대한 해결책을 제공하는 23가지 디자인 패턴의 조합

객체지향 원칙

• 바뀌는 부분은 캡슐화한다

• 상속보다는 구성을 활용한다

• 구현보다는 인터페이스에 맞춰서 프로그래밍한다

• 상호작용하는 객체 사이에서는 가능하면 느슨한 결합을 사용해야 한다

• 클래스는 확장에는 열려 있어야 하지만 변경에는 닫혀있어야 한다(OCP)

• 추상화된 것에 의존하게 만들고 구상 클래스에 의존하지 않게 만든다.

생성 패턴(Creational Patterns)

• 객체의 생성과 초기화에 관련된 패턴

• 객체를 생성하는 방식을 추상화

• 주요 패턴: Singleton, Factory Method, Abstract Factory, Builder, Prototype

구조 패턴(Structural Patterns)

• 클래스나 객체를 합성하여 더 큰 구조로 만드는 패턴

• 클래스와 객체를 조합하여 더큰 구조로 만듦

• 주요 패턴: Adapter, Bridge, Composite, Decorator, Facade, Flyweight, Proxy

행동 패턴(Behavioral Paterrns)

• 객체 간의 통신과 책임을 분산하는 패턴

• 알고리즘과 객체 간의 책임을 분리

• 주요 패턴: Chain of Responsibility, Command, Interpreter, Iterator, Mediator, Memento, Observer, State, Strategy, Template Method, Visitor

생성 패턴

팩토리 패턴

• 객체 생성을 캡슐화하는 디자인 패턴

• 객체를 생성하는 코드를 클라이언트 코드로부터 분리하여 유연성을 제공

• 객체를 생성하는 과정을 서브클래스에서 처리하도록 하는 것이 특징

• 객체를 생성하는 별도 도구를 제공

// 도형 인터페이스
interface Shape {
  void draw()
}

// 구체적인 도형 클래스 - 원
class Circle implements Shpae {
  @Override
   public void draw() {
  }
}

// 구체적인 도형 클래스 - 정사각형
class Square implements Shpae {
  @Override
   public void draw() {
  }
}

// 팩토리 인터페이스
interface ShapeFactory {
  Shape createShape();
}

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

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

// 클라이언트 코드
public class FactoryPatternExample {
  public state void main(String[] args) {
    // 원을 생성하는 팩토리를 이용해 도형 생성
    ShapeFactory circleFactory = new CircleFactory();
    Shape circle = circleFactory.createShape();
    circle.draw();
    
    // 정사각형을 생성하는 팩토리를 이용해 도형 생성
    ShapeFactory squareFactory = new SquareFactory();
    Shape square = squareFactory.createShape();
    square.draw();
  }
}

싱글톤 패턴

• 하나의 인스턴스만을 갖도록 보장

public class Singleton {
  private static Singleton intstance;
  // 외부에서 생성할 수 없도록 생성자 private
  private Singleton() {}
  
  // 오직 생성자는 getInstance()를 통해 가져갈 수 있도록 메서드 제공
  public static Singleton getInstance() {
    if (instace == null) {
      instance = new Singleton();
    }
    return instacne;
  }
}

팩토리 메서드 패턴

• 객체 생성을 캡슐화

• 객체 생성을 서브 클래스에서 결정하도록 하는 것

interface Product {
  void create();
}

class ConcreteProduct implements Product {
  @Override
  public void create() {
  }
}
  
abstract class Creator {
  public abstract Product factoryMethod();
}
  
class ConcreteCreator extends Creator {
  @Override 
  public Product factoryMethod() {
    return new ConcreteProduct();
  }
} 

빌더 패턴(Builder Pattern)

• 복잡한 객체를 생성하는데 사용되는 패턴

• 객체 생성의 단계를 분리하여 복잡성을 해결

• 객체의 생성 과정을 다양한 방식으로 조합

class Product {
  private String part1;
  private String part2;
  
  public void setPart1(String part1) {
    this.part1 = part1;
  }
  
  public void setPart2(String part1) {
    this.part2 = part2;
  }
  
  @Override
  public String toString() {
    return "Product [part1=" + part1 + ", part2=" +part2 + "]";
  }
}

// 빌더 인터페이스
interface Builder {
  void buildPart1(String part1);
  void buildPart2(String part2);
  Product getResult();
}

// 구체적인 빌더 클래스
class ConcreteBuilder implements Builder {
  private Product product = new Product();
  
  @Override
  public void buildPart1(String part1) {
    product.setPart1(part1);
  }
  
  @Override
  public void buildPart2(String part2) {
    product.setPart2(part2);
  }  
  
  @Override
  public Product getResult() {
    return project
  }
}

// 순서를 변경하거나 전략 상태를 변경 ex

// 디렉터 클래스 (생성 순서를 정의)
class Director {
  public Product construct(Builder builder) {
    builder.buildPart1("Part1");
    builder.buildPart2("Part2");
    return builder.getResult();
  }
}

// 클라이언트 코드'
public class BuilderPatternExample {
  public static void main(String[] args) {
    Builder builder = new ConcreteBuilder();
    Director director = new Director();
    
    Product product = director.construct(builder);
  }
}

구조 패턴

Facade 패턴

• 여러 개의 서브시스템이나 복잡한 인터페이스를 단순화

• 클라이언트에게 더 쉽게 사용할 수 있는 인터페이스를 제공하는 패턴

• 복잡한 시스템을 단순화 인터페이스로 래핑

• 여러 서브시스템을 조합해서 뭔가 동작을 만들기엔 복잡해진다. 이럴 때 Facade 패턴을 사용

• 복잡한 여러 서브시스템을 이용해서 오퍼레이션을 만들 때 파사드 패턴을 쓴다.

// Subsystem classes
class Subsystem1 {
  public void operation1() {}
  
  public void operation2() {}
}

class Subsystem2 {
  public void operation1() {}
  
  public void operation2() {}
}

// Facade class
class Facade {
  private Subsystem1 subsystem1;
  private Subsystem2 subsystem2;
  private Subsystem3 subsystem3;
  
  public Facade() {
    this.subsystem1 = new SubSystem1();
    this.subsystem2 = new SubSystem2();
    this.subsystem3 = new SubSystem3();
  }
  
  // Methods that simplify complex operations
  public void operationA() {
    System.out.println('Facde Operation A");
    subsystem1.operation1();
    subsystem2.operation1();
    subsystem3.operation1();
  }
}

// Exmplae
public class FacadePatternExample {
  public static void main(String[] args) {
    Facade facade = new Facade();
    
    // Use the Facade to simplify operations
    facade.operationA();
    facade.operationB();
  }
}

Proxy 패턴

• 객체의 접근이나 조작을 중간에서 제어하거나 보조할 때 사용

• 객체의 대리자나 대변자 역할을 하는 객체를 사용

• 실제 객체에 대한 접근을 중간에서 제어하거나 중간에서 부가적인 작업을 수행하는 패턴

• 중간에 대리자가 낀 형태

• 중간에서 하는 일은 없지만 어떤 동작에 대해서 위임 받은 객체에 전달

• 로깅 및 속도 측정, 접근 제어 등 부가적인 별도 동작을 할때 사용

interface Image {
  void display();
}

class RealImage implements Image {
  private String filename;
  
  public RealImage(String filename) {
    this.filename = filename;
    loadImageFromDisk();
  }
  
  private void loadImageFromDisk() {}
  
  @Override
  public void display() {}
}

// 이미지의 프록시 클래스
// 실질적인 동작은 구현되지 않음
class ProxyImage implements Image {
  private RealImage realImage;
  private String filename;
  
  public ProxyImage(String filename) {
    this.filename = filename;
  }
  
  @Override
  public void display() {
    if (realImage == null) {
      realImage = new RealImage(filename);
    }
    realImage.display();
  }
}

// 클라이언트 코드
public class ProxyPatternExample {
  public static void main(String[] args) {
    // 프록시를 사용하여 이미지 로딩 및 표시
    Image image = new ProxyImage("example.jpg");
    
    // 이미지가 처음으로 표시될 때 실제 이미지가 로딩되는 것을 확인할 수 있음
    image.display();
    
    // 이미지가 이미 로딩된 경우에는 실제 이미지를 다시 로딩하지 않음
    image.dispaly();
  }
}

행동 패턴

전략 패턴(Strategy Pattern)

• 알고리즘이나 행위를 정의하고, 각각을 캡슐화

• 알고리즘의 변경에 따른 영향을 최소화

• 동적으로 알고리즘을 선택

• 알고리즘이나 행위(전략)을 주입하여 교체하기 쉽게 만드는 것

// 전략 인터페이스
interface SortingStrategy {
  void sort(int[] array);
}

// 구체적인 전략 클래스 - 버블 정렬
class BubbleSortStrategy implements SortingStrategy {
  @Override
  public void sort(int[] array) {
  //실제 버블 정렬 알고리즘 구현
  }
}

// 구체적인 전략 클래스 - 퀵 정렬
class QuickSortStrategy implements SortingStrategy {
  @Override
  public void sort(int[] array) {
  //실제 퀵 정렬 알고리즘 구현
  }
}

// 컨텍스트 클래스
class SortContext {
  private SortingStrategy sortingStrategy;
  
  public void setSortingStrategy(SortingStrategy sortingStrategy) {
    this.sortingStrategy = sortingStrategy;
  }
  
  public void performSort(int[] array) {
    sortingStrategy.sort(array);
  }
}

// 클라이언트 코드
public class StrategyPatternExample {
  public static void main(String[] args) {
    int[] arrayToSort = {5, 2, 8, 1, 7};
    
    SortContext sortContext = new SortContext();
    
    // 첫 번째 정렬: 버블
    SortContext.setSortingStrategy(new BubbleSortStrategy());
    sortContext.performSort(arrayToSort);
    
    
    // 두 번째 정렬: 퀵
    SortContext.setSortingStrategy(new QuickSortStrategy());
    sortContext.performSort(arrayToSort);
  }
}

옵저버 패턴

• 어떤 객체의 상태가 변경될 때 종속 객체들이 자동으로 알림을 받는다.

• 객체들에게 알리기

// Observer interface
interface Observer {
  void update(String message);
}

// ConcreteObserver class
class ConcreteObserver implements Observer {
  private String name;
  
  public ConcreteObserver(String name) {
    this.name = name;
  }
  
  @Override
  public void update(String message) {
    System.out.println(name + " received message: " + message);
  }
}

// Subject class
class Subject {
  private List<Observer> observers = new ArrayList<>();
  
  // Add an observer to the list
  public void addObserver(Observer observer) {
    observers.add(observer);
  }
  
  // Remove an observer from the list
  public void removeObserver(Observer observer) {
    observers.remove(observer);
  }
  
  // Notify all observers with a message
  public void notifyObservers(String message) {
    for (Observer observer : observers) {
      observer.update(message);
    }
  }
}

// Example usage
public class ObserverPatternExample {
  public static void main(String[] args){
    // Create subject
    Subject subject = new Subject();
    
    // Create observers
    Observer observer1 = new ConcreteObserver("Observer 1");
    Observer observer2 = new ConcreteObserver("Observer 2");
    
    // Register observers with the subject
    subject.notifyObservers("Hello Observers!");
    
    // Unregister observer1
    subject.removeObserver(observer1);
    
    // Notify remaining observer with another message
    subject.notifiyObservers("Observer 1 has been removed.");
  }
}