디자인 패턴

1. 개요

2. 역사

3. 생성 패턴(추상 객체 인스턴스화)

3.1. 추상 팩토리(Abstract Factory)

3.2. 팩토리 메서드(Factory Method)

#!syntax java
class Unit {
    Unit() {
        //생성자
    }
   //이하 유닛의 메소드들
}

#!syntax java
class Marine extends Unit {
    Marine() {
        //생성자
    }
    //이하 마린의 메소드들
}

#!syntax java
class Firebat extends Unit {
    Firebat() {
        //생성자
    }
    //이하 파이어뱃의 메소드들
}

#!syntax java
class Map {
    Map(File mapFile) {
        while(mapFile.hasNext() == true) {
            String[] unit = mapFile.getNext();
            if(unit[0].equals("Marine")) {
                Marine marine = new Marine(unit);
            } else if(unit[0].equals("Firebat")) {
                Firebat firebat = new Firebat(unit);
            }
           //기타 유닛의 생성자들
       }
       //유닛 초기화 이후 코드
    }
}

#!syntax java
class UnitFactory {
    static Unit create(String[] data) {
        if(data[0].equals("Marine")) {
            return new Marine(data);
        } else if(data[0].equals("Firebat")) {
            return new Firebat(data);
        }
       //기타 유닛의 생성자들
    }
}

#!syntax java
class Map {
    Map(File mapFile) {
        while(mapFile.hasNext() == true) {
            Unit unit = UnitFactory.create(mapFile.getNext());
       }
       //유닛 초기화 이후 코드
    }
}

• 상속을 막고 싶은데 final 키워드가 직접 지원되지 않는 언어 버전임
• 생성 객체의 총수를 제한하고 싶음
• 생성 도중에 C++ 예외가 터지기 때문에 생성자에 초기화 코드를 넣기 곤란한 경우 [6]
• 생성 과정에 다른 객체를 참조해서 생성 순서를 조절해야 하는 경우
• 생성 직후 반환값을 사용해서 계산하는 게 주 업무인 객체임
• 생성되는 객체의 구체적인 타입을 숨기거나 도중에 바꾸고 싶은 경우(라이브러리 등)
• 객체 생성이 확실하지 않은 연산 과정의 캡슐화

3.3. 빌더(Builder)

#!syntax java
class Something {

    private Something(int number, String name, double size) {
        //Something 클래스 초기화
    }

    public static class Builder {
        int number=0;
        String name=null;
        double size=0d;

        public Builder() {
            //Builder 초기화
        }

        public Builder setNumber(int number) {
            this.number = number;
            return this;
        }

        public Builder setName(String name) {
            this.name = name;
            return this;
        }

        public Builder setSize(double size) {
            this.size = size;
            return this;
        }

        public Something build() {
            return new Something(number, name, size);
        }
    }
}

#!syntax java
public void createSomething() {
    Something something = new Something.Builder().setNumber(number).setName(name).setSize(size).build();
}

• 클래스와 사용 대상의 결합도를 낮추기 위해

• 생성자에 전달하는 인수에 의미를 부여하기 위해

3.4. 프로토타입

1. Prototype 인터페이스: 객체를 복제하는 메서드를 정의한다.
2. Concrete Prototype 클래스: Prototype 인터페이스를 구현하며, clone() 메서드를 통해 자신을 복제할 수 있다.

#!syntax cpp
class Prototype {
public:
    virtual Prototype* clone() const = 0;
};

class ConcretePrototype : public Prototype {
private:
    int data;
public:
    ConcretePrototype(int val) : data(val) {}
    
    Prototype* clone() const override {
        return new ConcretePrototype(*this);
    }
};

#!syntax cpp
// 스타크래프트의 저글링 유닛을 복제하는 예제
class Zergling : public Prototype {
private:
    int health;
    int attackDamage;
    int moveSpeed;

public:
    Zergling(int h, int ad, int ms) : health(h), attackDamage(ad), moveSpeed(ms) {}

    // 클론 메서드를 이용해 새로운 저글링 복제
    Prototype* clone() const override {
        return new Zergling(*this);
    }

    void showStatus() const {
        std::cout << "저글링: 체력(" << health << "), 공격력(" << attackDamage << "), 이동 속도(" << moveSpeed << ")" << std::endl;
    }
};

int main() {
    // 초기 저글링 생성
    Zergling* prototypeZergling = new Zergling(35, 5, 10);

    // 프로토타입을 이용해 여러 저글링을 복제
    Zergling* clonedZergling1 = static_cast<Zergling*>(prototypeZergling->clone());
    Zergling* clonedZergling2 = static_cast<Zergling*>(prototypeZergling->clone());

    // 상태 출력
    clonedZergling1->showStatus();
    clonedZergling2->showStatus();

    // 메모리 해제
    delete prototypeZergling;
    delete clonedZergling1;
    delete clonedZergling2;

    return 0;
}

• 장점
1. 객체 생성 비용 절감: 복잡한 초기화 과정을 거치지 않고 객체를 빠르게 생성할 수 있다.
2. 유연성: 복제된 객체는 필요에 따라 원본과 다른 값을 가질 수 있다. 예를 들어, 복제된 저글링의 특성을 부분적으로 변경할 수 있다.
• 단점
1. 깊은 복사 vs 얕은 복사 문제: 객체의 속성 중 포인터나 참조를 복사할 때 얕은 복사로 인한 오류가 발생할 수 있다. 이를 해결하기 위해 깊은 복사를 적절히 구현해야 한다.
2. 복제 비용: 복제하는 과정에서도 성능 비용이 발생할 수 있다. 특히 객체가 매우 복잡한 경우, 단순한 생성보다 복제 비용이 더 클 수 있다.

3.5. 싱글톤(Singleton)

#!syntax java
class Singleton {

    private static final Singleton instance = new Singleton();

    private Singleton() {
        // 초기화 코드
    }

    public static Singleton getInstance() {
        return instance;
    }
}

• 전역 접근성: 싱글톤 인스턴스는 프로그램 어디서든 접근할 수 있다.
• 유일한 인스턴스 보장: 클래스의 인스턴스가 하나뿐임을 보장하여, 불필요한 메모리 낭비와 자원 중복을 방지한다.
• 생성자 접근 제한: 싱글톤 클래스의 생성자는 private으로 선언되어 외부에서 새로운 인스턴스를 생성하지 못하도록 제한된다.

• 사전 초기화(Eager Initialization): 클래스가 로드될 때 즉시 인스턴스를 생성하는 방식이다. 이 방식은 멀티스레드 환경에서 안전하며, 이중 객체 생성 문제를 방지할 수 있다. 다만, 인스턴스를 실제로 사용하지 않더라도 메모리가 할당되는 단점이 있다. 자바에서 사전 초기화의 예시는 다음과 같다.

#!syntax java
class Singleton {

    private static final Singleton instance = new Singleton();

    private Singleton() {
        // 초기화 코드
    }

    public static Singleton getInstance() {
        return instance;
    }
}

• 사후 초기화(Lazy Initialization): 필요한 시점에 인스턴스를 생성하는 방식이다. 이 방법은 메모리와 자원을 효율적으로 사용할 수 있지만, 멀티스레드 환경에서는 이중 객체 생성 문제가 발생할 수 있어 주의가 필요하다. 다음은 간단한 사후 초기화의 예시이다.

#!syntax java
class Singleton {

    private static Singleton instance;

    private Singleton() {
        // 초기화 코드
    }

    public static synchronized Singleton getInstance() {
        if (instance == null) {
            instance = new Singleton();
        }
        return instance;
    }
}

• 오남용 문제

1. 상태가 없는 클래스: 속성이 없거나, 있어도 모두 읽기 전용인 경우.
2. 인스턴스 메소드가 필요한 경우: 정적 메소드가 아닌 인스턴스 메소드가 필요한 경우.

1. 추상 팩토리(Abstract Factory): 대부분의 경우 콘크리트 팩토리 클래스는 하나의 인스턴스만 필요하다.
2. 빌더(Builder): 내부 빌더 클래스에서 사용된다.
3. 프로토타입(Prototype): 콘크리트 프로토타입 클래스에서 사용된다.
4. 파사드(Facade): 파사드 클래스가 상태를 가지지 않는 경우 사용될 수 있다.

4. 구조 패턴(객체 결합)

4.1. 어댑터

4.2. 브리지

4.3. 컴포지트

4.4. 데코레이터

4.5. 파사드(Facade)

#!syntax java
public interface Shape {
   void draw();
}

#!syntax java
public class Rectangle implements Shape {

   @Override
   public void draw() {
      System.out.println("Rectangle::draw()");
   }
}

#!syntax java
public class Square implements Shape {

   @Override
   public void draw() {
      System.out.println("Square::draw()");
   }
}

#!syntax java
public class Circle implements Shape {

   @Override
   public void draw() {
      System.out.println("Circle::draw()");
   }
}

#!syntax java
public class ShapeMaker {
   private Shape circle;
   private Shape rectangle;
   private Shape square;

   public ShapeMaker() {
      circle = new Circle();
      rectangle = new Rectangle();
      square = new Square();
   }

   public void drawCircle(){
      circle.draw();
   }
   public void drawRectangle(){
      rectangle.draw();
   }
   public void drawSquare(){
      square.draw();
   }
}

#!syntax java
public class FacadePatternDemo {
   public static void main(String[] args) {
      ShapeMaker shapeMaker = new ShapeMaker();

      shapeMaker.drawCircle();
      shapeMaker.drawRectangle();
      shapeMaker.drawSquare();		
   }
}

#!syntax java
Circle::draw()
Rectangle::draw()
Square::draw()

4.6. 플라이웨이트

4.7. 프록시

5. 행위 패턴(객체 간 커뮤니케이션)

5.1. 책임 체인

5.2. 커맨드

5.3. 인터프리터

5.4. 반복자(iterator)

#!syntax csharp
List<int> list = new List<int>();
// List에 요소 추가 //

foreach(int _value in list) {
   Console.WriteLine(_value);
}

#!syntax java
for(int index=0; index<list.size(); index++) {
  list.get(index).doSomething();
}

#!syntax java
interface Iterator<E> {
  boolean hasNext();
  E next();
  void remove();
}

#!syntax java
Iterator<Object> iterator = collection.iterator();
while(iterator.hasNext() == true) {
  Object object = iterator.next();
  object.doSomething();
}

#!syntax cpp
std::list<int>list;
for(std::list<int>::iterator it = list.begin(); it != list.end(); ++it){
  (*it)=3;
}

5.5. 중재자(Mediator)

5.6. 메멘토

5.7. 옵저버(Observer)

#!syntax csharp
public class MainUI{
    public Image HPBar;
    public Image HPNumber;
    public void HPChange(int HP){ /* HPBar과 HPNumber를 HP에 맞게 수정 */}
    // 기타 여러 코드
}

public class CharacterUI{
    public Image SimpleHPBar;
    public void HPChange(int HP){ /* SimpleHPBar를 HP에 맞게 수정 */}
    // 기타 여러 코드
}

public class Player{
    private int HP;

    public MainUI mainUI;
    public CharacterUI characterUI;

    public void ChangeHPUI(){
        mainUI.HPChange(HP);
        characterUI.HPChange(HP);
    }
}

#!syntax csharp
public interface Subject{
    public void AddObserver(Observer ops);
    public void RemoveObserver(Observer ops);
    public void NotifyToObserver();
}

public interface Observer{
    public void Notified(int nowHP);
}

#!syntax csharp
public class MainUI : Observer{
    public Image HPBar;
    public Image HPNumber;
    public void Notified(int HP){ /* HPBar과 HPNumber를 HP에 맞게 수정 */}
    // 기타 여러 코드
}

public class CharacterUI : Observer{
    public Image SimpleHPBar;
    public void Notified(int HP){ /* SimpleHPBar를 HP에 맞게 수정 */}
    // 기타 여러 코드
}

#!syntax csharp
public class Player : Subject{
    private int HP;
    private List<Observer> observers = new List<Observer>(); // 이 서브젝트가 관리 중인 오브젝트의 목록

    public AddObserver(Observer ops){
        observers.Add(ops);
    } // 옵저버 리스트에 옵저버 추가하기

    public RemoveObserver(Observer ops){
        if (observers.IndexOf(ops) > 0) { observers.Remove(ops); }
    } // 옵저버 리스트에 그 옵저버가 있으면 옵저버 빼기

    public NotifyToObserver(){
        foreach (Observer ops in observers) { ops.Notified(HP); }
    } // 옵저버 리스트의 모든 옵저버에게, 현재 HP를 매개 변수로 하여 전달
}

5.7.1. 발행-구독(Publisher-Subscriber)

5.8. 상태(State)

#!syntax csharp
enum OvenState{
    default = 0,
    stop,
    pause,
    run
}

public class micro_oven{
    private int ovenCount;
    private OvenState ovenState;

    public void onButton(){
         switch(ovenState){
            case OvenState.stop:
                ovenState = OvenState.run;
                ovenCount += 30;
                break;
            case OvenState.pause:
                ovenState = OvenState.run;
                break;
            case OvenState.run:
                ovenCount += 30;
                break;
        }
    }
    public void offButton(){
         switch(ovenState){
            case OvenState.stop:
                break;
            case OvenState.pause:
                ovenState = OvenState.stop;
                break;
            case OvenState.run:
                ovenState = OvenState.pause;
                break;
        }
    }

}

#!syntax csharp
interface OvenState{
    void onButton();
    void offButton();
}

#!syntax csharp
public class StopState : OvenState{
    public MicroOven microOven;
    public StopState(MicroOven microOven){
        this.microOven = microOven;
    } // 오븐의 상태를 표시해 줄 MicroOven을 생성자에 추가

    public override void onButton(){
        microOven.ovenCount += 30;
        microOven.ovenState = microOven.RunState;
    }
    public override void offButton(){
        microOven.ovenState = microOven.StopState;
    }
}

public class PauseState : OvenState{
    // 생성자는 동일
    public override void onButton(){
        microOven.ovenState = microOven.RunState;
    }
    public override void offButton(){
        microOven.ovenState = microOven.StopState;
    }
}

public class RunState : OvenState{
    // 생성자는 동일
    public override void onButton(){
        microOven.ovenCount += 30;
    }
    public override void offButton(){
        microOven.ovenState = microOven.PauseState;
    }
}

#!syntax csharp
public class MicroOven{
    public readonly State StopState;
    public readonly State PauseState;
    public readonly State RunState;

    public MicroOven(){
        this.StopState = new StopState(this);
        this.PauseState = new PauseState(this);
        this.RunState = new RunState(this);
    } // 각 State를 의미하는 변수를 처음 생성할 때 고정

    private State ovenState;
    private float ovenCount;

    public void onButton(){ ovenState.onButton(); }
    public void offButton(){ ovenState.offButton(); }
}

5.9. 전략(Strategy)

5.9.1. 예시

• WASD로 플레이어의 움직임을 조작하고, 마우스 좌 클릭을 사용하면 공격을 한다.
• 플레이어는 '칼'과 '권총'이라는 두 개의 무기를 갖고 있다.
• 칼을 장비할 경우 마우스 좌 클릭을 하면 칼을 휘두른다.
• 총을 장비할 경우 마우스 좌 클릭을 하면 총을 발사한다.

#!syntax csharp
public abstract class Weapon{
    public abstract void attack();
}

public class Knife : Weapon{
    public override void attack(){ /* 칼을 휘두른다. */ }
}

public class Pistol : Weapon{
    public override void attack(){ /* 권총을 쏜다. */ }
}

#!syntax csharp
public abstract class Weapon{
    public abstract void attack();
}

public class Knife : Weapon{
    public override void attack(){ /* 칼을 휘두른다. */ }
}

public class Pistol : Weapon{
    public override void attack(){ /* 권총을 쏜다. */ }
}

public class Snipe : Weapon{
    public override void attack(){ /* 저격 총을 쏜다. */ }
    public override void rightclick(){ /* 조준경으로 확대해서 본다. */ }
}

5.9.1.1. 전략 패턴이 아닌 해결책과 문제점

#!syntax csharp
public abstract class Weapon{
    public abstract void attack();
    public abstract void rightclick();
}

public class Knife : Weapon{
    public override void attack(){ /* 칼을 휘두른다. */ }
    public override void rightclick(){ /* 아무 일도 일어나지 않는다. */ }
}

public class Pistol : Weapon{
    public override void attack(){ /* 권총을 쏜다. */ }
    public override void rightclick(){ /* 아무 일도 일어나지 않는다. */ }
}

public class Snipe : Weapon{
    public override void attack(){ /* 저격 총을 쏜다. */ }
    public override void rightclick(){ /* 조준경으로 확대해서 본다. */ }
}

#!syntax csharp
public abstract class Weapon{
    public abstract void attack();
    public abstract void rightclick();
    public abstract void Rclick();
    public abstract void Qclick();
    public abstract void Eclick();
}

public class Knife : Weapon{
    public override void attack(){ /* 칼을 휘두른다. */ }
    public override void rightclick(){ /* 아무 일도 일어나지 않는다. */ }
    public override void Rclick(){ /* 아무 일도 일어나지 않는다. */ }
    public override void Qclick(){ /* 아무 일도 일어나지 않는다. */ }
    public override void Eclick(){ /* 아무 일도 일어나지 않는다. */ }
    // 아무 기능도 안 쓰는 Knife는 쓰지도 않을 기능이 추가될 때마다 온갖 더미 함수를 뒤집어쓰게 된다.
}

#!syntax csharp
public abstract class WeaponL{
    public abstract void clickL();
}

public abstract class WeaponR{
    public abstract void clickR();
}

public class Knife : WeaponL{
    public override void clickL(){ /* 칼을 휘두른다. */ }
}

public class Pistol : WeaponL{
    public override void clickL(){ /* 권총을 쏜다. */ }
}

public class Snipe : WeaponL, WeaponR{
    public override void clickL(){ /* 저격 총을 쏜다. */ }
    public override void clickR(){ /* 조준경으로 확대해서 본다. */ }
}

#!syntax csharp
public abstract class WeaponL{
    public abstract void clickL();
}

public abstract class WeaponR{
    public abstract void clickR();
}

public abstract class WeaponWASD{
    public abstract void WASD();
}

public class Knife : WeaponL, WeaponWASD{
    public override void clickL(){ /* 칼을 휘두른다. */ }
    public override void WASD(){ /* 방향키대로 움직인다. */ }
}

public class Pistol : WeaponL, WeaponWASD{
    public override void clickL(){ /* 권총을 쏜다. */ }
    public override void WASD(){ /* 방향키대로 움직인다. */ }
}

public class Snipe : WeaponL, WeaponR{
    public override void clickL(){ /* 저격 총을 쏜다. */ }
    public override void clickR(){ /* 조준경으로 확대해서 본다. */ }
}

#!syntax csharp
public class Weapon{
    public virtual void clickL(){ /* 총을 쏜다. */ };
}

public class WeaponNormal : Weapon{
    public virtual void WASD(){ /* 방향키대로 움직인다. */ };
}

public class WeaponRifles : Weapon{
    public virtual void clickR(){ /* 줌 인을 한다. */ }
}

public class Knife : WeaponNormal{
    public override void clickL(){ /* 칼을 휘두른다. */ }
    // 부모 class의 WASD()를 그대로 상속받음.
}

public class Pistol : WeaponNormal{
    public override void clickL(){ /* 권총을 쏜다. */ }
}

public class Snipe : WeaponRifles{
    public override void clickL(){ /* 저격 총을 쏜다. */ }
    // 부모 class의 clickR()을 그대로 상속받음.
}

5.9.1.2. 전략 패턴을 활용한 코딩

#!syntax csharp
public interface LeftClick{
    public void left();
}

public interface RightClick{
    public void right();
}

public interface WASD{
    public void wasd();
}

#!syntax csharp
public class KnifeLeft : LeftClick{
    public override void left(){ /* 칼로 벤다. */ };
}

public class PistolLeft : LeftClick{
    public override void left(){ /* 권총을 쏜다. */ };
}

public class SnipeLeft : LeftClick{
    public override void left(){ /* 저격 총을 쏜다. */ };
}

public class ZoomRight : RightClick{
    public override void right(){ /* 줌 인을 한다. */ };
}

public class NothingRight : RightClick{
    public override void right(){ /* 아무 일도 없다. */ };
}

public class WASDMovable : WASD{
    public override void wasd(){ /* 방향키대로 움직인다. */ };
}

public class WASDUnmovable : WASD{
    public override void wasd(){ /* 움직이지 못한다. */ };
}

#!syntax csharp
public class Weapon{
    public LeftClick leftStrategy;
    public RightClick rightStrategy;
    public WASD wasdStrategy;
    
    public void left(){ leftStrategy.left(); }
    public void right(){ rightStrategy.right(); }
    public void wasd(){ wasdStrategy.wasd(); }
}

#!syntax csharp
public class Knife : Weapon{
    public Knife(){
        leftStrategy = new KnifeLeft();
        rightStrategy = new NothingRight();
        wasdStrategy = new WASDMovable();
    }
}
public class Pistol : Weapon{
    public Pistol(){
        leftStrategy = new PistolLeft();
        rightStrategy = new NothingRight();
        wasdStrategy = new WASDMovable();
    }
}
public class Snipe : Weapon{
    public Snipe(){
        leftStrategy = new SnipeLeft();
        rightStrategy = new ZoomRight();
        wasdStrategy = new WASDUnmovable();
    }
}

#!syntax csharp
public class Player{
    public readonly Knife knife;
    public readonly Pistol pistol;
    public readonly Snipe snipe;

    public Weapon nowWeapon;

    public Player(){
        knife = new Knife();
        pistol = new Pistol();
        snipe = new Snipe();

        nowWeapon = knife;
    }

    public void left(){ nowWeapon.left(); }
    public void right(){ nowWeapon.right(); }
    public void wasd(){ nowWeapon.wasd(); }
}

#!syntax csharp
public class Pistol : Weapon{
    public Pistol(){
        leftStrategy = new PistolLeft();
        rightStrategy = new NothingRight();
        //wasdStrategy = new WASDMovable();
        wasdStrategy = new WASDUnmovable();
    }
}

#!syntax csharp
public class WASDSlowmovable : WASD{
    public override void wasd(){ /* 방향키대로 많이 느리게 움직인다. */ };
}

public class Pistol : Weapon{
    public Pistol(){
        leftStrategy = new PistolLeft();
        rightStrategy = new NothingRight();
        //wasdStrategy = new WASDUnmovable();
        wasdStrategy = new WASDSlowmovable();
    }
}

#!syntax csharp
public class WASDMovable : WASD{
    //public override void wasd(){ /* 방향키대로 움직인다. */ };
    public override void wasd(){ /* 방향키대로 움직이는데, 좀 느린 속도로. */ };
}

#!syntax csharp
public class NothingLeft : LeftClick{
    public override void left(){ /* 아무 일도 일어나지 않는다. */ }; // 좌 클릭이 기능하지 않는 새 전략
}

public class DefenceRight : RightClick{
    public override void right(){ /* 방패를 들어 전방의 공격을 막는다. */ }; // 우 클릭으로 방어하는 새 전략
}

public class Shield : Weapon{
    public Shield(){ // 새로운 무기인 방패의 class
        leftStrategy = new NothingLeft();
        rightStrategy = new DefenceRight(); // 방패에 맞는 새 좌 클릭, 우 클릭 전략 배정
        wasdStrategy = new WASDSlowmovable(); // 이미 쓰던 전략을 재탕
    }
}

public class Player{
    public readonly Knife knife;
    public readonly Pistol pistol;
    public readonly Snipe snipe;
    public readonly Shield shield; // 클라이언트에 방패 추가해 주고

    public Weapon nowWeapon;

    public Player(){
        knife = new Knife();
        pistol = new Pistol();
        snipe = new Snipe();
        shield = new Shield(); // 선언만 해주면 끝.

        nowWeapon = knife;
    }

    public void left(){ nowWeapon.left(); }
    public void right(){ nowWeapon.right(); }
    public void wasd(){ nowWeapon.wasd(); }
}

#!syntax csharp
public interface RClick{
    public void keyboardr(); // R 키를 눌러서 발생하는 인터페이스 캡슐화
}

public class NothingR : RClick{
    public override keyboardr(){ /* 아무 일도 일어나지 않음. */ } // 미작동한다는 전략 생성
}

public class Weapon{
    public LeftClick leftStrategy;
    public RightClick rightStrategy;
    public WASD wasdStrategy;
    public RClick rStrategy; // R 키를 눌렀을 때의 전략 생성
    
    public void left(){ leftStrategy.left(); }
    public void right(){ rightStrategy.right(); }
    public void wasd(){ wasdStrategy.wasd(); }
    public void keyboardr(){ rStrategy.keyboardr(); } // 전략을 따라가도록 함수 배정
}

public class Knife : Weapon{
    public Knife(){
        leftStrategy = new KnifeLeft();
        rightStrategy = new NothingRight();
        wasdStrategy = new WASDMovable();
        rStrategy = new NothingR(); // 해당 기능을 안 쓰는 무기에 대해서는 아무것도 안 하는 전략 배정
    }
}

public class Player{
    public readonly Knife knife;
    public readonly Pistol pistol;
    public readonly Snipe snipe;
    public readonly Shield shield;

    public Weapon nowWeapon;

    public Player(){
        knife = new Knife();
        pistol = new Pistol();
        snipe = new Snipe();
        shield = new Shield();

        nowWeapon = knife;
    }

    public void left(){ nowWeapon.left(); }
    public void right(){ nowWeapon.right(); }
    public void wasd(){ nowWeapon.wasd(); }
    public void keyboardr(){ nowWeapon.keyboardr(); } // 클라이언트에서 R 키에 반응하는 함수 지정.
}

5.10. 템플릿 메소드

5.11. 방문자

6. 기타