🎨 01. 디자인 패턴 소개와 전략 패턴

🦆 오리 시뮬레이션 게임

SimUDuck이라는 오리 시뮬레이션 게임은 헤엄도 치고, 꽥꽥 소리도 내는 다양한 오리가 등장한다. 이 시스템을 처음 디자인한 사람은 표준 객체지향 기법을 사용해 Duck이라는 슈퍼클래스를 만든 다음, 클래스를 확장해 서로 다른 오리를 만들었다.

// Duck (슈퍼클래스)

quack() // 꽥꽥 소리를 냄
swim() // 헤엄을 칠 수 있음
display() // 모든 오리의 모양이 다르므로 추상 메소드

그런데 갑자기 오리를 날게 하라는 요구사항이 추가되었다.

// Duck (슈퍼클래스)

quack() // 꽥꽥 소리를 냄
swim() // 헤엄을 칠 수 있음
display() // 모든 오리의 모양이 다르므로 추상 메소드
fly() // 추가!!!

Duck이라는 슈퍼클래스에 fly() 메소드를 추가하면서 적합하지 않은 일부 서브클래스(고무 오리 등)에도 fly()가 추가된 것이다. 코드의 일부분만 고쳤는데, 프로그램 전체에 고무 오리가 날아다니는 오류가 발생했다.

// RubberDuck

quack() // 꽥꽥 소리를 냄
swim() // 헤엄을 칠 수 있음
display() // 모든 오리의 모양이 다르므로 추상 메소드
fly() {
// 아무것도 하지 않도록 오버라이드
}

그래서 결국 고무 오리 클래스에서는 날지 않도록 fly 메소드를 오버라이드 해 주었다. 그런데 임원진이 앞으로 6개월마다 제품을 업데이트하기로 결정했다. 앞으로 규격이 계속 바뀌게 된다면? Duck의 서브클래스인 fly()와 quack() 메소드를 일일이 상황에 따라 오버라이드 해야 한다.

🦆 상속의 단점

• 서브클래스에서 코드가 중복된다.
• 실행 시 특징을 바꾸기 힘들다.
• 모든 오리의 행동을 알기 힘들다.
• 코드를 변경했을 때 다른 오리들에게 원치 않은 영향을 끼칠 수 있다.

🦆 인터페이스 설계하기

fly()를 Duck 슈퍼클래스에서 빼고 fly() 메소드가 들어있는 Flyable 인터페이스를 만들 수 있다. 날 수 있는 오리에게만 그 인터페이스를 구현해서 fly() 메소드를 넣을 수 있다. 같은 방법으로 Quackable이라는 인터페이스를 통해 꽥꽥거리는 오리를 구현할 수도 있다.

그러나 Flyable, Quackable을 구현해 일부 문제를 해결할 수는 있겠으나, 코드를 재사용하지 않으므로 코드 관리에 커다란 문제가 생긴다.

• 날 수 있는 오리 중에서도 날아다니는 방식이 서로 다를 수 있음
• 소프트웨어를 고칠 때 기존 코드에 미치는 영향을 최소한으로 줄이면서 작업할 수 있는 방법이 있다면?

🦆 문제를 명확하게 파악하기

상속의 경우 서브클래스마다 오리의 행동이 바뀔 수 있는데도 모든 서브클래스에서 한 가지 행동만 사용하도록 하는 것은 그리 올바르지 못하다.

인터페이스의 경우 자바 인터페이스에는 구현된 코드가 없으므로 코드를 재사용할 수 없다는 문제점이 있다. 즉, 한 가지 행동을 바꿀 때마다 그 행동이 정의되어 있는 서로 다른 서브클래스를 전부 찾아서 코드를 일일이 고쳐야 하고, 그 과정에서 새로운 버그가 생길 가능성도 있다.

디자인 원칙
애플리케이션에서 달라지는 부분을 찾아내고, 달라지지 않는 부분과 분리한다.

바뀌는 부분은 따로 뽑아서 캡슐화한다. 그러면 나중에 바뀌지 않는 부분에는 영향을 미치지 않고 그 부분만 고치거나 확장할 수 있다.

🦆 바뀌는 부분과 그렇지 않은 부분 분리하기

Duck 클래스는 잘 작동하고 있으며, 자주 달라지거나 바뀌지 않으므로 그대로 둔다.

변화하는 부분과 그대로 있는 부분을 분리하려면 2개의 클래스 집합(set)을 만들어야 한다. 하나는 나는 것과 관련된 부분이고, 다른 하나는 꽥꽥거리는 것과 관련된 부분이다. 각 클래스 집합에는 각각의 행동을 구현한 것을 전부 집어넣는다.

fly()와 quack()은 Duck 클래스에 있는 오리 종류에 따라 달라지는 부분이다.

fly()와 quack()을 Duck 클래스로부터 분리하려면 2개의 메소드를 모두 Duck 클래스에서 끄집어내서 각 행동을 나타낼 클래스 집합을 새로 만들어야 한다.

🦆 오리의 행동을 디자인하는 방법

• 최대한 유연하게 만든다.
• Duck의 인스턴스에 행동을 할당할 수 있어야 한다.
  • MallardDuck 인스턴스를 새로 만들고 특정 형식의 나는 행동으로 초기화하는 방법
  • 오리의 행동을 동적으로 바꾼다. 즉, Duck 클래스에 행동과 관련된 세터 메소드를 포함해서 프로그램 실행 중에도 MallardDuck의 나는 행동을 바꿀 수 있다.

디자인 원칙
구현보다는 인터페이스에 맞춰서 프로그래밍한다.

각 행동은 FlyBehavior, QuackBehavior로 표현한다. 특정 행동은 Duck 클래스에서 구현하지 않고, 행동을 목적으로 하는 클래스의 집합을 만든다. 새로운 디자인을 사용하면 Duck 서브클래스는 인터페이스(FlyBehavior, QuackBehavior)로 표현되는 행동을 사용한다.

“인터페이스에 맞춰서 프로그래밍한다.” 라는 말은 사실 “상위 형식에 맞춰서 프로그래밍한다.” 라는 말입니다.

인터페이스는 중의적 의미로 쓰였다.

• 자바의 구조
• 인터페이스 개념 지칭

인터페이스에 맞춰서 프로그래밍한다. ⇒ 실제 실행 시에 쓰이는 객체가 코드에 고정되지 않도록 상위 형식에 맞춰 프로그래밍해서 다형성을 활용하라.

상위 형식에 맞춰서 프로그래밍한다. ⇒ 변수를 선언할 때 보통 추상 클래스나 인터페이스 같은 상위 형식으로 선언하라. ⇒ 객체를 변수에 대입할 때 상위 형식을 구체적으로 구현한 형식이라면 어떤 객체든 넣을 수 있기 때문이다.

Dog d = new Dog();
d.bark();

변수 d를 Dog 형식으로 선언하면 구체적인 구현에 맞춰서 코딩해야 한다. 하지만 인터페이스와 상위 형식에 맞춰서 프로그래밍한다면 다음과 같이 할 수 있다.

Animal animal = new Dog();
animal.makeSound();

Dog라는 걸 알고 있긴 하지만 다형성을 활용해서 Animal의 레퍼런스를 써도 된다. 더 바람직한 방법은 상위 형식의 인스턴스를 만드는 과정을 직접 코드로 만드는 대신 구체적으로 구현된 객체를 실행 시에 대입하는 것이다.

a = getAnimal();
a.makeSound();

우린 animal이 어떤 하위 클래스인지 몰라도 makeSound()를 동작하는 데에 아무 문제가 없다.

🦆 오리의 행동을 구현하는 방법

이런 식으로 디자인하면 다른 형식의 객체에서도 나는 행동과 꽥꽥거리는 행동을 재사용할 수 있다. 로켓 추친력으로 날아가는 행동을 추가하려면 FlyBehavior를 상속받는 FlyRocketPowered 클래스를 만들면 되고, 오리 소리를 내는 장치 클래스를 새로 만든다면 Quack을 활용할 수도 있다.

🦆 오리 행동 통합하기

가장 중요한 점은 나는 행동과 꽥꽥거리는 행동을 Duck 클래스에서 정의한 메소드를 써서 구현하지 않고 다른 클래스에 위임한다는 것이다.

1. 우선 Duck 클래스에 flyBehavior와 quackBehavior라는 인터페이스 형식의 인스턴스 변수를 추가한다. 각 오리 객체에서는 실행 시에 이 변수에 특정 행동 형식의 레퍼런스를 다형적으로 설정한다. 나는 행동과 꽥꽥거리는 행동은 인터페이스로 분리했으므로 Duck 클래스와 모든 서브클래스에서 fly()와 quack() 메소드는 제거한다. Duck 클래스에 fly()와 quack() 대신 performFly()와 performQuack()라는 메소드를 넣는다.

// 1. 날기 행동을 위한 인터페이스
interface FlyBehavior {
    void fly();
}

// 2. 꽥꽥거리는 행동을 위한 인터페이스
interface QuackBehavior {
    void quack();
}

// 3. 실제 날기 행동들 (전략)
class FlyWithWings implements FlyBehavior {
    public void fly() {
        System.out.println("퍼덕퍼덕");
    }
}

class FlyNoWay implements FlyBehavior {
    public void fly() {
        System.out.println("새장 안에 갇힌 새");
    }
}

// 4. 실제 꽥꽥거리는 행동들 (전략)
class Quack implements QuackBehavior {
    public void quack() {
        System.out.println("꽥꽥");
    }
}

class MuteQuack implements QuackBehavior {
    public void quack() {
        System.out.println("...");
    }
}

// 5. Duck 클래스 (행동을 캡슐화하여 참조)
abstract class Duck {
    FlyBehavior flyBehavior;
    QuackBehavior quackBehavior;

    public void performFly() {
        flyBehavior.fly();
    }

    public void performQuack() {
        quackBehavior.quack();
    }

    public abstract void display();
}

1. MallardDuck 클래스 통해 flyBehavior와 quackBehavior 인스턴스 변수 설정 방법을 생각해 보자.
   1. MallardDuck의 인스턴스가 만들어질 때 생성자는 Duck으로 부터 상속받은 quackBehavior 인스턴스 변수에 Quack 형식의 새로운 인스턴스를 대입한다.
   2. MallardDuck의 생성자는 flyBehavior 인스턴스 변수에 FlyWithWings 형식의 인스턴스를 만들어서 대입한다.

// 6. 특정 오리 클래스 (행동을 동적으로 설정 가능)
class MallardDuck extends Duck {
    public MallardDuck() {
        flyBehavior = new FlyWithWings();
        quackBehavior = new Quack();
    }

    public void display() {
        System.out.println("나는 물오리");
    }
}

🦆 두 클래스를 합치는 방법

디자인 원칙
상속보다는 구성을 활용한다.

“A에는 B가 있다.”

각 오리에는 flyBehavior와 quackBehavior가 있으며, 각각 나는 행동과 꽥꽥거리는 행동을 위임받는다. 이런 식으로 두 클래스를 합치는 것을 “구성(composition)을 이용한다.” 라고 부른다. 구성을 활용해서 시스템을 만들면 유연성을 크게 향상시킬 수 있다.

🦆 전략 패턴

지금까지 적용한 것들이 바로 전략 패턴(Strategy Pattern)이다. 전략 패턴은 알고리즘군을 정의하고 캡슐화해서 각각의 알고리즘군을 수정해서 쓸 수 있게 해 준다. 전략 패턴을 사용하면 클라이언트로부터 알고리즘을 분리해서 독립적으로 변경할 수 있으므로 코드 재사용성과 유연성이 뛰어나다.