🎭 상태 패턴(State Pattern): 객체의 상태에 따른 행동 변화를 우아하게 관리하기

🔍 상태 패턴이란?

상태 패턴(State Pattern)은 객체의 내부 상태가 변경될 때 객체의 행동을 변경할 수 있게 하는 행위 디자인 패턴입니다. 이 패턴을 사용하면 객체가 마치 클래스를 바꾼 것처럼 보이게 할 수 있습니다.

상태 패턴은 상태 머신(State Machine)의 개념을 객체 지향 방식으로 구현한 것으로, 복잡한 조건문을 제거하고 각 상태별 행동을 독립적인 클래스로 캡슐화합니다.

🏗️ 상태 패턴의 핵심 구성 요소

1. 📋 Context (컨텍스트)

• 현재 상태를 참조하는 클래스
• 클라이언트가 직접 상호작용하는 인터페이스를 제공
• 상태 변경 요청을 현재 상태 객체에 위임

2. 🎯 State (상태 인터페이스)

• 모든 구체적인 상태 클래스가 구현해야 하는 인터페이스
• 상태별로 다르게 처리될 메서드들을 정의

3. 🔧 ConcreteState (구체적인 상태)

• State 인터페이스를 구현하는 클래스들
• 각 상태에서의 구체적인 행동을 정의
• 다음 상태로의 전환 로직을 포함할 수 있음

✨ 상태 패턴을 사용하는 이유

👍 장점

• 복잡한 조건문 제거: 거대한 if-else 문이나 switch 문을 제거할 수 있습니다
• 단일 책임 원칙: 각 상태별 코드를 별도 클래스로 분리합니다
• 개방-폐쇄 원칙: 새로운 상태 추가 시 기존 코드 수정 없이 확장 가능합니다
• 유지보수성 향상: 상태별 로직이 명확하게 분리되어 이해하기 쉽습니다

👎 단점

• 클래스 수 증가: 상태마다 별도의 클래스를 생성해야 합니다
• 복잡도 증가: 간단한 상태 변화의 경우 오버엔지니어링이 될 수 있습니다

🚗 Java 예제: 자동차 상태 관리

자동차의 상태(정지, 주행, 주차)에 따라 다른 행동을 하는 예제입니다.

상태 인터페이스 정의

// 자동차 상태 인터페이스
public interface CarState {
    void start(Car car);
    void drive(Car car);
    void park(Car car);
    void stop(Car car);
    String getStateName();
}

구체적인 상태 클래스들

// 정지 상태
public class StoppedState implements CarState {
    @Override
    public void start(Car car) {
        System.out.println("🚗 엔진을 시동합니다.");
        car.setState(new DrivingState());
    }
    
    @Override
    public void drive(Car car) {
        System.out.println("❌ 먼저 시동을 걸어주세요.");
    }
    
    @Override
    public void park(Car car) {
        System.out.println("❌ 이미 정지된 상태입니다.");
    }
    
    @Override
    public void stop(Car car) {
        System.out.println("❌ 이미 정지된 상태입니다.");
    }
    
    @Override
    public String getStateName() {
        return "정지";
    }
}

// 주행 상태
public class DrivingState implements CarState {
    @Override
    public void start(Car car) {
        System.out.println("❌ 이미 시동이 걸려있습니다.");
    }
    
    @Override
    public void drive(Car car) {
        System.out.println("🏃‍♂️ 달리고 있습니다! 부릉부릉~");
    }
    
    @Override
    public void park(Car car) {
        System.out.println("🅿️ 주차합니다.");
        car.setState(new ParkedState());
    }
    
    @Override
    public void stop(Car car) {
        System.out.println("🛑 차를 멈춥니다.");
        car.setState(new StoppedState());
    }
    
    @Override
    public String getStateName() {
        return "주행";
    }
}

// 주차 상태
public class ParkedState implements CarState {
    @Override
    public void start(Car car) {
        System.out.println("🚗 주차에서 출발합니다.");
        car.setState(new DrivingState());
    }
    
    @Override
    public void drive(Car car) {
        System.out.println("❌ 먼저 주차에서 나가주세요.");
    }
    
    @Override
    public void park(Car car) {
        System.out.println("❌ 이미 주차된 상태입니다.");
    }
    
    @Override
    public void stop(Car car) {
        System.out.println("🛑 엔진을 끕니다.");
        car.setState(new StoppedState());
    }
    
    @Override
    public String getStateName() {
        return "주차";
    }
}

컨텍스트 클래스 (자동차)

// 자동차 컨텍스트 클래스
public class Car {
    private CarState currentState;
    
    public Car() {
        this.currentState = new StoppedState();
    }
    
    public void setState(CarState state) {
        this.currentState = state;
        System.out.println("🔄 상태 변경: " + state.getStateName());
    }
    
    public void start() {
        currentState.start(this);
    }
    
    public void drive() {
        currentState.drive(this);
    }
    
    public void park() {
        currentState.park(this);
    }
    
    public void stop() {
        currentState.stop(this);
    }
    
    public String getCurrentState() {
        return currentState.getStateName();
    }
}

사용 예제

public class CarStateExample {
    public static void main(String[] args) {
        Car car = new Car();
        
        System.out.println("=== 자동차 상태 패턴 테스트 ===");
        System.out.println("현재 상태: " + car.getCurrentState());
        
        // 정지 상태에서 시작
        car.drive();  // 시동을 먼저 걸어야 함
        car.start();  // 시동 걸기
        car.drive();  // 주행
        car.park();   // 주차
        car.drive();  // 주차 상태에서 운전 시도
        car.stop();   // 엔진 끄기
    }
}

🏠 TypeScript 예제: 스마트 홈 시스템

집의 상태(일반 모드, 외출 모드, 취침 모드)에 따라 다른 행동을 하는 예제입니다.

상태 인터페이스 정의

// 집 상태 인터페이스
interface HomeState {
  enterHome(home: SmartHome): void;
  leaveHome(home: SmartHome): void;
  goToBed(home: SmartHome): void;
  wakeUp(home: SmartHome): void;
  getStateName(): string;
}

구체적인 상태 클래스들

// 일반 모드 (집에 있는 상태)
class HomeMode implements HomeState {
  enterHome(home: SmartHome): void {
    console.log('❌ 이미 집에 있습니다.');
  }
  
  leaveHome(home: SmartHome): void {
    console.log('🚪 외출합니다. 보안 모드를 활성화합니다.');
    console.log('💡 모든 불을 끕니다.');
    console.log('🔒 문을 잠급니다.');
    home.setState(new AwayMode());
  }
  
  goToBed(home: SmartHome): void {
    console.log('🌙 취침 모드로 전환합니다.');
    console.log('💡 조명을 어둡게 조정합니다.');
    console.log('🔇 알림음을 무음으로 설정합니다.');
    console.log('🌡️ 온도를 수면에 적합하게 조정합니다.');
    home.setState(new SleepMode());
  }
  
  wakeUp(home: SmartHome): void {
    console.log('❌ 이미 깨어있는 상태입니다.');
  }
  
  getStateName(): string {
    return '일반 모드';
  }
}

// 외출 모드
class AwayMode implements HomeState {
  enterHome(home: SmartHome): void {
    console.log('🏠 집에 돌아왔습니다. 환영합니다!');
    console.log('💡 현관등을 켭니다.');
    console.log('🔓 문을 열고 보안 모드를 해제합니다.');
    console.log('🌡️ 온도를 쾌적하게 조정합니다.');
    home.setState(new HomeMode());
  }
  
  leaveHome(home: SmartHome): void {
    console.log('❌ 이미 외출 중입니다.');
  }
  
  goToBed(home: SmartHome): void {
    console.log('❌ 집에 있지 않습니다. 먼저 집에 들어와주세요.');
  }
  
  wakeUp(home: SmartHome): void {
    console.log('❌ 집에 있지 않습니다.');
  }
  
  getStateName(): string {
    return '외출 모드';
  }
}

// 취침 모드
class SleepMode implements HomeState {
  enterHome(home: SmartHome): void {
    console.log('❌ 이미 집에 있습니다.');
  }
  
  leaveHome(home: SmartHome): void {
    console.log('🌅 기상 후 외출합니다.');
    console.log('💡 모든 불을 끕니다.');
    console.log('🔒 문을 잠그고 보안 모드를 활성화합니다.');
    home.setState(new AwayMode());
  }
  
  goToBed(home: SmartHome): void {
    console.log('❌ 이미 취침 모드입니다.');
  }
  
  wakeUp(home: SmartHome): void {
    console.log('☀️ 좋은 아침입니다! 기상 모드로 전환합니다.');
    console.log('💡 조명을 밝게 조정합니다.');
    console.log('🔔 알림음을 활성화합니다.');
    console.log('☕ 커피 머신을 준비합니다.');
    home.setState(new HomeMode());
  }
  
  getStateName(): string {
    return '취침 모드';
  }
}

컨텍스트 클래스 (스마트 홈)

// 스마트 홈 컨텍스트 클래스
class SmartHome {
  private currentState: HomeState;
  
  constructor() {
    this.currentState = new HomeMode();
  }
  
  setState(state: HomeState): void {
    this.currentState = state;
    console.log(`🔄 상태 변경: ${state.getStateName()}`);
  }
  
  enterHome(): void {
    this.currentState.enterHome(this);
  }
  
  leaveHome(): void {
    this.currentState.leaveHome(this);
  }
  
  goToBed(): void {
    this.currentState.goToBed(this);
  }
  
  wakeUp(): void {
    this.currentState.wakeUp(this);
  }
  
  getCurrentState(): string {
    return this.currentState.getStateName();
  }
}

사용 예제

// 스마트 홈 테스트
function testSmartHome(): void {
  const home = new SmartHome();
  
  console.log('=== 스마트 홈 상태 패턴 테스트 ===');
  console.log(`현재 상태: ${home.getCurrentState()}`);
  
  // 일반 모드에서 시작
  home.goToBed();    // 취침 모드로 전환
  home.leaveHome();  // 취침 중에 외출 시도
  home.wakeUp();     // 기상
  home.leaveHome();  // 외출
  home.goToBed();    // 외출 중에 취침 시도
  home.enterHome();  // 귀가
  home.goToBed();    // 다시 취침
}

// 테스트 실행
testSmartHome();

🤔 상태 패턴 vs 전략 패턴

많은 개발자들이 상태 패턴과 전략 패턴을 혼동하는데, 두 패턴의 차이점은 다음과 같습니다:

상태 패턴 (State Pattern)

• 목적: 객체의 내부 상태에 따라 행동을 변경
• 상태 전환: 상태 객체 스스로가 다음 상태를 결정
• 의존성: 상태들이 서로를 알고 있음
• 사용 시점: 상태 머신, 게임 캐릭터, UI 컴포넌트 등

전략 패턴 (Strategy Pattern)

• 목적: 알고리즘을 런타임에 선택
• 전략 선택: 클라이언트가 전략을 선택
• 의존성: 전략들이 서로를 모름
• 사용 시점: 정렬 알고리즘, 결제 방식, 압축 방식 등

🎯 언제 상태 패턴을 사용해야 할까?

상태 패턴은 다음과 같은 상황에서 유용합니다:

1. 복잡한 조건문이 많은 경우: 객체의 상태에 따라 다른 행동을 하는 거대한 if-else 문이 있을 때
2. 상태 전환이 복잡한 경우: 여러 상태 간의 전환 규칙이 복잡할 때
3. 상태별 행동이 명확히 구분되는 경우: 각 상태에서 완전히 다른 행동을 해야 할 때
4. 상태가 자주 추가되거나 변경되는 경우: 새로운 상태를 쉽게 추가하고 싶을 때

📚 결론

상태 패턴은 복잡한 상태 관리 로직을 깔끔하게 정리할 수 있는 강력한 디자인 패턴입니다. 특히 상태 머신이 필요한 시스템에서는 필수적인 패턴이라고 할 수 있습니다.

하지만 간단한 상태 변화의 경우에는 오히려 복잡도만 증가시킬 수 있으므로, 프로젝트의 요구사항과 복잡도를 고려하여 신중하게 적용해야 합니다.

상태 패턴을 잘 활용하면 유지보수가 쉽고 확장 가능한 코드를 작성할 수 있습니다! 🚀