[타입스크립트] composition 장점을 극대화하는 강력한 interface

전 포스팅([타입스크립트] 객체지향의 꽃 composition(부제: 상속의 문제점) — My dev Note📒 (tistory.com))과 이어집니다

 

 

전 포스팅 요약 : 컴포지션을 통해서(3~4단계를 넘어가는 상속 수직 관계를 해소) 상속을 2단계 이상으로 사용하지 않고도 하나의 클래스에 여러가지 부품 클래스를 주입

헤딩 포스팅 요약 :

"강력한 interface와 composition의 복합개념이 되는 전략 패턴을 이용하여 퀄리티 높은 코드를 생산하자"

인터페이스로 하여금 필요한 기능들을 구현한 각각 클래스들을 생성, 부품으로 전달하여

사용자는 원할 때마다 같은 인터페이스를 구현한 다른 부품( 클래스)들을 끼워넣은 새로운 클래스를 찍어낼 수도 있다.

원하는 용도에 맞게 클래스들을 코드 재사용하면서 만들어낼 수 있게 된다!

여러가지 부품들을 확장성있게 코드를 재사용, 조립해나가면서 원하는 만큼 다양한 형태의 오브젝트들을 계속 만들 수 있다.(너무나 쉬운 유지보수)

 

composition으로 상속의 단계를 1단계로 낮추더라도, 코드의 재사용성이 낮다.

클래스들 간에 의사소통, 상호 작용 하는 경우에 클래스 자신을 노출하는 것이 아니라 계약서에 적힌 계약에 의거해서 의사소통 하는 것이 조금 더 확장가능하고 유연한 코드를 만드는데 좋을 것이다.

 

여기서 계약서가 바로 인터페이스가 된다. 이것이 클래스 디커플링의 단초이다.

컴포지션으로 클래스간 커플링이 강한 코드를

인터페이스를 통해서 클래스 간의 의사소통, 상호작용 할 수 있도록 하여

디커플링된 코드로 수정해보는 포스팅

 

 

 

<아래 코드 요약>

(컴포지션 방식을 도입하여 상속이 1단계로 유지되었지만 클래스 간 결합도가 높다는 문제점이 있다.

이번 포스팅에서는 강력한 인터페이스를 이용해서 클래스 간 결합도를 낮춰보도록 한다.) 

커피머신 클래스와,

커피머신 클래스를 상속받은 카페라떼머신,

커피머신 클래스를 상속받은 소금커피머신,

커피머신 클래스를 상속받은 소금카페라뗴머신.

 

 

솔트 믹서 클래스가 컴포지션이 되어 소금커피머신과 소금카페라떼머신에 소금이 추가되고,

 밀크 스팀 클래스가 컴포지션이 되어 카페라떼머신과 소금카페라떼머신에 우유폼이 추가된다.

//   //커피머신 만들기
type CoffeeCup = {
  orderShot: number;
  hasMilk?: boolean;
  hasSalt?: boolean;
};

interface CoffeeMaker {
  makeCoffee(shots: number): CoffeeCup;
}

//일반 우유 거품기//////////////////////////////////////////////////////////////////////
class CheapMilkSteamer {
  //(1)우유 거품을 만드는 내부 함수
  private steamMilk(): void {
    console.log("몽글몽글 포삭포삭한 우유폼");
  }
  //(2)만들어진 커피컵을 받아서, 만들어진 우유거품(1)을 부어서 이 커피컵을 다시 리턴하는 함수
  addMilkform(cup: CoffeeCup): CoffeeCup {
    this.steamMilk();
    return {
      ...cup,
      hasMilk: true,
    };
  }
}

//소금믹서///////////////////////////////////////////////////////////////////////////////
class SaltMixer {
  //(1)소금을 집는 내부 함수
  private getSalt() {
    console.log("소금을 한꼬집 집었다");
    return true;
  }
  //(2)만들어진 커피컵을 받아서, 집은 소금(1)을 뿌려서 이 커피컵을 다시 리턴하는 함수
  addSalt(cup: CoffeeCup): CoffeeCup {
    const salt = this.getSalt();
    return {
      ...cup,
      hasSalt: salt,
    };
  }
}
// CoffeeMaker 인터페이스를 구현하는 CoffeMachine 클래스이다.////////////////////////////
class CoffeMachine implements CoffeeMaker {
  protected static ONE_SHOT_CAPSULE: number = 3;
  protected static ONE_CUP_WATER: number = 10;

  static makeMachine(beans: number, water: number): CoffeMachine {
    return new CoffeMachine(beans, water);
  }

  public constructor(
    protected capsule: number = 3,
    protected water: number = 10
  ) {}

  makeCoffee(orderShot: number): CoffeeCup {
    this.checkMaterials(orderShot);
    console.log("캡슐쓰기 전 " + this.capsule);
    this.useCapsule(orderShot);
    console.log("물쓰기 전 " + this.water);
    this.useWater();
    this.heatWater();
    return this.extract(orderShot);
  }

  protected checkMaterials(orderShot: number) {
    if (this.capsule < orderShot * CoffeMachine.ONE_SHOT_CAPSULE) {
      throw new Error(`커피캡슐 부족!!! 현재 보유 캡슐 : ${this.capsule}`);
    }
    if (this.water < CoffeMachine.ONE_CUP_WATER) {
      throw new Error(`물 부족!!! 남은 물 ${this.water}`);
    }
  }
  clean(): void {
    console.log("커피머신 행구는 중!");
  }

  private extract(shots: number): CoffeeCup {
    return {
      orderShot: shots,
      hasMilk: false,
    };
  }
  private heatWater() {
    console.log("물 끓이는 중...");
  }

  private useCapsule(shot: number) {
    console.log("캡슐쓰러왔습니다.");
    this.capsule -= shot * CoffeMachine.ONE_SHOT_CAPSULE;
    console.log("캡슐 쓰고 난 후" + this.capsule);
  }

  protected useWater() {
    console.log("물쓰러왔습니다.");
    this.water -= CoffeMachine.ONE_CUP_WATER;
    console.log("물쓰고 난 후 " + this.water);
  }

  addCapsule(capsule: number) {
    this.capsule += capsule;
  }

  fulfillWater(water: number) {
    this.water += water;
  }

  get Water(): number {
    return this.water;
  }

  get Capsule(): number {
    return this.capsule;
  }
}

// CoffeMachine 클래스를 상속받은 CafeLatteMachine 클래스이다.\\\\\\\\\\\\\\\\\\\\\\\\\\\\

class CafeLatteMachine extends CoffeMachine {
  public constructor(
    protected capsule: number = 3,
    protected water: number = 10,
    private milkFrother: CheapMilkSteamer
  ) {
    super(capsule, water);
  }

  makeCoffee(orderShot: number): CoffeeCup {
    const coffee = super.makeCoffee(orderShot); //기본적인 캡슐 소비, 물 소비, 물 가열 다 끝나고 완성된 커피가 반환
    return this.milkFrother.addMilkform(coffee);
  }
}

// CoffeMachine 클래스 를 상속받은 saltCoffeeMachine 클래스이다.\\\\\\\\\\\\\\\\\\\\\\\\\\\
class saltCoffeeMachine extends CoffeMachine {
  public constructor(
    protected capsule: number = 3,
    protected water: number = 10,
    private saltTopping: SaltMixer
  ) {
    super(capsule, water);
  }
  makeCoffee(orderShot: number): CoffeeCup {
    const coffee = super.makeCoffee(orderShot);
    return this.saltTopping.addSalt(coffee);
  }
}

// 만들고 싶었던 saltCafeLatteCoffeeMachine 클래스이다.\\\\\\\\\\\\\\\\\\\\\\\\\\\
class saltCafeLatteCoffeeMachine extends CoffeMachine {
  public constructor(
    protected capsule: number = 3,
    protected water: number = 10,
    private saltTopping: SaltMixer,
    private milkFrother: CheapMilkSteamer
  ) {
    super(capsule, water);
  }
  makeCoffee(orderShot: number): CoffeeCup {
    const coffee = super.makeCoffee(orderShot);
    const saltAdded = this.saltTopping.addSalt(coffee);
    return this.milkFrother.addMilkform(saltAdded);
  }
}

const machines: CoffeeMaker[] = [
  new CoffeMachine(25, 25),
  new CafeLatteMachine(15, 25, new CheapMilkSteamer()),
  new saltCoffeeMachine(5, 10, new SaltMixer()),
  new saltCafeLatteCoffeeMachine(
    5,
    10,
    new SaltMixer(),
    new CheapMilkSteamer()
  ),
];

machines.forEach((machine) => {
  console.log("------------커피머신 가동~!-- ----------");
  console.log(machine.makeCoffee(1));
});

이렇게 콘솔창에 입력하면

const cheapMilkSteamer = new CheapMilkSteamer();
const saltMixer = new SaltMixer();

const saltCoffeeMaker = new saltCoffeeMachine(100, 100, saltMixer);
const saltCafeLatteMaker = new saltCafeLatteCoffeeMachine(
  100,
  100,
  saltMixer,
  cheapMilkSteamer
);
const latteMaker = new CafeLatteMachine(100, 100, cheapMilkSteamer);

const coffeMakers: CoffeeMaker[] = [
  latteMaker,
  saltCoffeeMaker,
  saltCafeLatteMaker,
];
coffeMakers.forEach((maker: CoffeeMaker) => {
  console.log("------------커피머신 가동~!-- ----------");
  console.log(maker.makeCoffee(1));
});

<출력결과>

------------커피머신 가동~!-- ----------
캡슐쓰기 전 100
캡슐쓰러왔습니다.
캡슐 쓰고 난 후97
물쓰기 전 100
물쓰러왔습니다.
물쓰고 난 후 90
물 끓이는 중...
몽글몽글 포삭포삭한 우유폼
{ orderShot: 1, hasMilk: true }
------------커피머신 가동~!-- ----------
캡슐쓰기 전 100
캡슐쓰러왔습니다.
캡슐 쓰고 난 후97
물쓰기 전 100
물쓰러왔습니다.
물쓰고 난 후 90
물 끓이는 중...
소금을 한꼬집 집었다
{ orderShot: 1, hasMilk: false, hasSalt: true }
------------커피머신 가동~!-- ----------
캡슐쓰기 전 100
캡슐쓰러왔습니다.
캡슐 쓰고 난 후97
물쓰기 전 100
물쓰러왔습니다.
물쓰고 난 후 90
물 끓이는 중...
소금을 한꼬집 집었다
몽글몽글 포삭포삭한 우유폼
{ orderShot: 1, hasMilk: true, hasSalt: true }

 

 

결과는 잘 나오지만 코드의 재사용성이 현저히 낮다.

이렇게 클래스들 간에 의사소통, 상호 작용 하는 경우에 클래스 자신을 노출하는 것이 아니라 계약서에 적힌 계약에 의거해서 의사소통 하도록하면 어떨까?

 

여기서 계약서가 바로 인터페이스가 된다. 이것이 클래스 디커플링의 단초이다.

인터페이스를 통해서 클래스 간의 의사소통, 상호작용 할 수 있도록 코드를 수정해본다.

 

 

1. 우유폼을 만드는 인터페이스와 소금을 집어서 뿌리는 인터페이스를 새로 만들어준다.

 

interface MilkFrother {
  addMilkform(cup: CoffeeCup): CoffeeCup;
}

interface SaltTopping {
  addSalt(cup: CoffeeCup): CoffeeCup;
}

 

2.  밀크 스팀 클래스와 솔트 믹서 클래스에 각각 위에서 만들어준 인터페이스를 잘 implements 해준다.

이렇게 각각 정해진 규약서(인터페이스)를 implements하고 규격 사항에 맞는 함수를 구현한 클래스가 되었다.(원래 있던 함수들임으로)

 

//일반 우유 거품기//////////////////////////////////////////////////////////////////////
class CheapMilkSteamer implements MilkFrother {
  //(1)우유 거품을 만드는 내부 함수
  private steamMilk(): void {
    console.log("몽글몽글 포삭포삭한 우유폼");
  }
  //(2)만들어진 커피컵을 받아서, 만들어진 우유거품(1)을 부어서 이 커피컵을 다시 리턴하는 함수
  addMilkform(cup: CoffeeCup): CoffeeCup {
    this.steamMilk();
    return {
      ...cup,
      hasMilk: true,
    };
  }
}

//소금믹서///////////////////////////////////////////////////////////////////////////////
class SaltMixer implements SaltTopping {
  //(1)소금을 집는 내부 함수
  private getSalt() {
    console.log("소금을 한꼬집 집었다");
    return true;
  }
  //(2)만들어진 커피컵을 받아서, 집은 소금(1)을 뿌려서 이 커피컵을 다시 리턴하는 함수
  addSalt(cup: CoffeeCup): CoffeeCup {
    const salt = this.getSalt();
    return {
      ...cup,
      hasSalt: salt,
    };
  }
}

 

3. 사용하는 것에서 직접적으로 밀크 스팀 클래스와 솔트 믹서 클래스를 받아오는 것이 아니라, 

그 자리를 인터페이스로 대체해준다.

// CoffeMachine 클래스를 상속받은 CafeLatteMachine 클래스이다.\\\\\\\\\\\\\\\\\\\\\\\\\\\\

class CafeLatteMachine extends CoffeMachine {
  public constructor(
    protected capsule: number = 3,
    protected water: number = 10,
    private milkFrother: MilkFrother
  ) {
    super(capsule, water);
  }

  makeCoffee(orderShot: number): CoffeeCup {
    const coffee = super.makeCoffee(orderShot); //기본적인 캡슐 소비, 물 소비, 물 가열 다 끝나고 완성된 커피가 반환
    return this.milkFrother.addMilkform(coffee);
  }
}

// CoffeMachine 클래스 를 상속받은 saltCoffeeMachine 클래스이다.\\\\\\\\\\\\\\\\\\\\\\\\\\\
class saltCoffeeMachine extends CoffeMachine {
  public constructor(
    protected capsule: number = 3,
    protected water: number = 10,
    private saltTopping: SaltTopping
  ) {
    super(capsule, water);
  }
  makeCoffee(orderShot: number): CoffeeCup {
    const coffee = super.makeCoffee(orderShot);
    return this.saltTopping.addSalt(coffee);
  }
}

// 만들고 싶었던 saltCafeLatteCoffeeMachine 클래스이다.\\\\\\\\\\\\\\\\\\\\\\\\\\\
class saltCafeLatteCoffeeMachine extends CoffeMachine {
  public constructor(
    protected capsule: number = 3,
    protected water: number = 10,
    private saltTopping: SaltTopping,
    private milkFrother: MilkFrother
  ) {
    super(capsule, water);
  }
  makeCoffee(orderShot: number): CoffeeCup {
    const coffee = super.makeCoffee(orderShot);
    const saltAdded = this.saltTopping.addSalt(coffee);
    return this.milkFrother.addMilkform(saltAdded);
  }
}

순식간에 클래스 간 강한 커플링이 풀렸다!

이제 클래스들은 면대면이 아니라 인터페이스를 통해서만 계약에 맞추어 의사소틍을 하게 되었다. 

 

<전체코드>

//   //커피머신 만들기
type CoffeeCup = {
  orderShot: number;
  hasMilk?: boolean;
  hasSalt?: boolean;
};

interface MilkFrother {
  addMilkform(cup: CoffeeCup): CoffeeCup;
}

interface SaltTopping {
  addSalt(cup: CoffeeCup): CoffeeCup;
}
interface CoffeeMaker {
  makeCoffee(shots: number): CoffeeCup;
}

//일반 우유 거품기//////////////////////////////////////////////////////////////////////
class CheapMilkSteamer implements MilkFrother {
  //(1)우유 거품을 만드는 내부 함수
  private steamMilk(): void {
    console.log("몽글몽글 포삭포삭한 우유폼");
  }
  //(2)만들어진 커피컵을 받아서, 만들어진 우유거품(1)을 부어서 이 커피컵을 다시 리턴하는 함수
  addMilkform(cup: CoffeeCup): CoffeeCup {
    this.steamMilk();
    return {
      ...cup,
      hasMilk: true,
    };
  }
}

//소금믹서///////////////////////////////////////////////////////////////////////////////
class SaltMixer implements SaltTopping {
  //(1)소금을 집는 내부 함수
  private getSalt() {
    console.log("소금을 한꼬집 집었다");
    return true;
  }
  //(2)만들어진 커피컵을 받아서, 집은 소금(1)을 뿌려서 이 커피컵을 다시 리턴하는 함수
  addSalt(cup: CoffeeCup): CoffeeCup {
    const salt = this.getSalt();
    return {
      ...cup,
      hasSalt: salt,
    };
  }
}
// CoffeeMaker 인터페이스를 구현하는 CoffeMachine 클래스이다.////////////////////////////
class CoffeMachine implements CoffeeMaker {
  protected static ONE_SHOT_CAPSULE: number = 3;
  protected static ONE_CUP_WATER: number = 10;

  static makeMachine(beans: number, water: number): CoffeMachine {
    return new CoffeMachine(beans, water);
  }

  public constructor(
    protected capsule: number = 3,
    protected water: number = 10
  ) {}

  makeCoffee(orderShot: number): CoffeeCup {
    this.checkMaterials(orderShot);
    console.log("캡슐쓰기 전 " + this.capsule);
    this.useCapsule(orderShot);
    console.log("물쓰기 전 " + this.water);
    this.useWater();
    this.heatWater();
    return this.extract(orderShot);
  }

  protected checkMaterials(orderShot: number) {
    if (this.capsule < orderShot * CoffeMachine.ONE_SHOT_CAPSULE) {
      throw new Error(`커피캡슐 부족!!! 현재 보유 캡슐 : ${this.capsule}`);
    }
    if (this.water < CoffeMachine.ONE_CUP_WATER) {
      throw new Error(`물 부족!!! 남은 물 ${this.water}`);
    }
  }
  clean(): void {
    console.log("커피머신 행구는 중!");
  }

  private extract(shots: number): CoffeeCup {
    return {
      orderShot: shots,
      hasMilk: false,
    };
  }
  private heatWater() {
    console.log("물 끓이는 중...");
  }

  private useCapsule(shot: number) {
    console.log("캡슐쓰러왔습니다.");
    this.capsule -= shot * CoffeMachine.ONE_SHOT_CAPSULE;
    console.log("캡슐 쓰고 난 후" + this.capsule);
  }

  protected useWater() {
    console.log("물쓰러왔습니다.");
    this.water -= CoffeMachine.ONE_CUP_WATER;
    console.log("물쓰고 난 후 " + this.water);
  }

  addCapsule(capsule: number) {
    this.capsule += capsule;
  }

  fulfillWater(water: number) {
    this.water += water;
  }

  get Water(): number {
    return this.water;
  }

  get Capsule(): number {
    return this.capsule;
  }
}

// CoffeMachine 클래스를 상속받은 CafeLatteMachine 클래스이다.\\\\\\\\\\\\\\\\\\\\\\\\\\\\

class CafeLatteMachine extends CoffeMachine {
  public constructor(
    protected capsule: number = 3,
    protected water: number = 10,
    private milkFrother: MilkFrother
  ) {
    super(capsule, water);
  }

  makeCoffee(orderShot: number): CoffeeCup {
    const coffee = super.makeCoffee(orderShot); //기본적인 캡슐 소비, 물 소비, 물 가열 다 끝나고 완성된 커피가 반환
    return this.milkFrother.addMilkform(coffee);
  }
}

// CoffeMachine 클래스 를 상속받은 saltCoffeeMachine 클래스이다.\\\\\\\\\\\\\\\\\\\\\\\\\\\
class saltCoffeeMachine extends CoffeMachine {
  public constructor(
    protected capsule: number = 3,
    protected water: number = 10,
    private saltTopping: SaltTopping
  ) {
    super(capsule, water);
  }
  makeCoffee(orderShot: number): CoffeeCup {
    const coffee = super.makeCoffee(orderShot);
    return this.saltTopping.addSalt(coffee);
  }
}

// 만들고 싶었던 saltCafeLatteCoffeeMachine 클래스이다.\\\\\\\\\\\\\\\\\\\\\\\\\\\
class saltCafeLatteCoffeeMachine extends CoffeMachine {
  public constructor(
    protected capsule: number = 3,
    protected water: number = 10,
    private saltTopping: SaltTopping,
    private milkFrother: MilkFrother
  ) {
    super(capsule, water);
  }
  makeCoffee(orderShot: number): CoffeeCup {
    const coffee = super.makeCoffee(orderShot);
    const saltAdded = this.saltTopping.addSalt(coffee);
    return this.milkFrother.addMilkform(saltAdded);
  }
}


const cheapMilkSteamer = new CheapMilkSteamer();
const saltMixer = new SaltMixer();

const saltCoffeeMaker = new saltCoffeeMachine(100, 100, saltMixer);
const saltCafeLatteMaker = new saltCafeLatteCoffeeMachine(
  100,
  100,
  saltMixer,
  cheapMilkSteamer
);
const latteMaker = new CafeLatteMachine(100, 100, cheapMilkSteamer);

const coffeMakers: CoffeeMaker[] = [
  latteMaker,
  saltCoffeeMaker,
  saltCafeLatteMaker,
];
coffeMakers.forEach((maker: CoffeeMaker) => {
  console.log("------------커피머신 가동~!-- ----------");
  console.log(maker.makeCoffee(1));
});

 

 

+ 추가 실험

 

-1 implements MilkFrother 상태인 다양한 우유 거품기들을 작성해본다.

interface MilkFrother {
  addMilkform(cup: CoffeeCup): CoffeeCup;
}


//일반 우유 거품기//////////////////////////////////////////////////////////////////////
class CheapMilkSteamer implements MilkFrother {
  //(1)우유 거품을 만드는 내부 함수
  private steamMilk(): void {
    console.log("몽글몽글 포삭포삭한 우유폼");
  }
  //(2)만들어진 커피컵을 받아서, 만들어진 우유거품(1)을 부어서 이 커피컵을 다시 리턴하는 함수
  addMilkform(cup: CoffeeCup): CoffeeCup {
    this.steamMilk();
    return {
      ...cup,
      hasMilk: true,
    };
  }
}

//치즈폼 우유 거품기//////////////////////////////////////////////////
class CheeseMilkSteamer implements MilkFrother {
  //(1)우유 거품을 만드는 내부 함수
  private steamCheeseMilk(): void {
    console.log("부드러운 치즈가 녹아든 우유폼");
  }
  //(2)만들어진 커피컵을 받아서, 만들어진 우유거품(1)을 부어서 이 커피컵을 다시 리턴하는 함수
  addMilkform(cup: CoffeeCup): CoffeeCup {
    this.steamCheeseMilk();
    return {
      ...cup,
      hasMilk: true,
    };
  }
}

//유기농 우유 거품기//////////////////////////////////////////////////
class OrganicMilkSteamer implements MilkFrother {
  //(1)우유 거품을 만드는 내부 함수
  private steamOrganicMilk(): void {
    console.log("고급 유기농 우유로 만든 우유폼");
  }
  //(2)만들어진 커피컵을 받아서, 만들어진 우유거품(1)을 부어서 이 커피컵을 다시 리턴하는 함수
  addMilkform(cup: CoffeeCup): CoffeeCup {
    this.steamOrganicMilk();
    return {
      ...cup,
      hasMilk: true,
    };
  }
}

-2 유기농우유스팀 클래스와 치즈우유스팀 클래스 생성해주고

유기농 우유와 치즈 우유를 재미나게 섞고자 하는 클래스들을 순식간에 생성해준다.(감격스러운 코드 재사용의 순간)

기존에 있는 커피머신 클래스 생성 코드를 복사 붙여넣기 한다음에 이름만 조금 바꿔주고 (코드 재사용)

개발자 원하는 부품(클래스)을 용도에 맞게 가져다 넣어주기만 하면된다.

원하는 기능들을 조립한다는 점에서 컴포지션이자, 강력한 인터페이스인 것이다.

 

const cheapMilkSteamer = new CheapMilkSteamer();
const saltMixer = new SaltMixer();
const organicMilkSteamer = new OrganicMilkSteamer();
const cheeseMilkSteamer = new CheeseMilkSteamer();

//const saltCoffeeMaker = new saltCoffeeMachine(100, 100, saltMixer);
const saltCafeLatteMaker = new saltCafeLatteCoffeeMachine(
  100,
  100,
  saltMixer,
  cheapMilkSteamer
);
const saltCheeseCafeLatteMaker = new saltCafeLatteCoffeeMachine(
  100,
  100,
  saltMixer,
  cheeseMilkSteamer
);
const saltOrganicCafeLatteMaker = new saltCafeLatteCoffeeMachine(
  100,
  100,
  saltMixer,
  organicMilkSteamer
);
const latteMaker = new CafeLatteMachine(100, 100, cheapMilkSteamer);
const cheeselatteMaker = new CafeLatteMachine(100, 100, cheeseMilkSteamer);
const organicLatteMaker = new CafeLatteMachine(100, 100, organicMilkSteamer);
const coffeMakers: CoffeeMaker[] = [
  latteMaker,
  //saltCoffeeMaker,
  saltCafeLatteMaker,
  cheeselatteMaker,
  organicLatteMaker,
  saltCheeseCafeLatteMaker,
  saltOrganicCafeLatteMaker,
];
coffeMakers.forEach((maker: CoffeeMaker) => {
  console.log("------------커피머신 가동~!-- ----------");
  console.log(maker.makeCoffee(1));
});

 

<출력 결과> 만족스러운 퍼포먼스를 보여준다.

------------커피머신 가동~!-- ----------
캡슐쓰기 전 100
캡슐쓰러왔습니다.
캡슐 쓰고 난 후97
물쓰기 전 100
물쓰러왔습니다.
물쓰고 난 후 90
물 끓이는 중...
몽글몽글 포삭포삭한 우유폼
{ orderShot: 1, hasMilk: true }
------------커피머신 가동~!-- ----------
캡슐쓰기 전 100
캡슐쓰러왔습니다.
캡슐 쓰고 난 후97
물쓰기 전 100
물쓰러왔습니다.
물쓰고 난 후 90
물 끓이는 중...
소금을 한꼬집 집었다
{ orderShot: 1, hasMilk: false, hasSalt: true }
------------커피머신 가동~!-- ----------
캡슐쓰기 전 100
캡슐쓰러왔습니다.
캡슐 쓰고 난 후97
물쓰기 전 100
물쓰러왔습니다.
물쓰고 난 후 90
물 끓이는 중...
소금을 한꼬집 집었다
몽글몽글 포삭포삭한 우유폼
{ orderShot: 1, hasMilk: true, hasSalt: true }
PS C:\Users\User\gitprogect\TsOOP> ts-node 2-tsOOP/1.ts
------------커피머신 가동~!-- ----------
캡슐쓰기 전 100
캡슐쓰러왔습니다.
캡슐 쓰고 난 후97
물쓰기 전 100
물쓰러왔습니다.
물쓰고 난 후 90
물 끓이는 중...
몽글몽글 포삭포삭한 우유폼     
{ orderShot: 1, hasMilk: true }
------------커피머신 가동~!-- ----------
캡슐쓰기 전 100
캡슐쓰러왔습니다.
캡슐 쓰고 난 후97
물쓰기 전 100
물쓰러왔습니다.
물쓰고 난 후 90
물 끓이는 중...
소금을 한꼬집 집었다
몽글몽글 포삭포삭한 우유폼
{ orderShot: 1, hasMilk: true, hasSalt: true }
------------커피머신 가동~!-- ----------
캡슐쓰기 전 100
캡슐쓰러왔습니다.
캡슐 쓰고 난 후97
물쓰기 전 100
물쓰러왔습니다.
물쓰고 난 후 90
물 끓이는 중...
부드러운 치즈가 녹아든 우유폼
{ orderShot: 1, hasMilk: true }
------------커피머신 가동~!-- ----------
캡슐쓰기 전 100
캡슐쓰러왔습니다.
캡슐 쓰고 난 후97
물쓰기 전 100
물쓰러왔습니다.
물쓰고 난 후 90
물 끓이는 중...
고급 유기농 우유로 만든 우유폼
{ orderShot: 1, hasMilk: true }
------------커피머신 가동~!-- ----------
캡슐쓰기 전 100
캡슐쓰러왔습니다.
캡슐 쓰고 난 후97
물쓰기 전 100
물쓰러왔습니다.
물쓰고 난 후 90
물 끓이는 중...
소금을 한꼬집 집었다
부드러운 치즈가 녹아든 우유폼
{ orderShot: 1, hasMilk: true, hasSalt: true }
------------커피머신 가동~!-- ----------
캡슐쓰기 전 100
캡슐쓰러왔습니다.
캡슐 쓰고 난 후97
물쓰기 전 100
물쓰러왔습니다.
물쓰고 난 후 90
물 끓이는 중...
소금을 한꼬집 집었다
고급 유기농 우유로 만든 우유폼
{ orderShot: 1, hasMilk: true, hasSalt: true }

 

 

<현재까지 전체 코드>

//   //커피머신 만들기
type CoffeeCup = {
  orderShot: number;
  hasMilk?: boolean;
  hasSalt?: boolean;
};

interface MilkFrother {
  addMilkform(cup: CoffeeCup): CoffeeCup;
}

interface SaltTopping {
  addSalt(cup: CoffeeCup): CoffeeCup;
}
interface CoffeeMaker {
  makeCoffee(shots: number): CoffeeCup;
}

//일반 우유 거품기//////////////////////////////////////////////////////////////////////
class CheapMilkSteamer implements MilkFrother {
  //(1)우유 거품을 만드는 내부 함수
  private steamMilk(): void {
    console.log("몽글몽글 포삭포삭한 우유폼");
  }
  //(2)만들어진 커피컵을 받아서, 만들어진 우유거품(1)을 부어서 이 커피컵을 다시 리턴하는 함수
  addMilkform(cup: CoffeeCup): CoffeeCup {
    this.steamMilk();
    return {
      ...cup,
      hasMilk: true,
    };
  }
}

//치즈폼 우유 거품기//////////////////////////////////////////////////
class CheeseMilkSteamer implements MilkFrother {
  //(1)우유 거품을 만드는 내부 함수
  private steamCheeseMilk(): void {
    console.log("부드러운 치즈가 녹아든 우유폼");
  }
  //(2)만들어진 커피컵을 받아서, 만들어진 우유거품(1)을 부어서 이 커피컵을 다시 리턴하는 함수
  addMilkform(cup: CoffeeCup): CoffeeCup {
    this.steamCheeseMilk();
    return {
      ...cup,
      hasMilk: true,
    };
  }
}

//유기농 우유 거품기//////////////////////////////////////////////////
class OrganicMilkSteamer implements MilkFrother {
  //(1)우유 거품을 만드는 내부 함수
  private steamOrganicMilk(): void {
    console.log("고급 유기농 우유로 만든 우유폼");
  }
  //(2)만들어진 커피컵을 받아서, 만들어진 우유거품(1)을 부어서 이 커피컵을 다시 리턴하는 함수
  addMilkform(cup: CoffeeCup): CoffeeCup {
    this.steamOrganicMilk();
    return {
      ...cup,
      hasMilk: true,
    };
  }
}

//소금믹서///////////////////////////////////////////////////////////////////////////////
class SaltMixer implements SaltTopping {
  //(1)소금을 집는 내부 함수
  private getSalt() {
    console.log("소금을 한꼬집 집었다");
    return true;
  }
  //(2)만들어진 커피컵을 받아서, 집은 소금(1)을 뿌려서 이 커피컵을 다시 리턴하는 함수
  addSalt(cup: CoffeeCup): CoffeeCup {
    const salt = this.getSalt();
    return {
      ...cup,
      hasSalt: salt,
    };
  }
}
// CoffeeMaker 인터페이스를 구현하는 CoffeMachine 클래스이다.////////////////////////////
class CoffeMachine implements CoffeeMaker {
  protected static ONE_SHOT_CAPSULE: number = 3;
  protected static ONE_CUP_WATER: number = 10;

  static makeMachine(beans: number, water: number): CoffeMachine {
    return new CoffeMachine(beans, water);
  }

  public constructor(
    protected capsule: number = 3,
    protected water: number = 10
  ) {}

  makeCoffee(orderShot: number): CoffeeCup {
    this.checkMaterials(orderShot);
    console.log("캡슐쓰기 전 " + this.capsule);
    this.useCapsule(orderShot);
    console.log("물쓰기 전 " + this.water);
    this.useWater();
    this.heatWater();
    return this.extract(orderShot);
  }

  protected checkMaterials(orderShot: number) {
    if (this.capsule < orderShot * CoffeMachine.ONE_SHOT_CAPSULE) {
      throw new Error(`커피캡슐 부족!!! 현재 보유 캡슐 : ${this.capsule}`);
    }
    if (this.water < CoffeMachine.ONE_CUP_WATER) {
      throw new Error(`물 부족!!! 남은 물 ${this.water}`);
    }
  }
  clean(): void {
    console.log("커피머신 행구는 중!");
  }

  private extract(shots: number): CoffeeCup {
    return {
      orderShot: shots,
      hasMilk: false,
    };
  }
  private heatWater() {
    console.log("물 끓이는 중...");
  }

  private useCapsule(shot: number) {
    console.log("캡슐쓰러왔습니다.");
    this.capsule -= shot * CoffeMachine.ONE_SHOT_CAPSULE;
    console.log("캡슐 쓰고 난 후" + this.capsule);
  }

  protected useWater() {
    console.log("물쓰러왔습니다.");
    this.water -= CoffeMachine.ONE_CUP_WATER;
    console.log("물쓰고 난 후 " + this.water);
  }

  addCapsule(capsule: number) {
    this.capsule += capsule;
  }

  fulfillWater(water: number) {
    this.water += water;
  }

  get Water(): number {
    return this.water;
  }

  get Capsule(): number {
    return this.capsule;
  }
}

// CoffeMachine 클래스를 상속받은 CafeLatteMachine 클래스이다.\\\\\\\\\\\\\\\\\\\\\\\\\\\\

class CafeLatteMachine extends CoffeMachine {
  public constructor(
    protected capsule: number = 3,
    protected water: number = 10,
    private milkFrother: MilkFrother
  ) {
    super(capsule, water);
  }

  makeCoffee(orderShot: number): CoffeeCup {
    const coffee = super.makeCoffee(orderShot); //기본적인 캡슐 소비, 물 소비, 물 가열 다 끝나고 완성된 커피가 반환
    return this.milkFrother.addMilkform(coffee);
  }
}

// CoffeMachine 클래스 를 상속받은 saltCoffeeMachine 클래스이다.\\\\\\\\\\\\\\\\\\\\\\\\\\\
class saltCoffeeMachine extends CoffeMachine {
  public constructor(
    protected capsule: number = 3,
    protected water: number = 10,
    private saltTopping: SaltTopping
  ) {
    super(capsule, water);
  }
  makeCoffee(orderShot: number): CoffeeCup {
    const coffee = super.makeCoffee(orderShot);
    return this.saltTopping.addSalt(coffee);
  }
}

// 만들고 싶었던 saltCafeLatteCoffeeMachine 클래스이다.\\\\\\\\\\\\\\\\\\\\\\\\\\\
class saltCafeLatteCoffeeMachine extends CoffeMachine {
  public constructor(
    protected capsule: number = 3,
    protected water: number = 10,
    private saltTopping: SaltTopping,
    private milkFrother: MilkFrother
  ) {
    super(capsule, water);
  }
  makeCoffee(orderShot: number): CoffeeCup {
    const coffee = super.makeCoffee(orderShot);
    const saltAdded = this.saltTopping.addSalt(coffee);
    return this.milkFrother.addMilkform(saltAdded);
  }
}


const cheapMilkSteamer = new CheapMilkSteamer();
const saltMixer = new SaltMixer();
const organicMilkSteamer = new OrganicMilkSteamer();
const cheeseMilkSteamer = new CheeseMilkSteamer();

//const saltCoffeeMaker = new saltCoffeeMachine(100, 100, saltMixer);
const saltCafeLatteMaker = new saltCafeLatteCoffeeMachine(
  100,
  100,
  saltMixer,
  cheapMilkSteamer
);
const saltCheeseCafeLatteMaker = new saltCafeLatteCoffeeMachine(
  100,
  100,
  saltMixer,
  cheeseMilkSteamer
);
const saltOrganicCafeLatteMaker = new saltCafeLatteCoffeeMachine(
  100,
  100,
  saltMixer,
  organicMilkSteamer
);
const latteMaker = new CafeLatteMachine(100, 100, cheapMilkSteamer);
const cheeselatteMaker = new CafeLatteMachine(100, 100, cheeseMilkSteamer);
const organicLatteMaker = new CafeLatteMachine(100, 100, organicMilkSteamer);
const coffeMakers: CoffeeMaker[] = [
  latteMaker,
  //saltCoffeeMaker,
  saltCafeLatteMaker,
  cheeselatteMaker,
  organicLatteMaker,
  saltCheeseCafeLatteMaker,
  saltOrganicCafeLatteMaker,
];
coffeMakers.forEach((maker: CoffeeMaker) => {
  console.log("------------커피머신 가동~!-- ----------");
  console.log(maker.makeCoffee(1));
});

 

아직 개선해야할 점들이 보인다.

이름이 복잡한 여러 종류의 클래스들이 다 필요없어졌으므로 필요한 최소한의 클래스만 남겨두고 다 지워버린다.

각각의 기능을 수행하는 부품들(클래스)와 부품 명세서인 인터페이스, 커피머신 클래스만 남겨둔다.

 

대신, 커피머신 클래스에 salt와 milkform 생성자 프로퍼티를 추가해주고 makeCoffee() 로직을 다음과 같이 변경해준다.

  makeCoffee(orderShot: number): CoffeeCup {
    this.checkMaterials(orderShot);
    console.log("캡슐쓰기 전 " + this.capsule);
    this.useCapsule(orderShot);
    console.log("물쓰기 전 " + this.water);
    this.useWater();
    this.heatWater();
    const coffeeCup = this.extract(orderShot);
    const saltAdded = this.salt.addSalt(coffeeCup);
    return this.milkform.addMilkform(saltAdded);
  }

 

// CoffeeMaker 인터페이스를 구현하는 CoffeMachine 클래스이다.////////////////////////////
class CoffeMachine implements CoffeeMaker {
  private static ONE_SHOT_CAPSULE: number = 3;
  private static ONE_CUP_WATER: number = 10;

  public constructor(
    private capsule: number = 3,
    private water: number = 10,
    private salt: SaltTopping,
    private milkform: MilkFrother
  ) {}

  makeCoffee(orderShot: number): CoffeeCup {
    this.checkMaterials(orderShot);
    console.log("캡슐쓰기 전 " + this.capsule);
    this.useCapsule(orderShot);
    console.log("물쓰기 전 " + this.water);
    this.useWater();
    this.heatWater();
    const coffeeCup = this.extract(orderShot);
    const saltAdded = this.salt.addSalt(coffeeCup);
    return this.milkform.addMilkform(saltAdded);
  }

  protected checkMaterials(orderShot: number) {
    if (this.capsule < orderShot * CoffeMachine.ONE_SHOT_CAPSULE) {
      throw new Error(`커피캡슐 부족!!! 현재 보유 캡슐 : ${this.capsule}`);
    }
    if (this.water < CoffeMachine.ONE_CUP_WATER) {
      throw new Error(`물 부족!!! 남은 물 ${this.water}`);
    }
  }
  clean(): void {
    console.log("커피머신 행구는 중!");
  }

  private extract(shots: number): CoffeeCup {
    return {
      orderShot: shots,
      hasMilk: false,
    };
  }
  private heatWater() {
    console.log("물 끓이는 중...");
  }

  private useCapsule(shot: number) {
    console.log("캡슐쓰러왔습니다.");
    this.capsule -= shot * CoffeMachine.ONE_SHOT_CAPSULE;
    console.log("캡슐 쓰고 난 후" + this.capsule);
  }

  protected useWater() {
    console.log("물쓰러왔습니다.");
    this.water -= CoffeMachine.ONE_CUP_WATER;
    console.log("물쓰고 난 후 " + this.water);
  }

  addCapsule(capsule: number) {
    this.capsule += capsule;
  }

  fulfillWater(water: number) {
    this.water += water;
  }

  get Water(): number {
    return this.water;
  }

  get Capsule(): number {
    return this.capsule;
  }
}

 

 

<현재 전체 코드>

 

//   //커피머신 만들기
type CoffeeCup = {
  orderShot: number;
  hasMilk?: boolean;
  hasSalt?: boolean;
};

interface MilkFrother {
  addMilkform(cup: CoffeeCup): CoffeeCup;
}

interface SaltTopping {
  addSalt(cup: CoffeeCup): CoffeeCup;
}
interface CoffeeMaker {
  makeCoffee(shots: number): CoffeeCup;
}

//일반 우유 거품기//////////////////////////////////////////////////////////////////////
class CheapMilkSteamer implements MilkFrother {
  //(1)우유 거품을 만드는 내부 함수
  private steamMilk(): void {
    console.log("몽글몽글 포삭포삭한 우유폼");
  }
  //(2)만들어진 커피컵을 받아서, 만들어진 우유거품(1)을 부어서 이 커피컵을 다시 리턴하는 함수
  addMilkform(cup: CoffeeCup): CoffeeCup {
    this.steamMilk();
    return {
      ...cup,
      hasMilk: true,
    };
  }
}

//치즈폼 우유 거품기//////////////////////////////////////////////////
class CheeseMilkSteamer implements MilkFrother {
  //(1)우유 거품을 만드는 내부 함수
  private steamCheeseMilk(): void {
    console.log("부드러운 치즈가 녹아든 우유폼");
  }
  //(2)만들어진 커피컵을 받아서, 만들어진 우유거품(1)을 부어서 이 커피컵을 다시 리턴하는 함수
  addMilkform(cup: CoffeeCup): CoffeeCup {
    this.steamCheeseMilk();
    return {
      ...cup,
      hasMilk: true,
    };
  }
}

//유기농 우유 거품기//////////////////////////////////////////////////
class OrganicMilkSteamer implements MilkFrother {
  //(1)우유 거품을 만드는 내부 함수
  private steamOrganicMilk(): void {
    console.log("고급 유기농 우유로 만든 우유폼");
  }
  //(2)만들어진 커피컵을 받아서, 만들어진 우유거품(1)을 부어서 이 커피컵을 다시 리턴하는 함수
  addMilkform(cup: CoffeeCup): CoffeeCup {
    this.steamOrganicMilk();
    return {
      ...cup,
      hasMilk: true,
    };
  }
}

//소금믹서///////////////////////////////////////////////////////////////////////////////
class SaltMixer implements SaltTopping {
  //(1)소금을 집는 내부 함수
  private getSalt() {
    console.log("소금을 한꼬집 집었다");
    return true;
  }
  //(2)만들어진 커피컵을 받아서, 집은 소금(1)을 뿌려서 이 커피컵을 다시 리턴하는 함수
  addSalt(cup: CoffeeCup): CoffeeCup {
    const salt = this.getSalt();
    return {
      ...cup,
      hasSalt: salt,
    };
  }
}
// CoffeeMaker 인터페이스를 구현하는 CoffeMachine 클래스이다.////////////////////////////
class CoffeMachine implements CoffeeMaker {
  private static ONE_SHOT_CAPSULE: number = 3;
  private static ONE_CUP_WATER: number = 10;

  public constructor(
    private capsule: number = 3,
    private water: number = 10,
    private salt: SaltTopping,
    private milkform: MilkFrother
  ) {}

  makeCoffee(orderShot: number): CoffeeCup {
    this.checkMaterials(orderShot);
    console.log("캡슐쓰기 전 " + this.capsule);
    this.useCapsule(orderShot);
    console.log("물쓰기 전 " + this.water);
    this.useWater();
    this.heatWater();
    const coffeeCup = this.extract(orderShot);
    const saltAdded = this.salt.addSalt(coffeeCup);
    return this.milkform.addMilkform(saltAdded);
  }

  protected checkMaterials(orderShot: number) {
    if (this.capsule < orderShot * CoffeMachine.ONE_SHOT_CAPSULE) {
      throw new Error(`커피캡슐 부족!!! 현재 보유 캡슐 : ${this.capsule}`);
    }
    if (this.water < CoffeMachine.ONE_CUP_WATER) {
      throw new Error(`물 부족!!! 남은 물 ${this.water}`);
    }
  }
  clean(): void {
    console.log("커피머신 행구는 중!");
  }

  private extract(shots: number): CoffeeCup {
    return {
      orderShot: shots,
      hasMilk: false,
    };
  }
  private heatWater() {
    console.log("물 끓이는 중...");
  }

  private useCapsule(shot: number) {
    console.log("캡슐쓰러왔습니다.");
    this.capsule -= shot * CoffeMachine.ONE_SHOT_CAPSULE;
    console.log("캡슐 쓰고 난 후" + this.capsule);
  }

  protected useWater() {
    console.log("물쓰러왔습니다.");
    this.water -= CoffeMachine.ONE_CUP_WATER;
    console.log("물쓰고 난 후 " + this.water);
  }

  addCapsule(capsule: number) {
    this.capsule += capsule;
  }

  fulfillWater(water: number) {
    this.water += water;
  }

  get Water(): number {
    return this.water;
  }

  get Capsule(): number {
    return this.capsule;
  }
}

implements MilkFrother인 NoMilk와

implements SaltTopping인 NoSalt 클래스를 만들어준다.

//우유폼 없음
class NoMilkSteamer implements MilkFrother {
  //(1)받아온 컵에다 추가 작업하지않고, 그대로 다시 반환
  addMilkform(cup: CoffeeCup): CoffeeCup {
    return cup
  }
}

 

//소금 토핑 없음
class NoSaltMixer implements SaltTopping {
  //(1)받아온 컵에다 추가 작업하지않고, 그대로 다시 반환
  addSalt(cup: CoffeeCup): CoffeeCup {
    return cup;
  }
}

 

그리고 각각 용도에 맞는 클래스들을 생성해준다.

//소금관련
const nosaltMixer = new NoSaltMixer();
const saltMixer = new SaltMixer();


//우유관련
const noMilkSteamer = new NoMilkSteamer();
const cheapMilkSteamer = new CheapMilkSteamer();
const organicMilkSteamer = new OrganicMilkSteamer();
const cheeseMilkSteamer = new CheeseMilkSteamer();

 

그 다음 작업은 용도에 맞게 부품클래스들을 잘 끼워넣어서

새로운 클래스들을 빵 빵 빵 찍어내는 일만 남았다.

//소금관련
const nosaltMixer = new NoSaltMixer();
const saltMixer = new SaltMixer();

//우유관련
const noMilkSteamer = new NoMilkSteamer();
const cheapMilkSteamer = new CheapMilkSteamer();
const organicMilkSteamer = new OrganicMilkSteamer();
const cheeseMilkSteamer = new CheeseMilkSteamer();

const saltCoffeeMaker = new CoffeMachine(100, 100, saltMixer, noMilkSteamer);
const saltCafeLatteMaker = new CoffeMachine(
  100,
  100,
  saltMixer,
  cheapMilkSteamer
);
const saltCheeseCafeLatteMaker = new CoffeMachine(
  100,
  100,
  saltMixer,
  cheeseMilkSteamer
);
const saltOrganicCafeLatteMaker = new CoffeMachine(
  100,
  100,
  saltMixer,
  organicMilkSteamer
);
const latteMaker = new CoffeMachine(100, 100, nosaltMixer, cheapMilkSteamer);
const cheeselatteMaker = new CoffeMachine(
  100,
  100,
  nosaltMixer,
  cheeseMilkSteamer
);
const organicLatteMaker = new CoffeMachine(
  100,
  100,
  nosaltMixer,
  organicMilkSteamer
);
const coffeMakers: CoffeeMaker[] = [
  latteMaker,
  saltCoffeeMaker,
  saltCafeLatteMaker,
  cheeselatteMaker,
  organicLatteMaker,
  saltCheeseCafeLatteMaker,
  saltOrganicCafeLatteMaker,
];
coffeMakers.forEach((maker: CoffeeMaker) => {
  console.log("------------커피머신 가동~!-- ----------");
  console.log(maker.makeCoffee(1));
});

 

 

<최종코드>

//   //커피머신 만들기
type CoffeeCup = {
  orderShot: number;
  hasMilk?: boolean;
  hasSalt?: boolean;
};

interface MilkFrother {
  addMilkform(cup: CoffeeCup): CoffeeCup;
}

interface SaltTopping {
  addSalt(cup: CoffeeCup): CoffeeCup;
}
interface CoffeeMaker {
  makeCoffee(shots: number): CoffeeCup;
}
//우유폼 없음
class NoMilkSteamer implements MilkFrother {
  //(1)받아온 컵에다 추가 작업하지않고, 그대로 다시 반환
  addMilkform(cup: CoffeeCup): CoffeeCup {
    return cup;
  }
}

//일반 우유 거품기//////////////////////////////////////////////////////////////////////
class CheapMilkSteamer implements MilkFrother {
  //(1)우유 거품을 만드는 내부 함수
  private steamMilk(): void {
    console.log("몽글몽글 포삭포삭한 우유폼");
  }
  //(2)만들어진 커피컵을 받아서, 만들어진 우유거품(1)을 부어서 이 커피컵을 다시 리턴하는 함수
  addMilkform(cup: CoffeeCup): CoffeeCup {
    this.steamMilk();
    return {
      ...cup,
      hasMilk: true,
    };
  }
}

//치즈폼 우유 거품기//////////////////////////////////////////////////
class CheeseMilkSteamer implements MilkFrother {
  //(1)우유 거품을 만드는 내부 함수
  private steamCheeseMilk(): void {
    console.log("부드러운 치즈가 녹아든 우유폼");
  }
  //(2)만들어진 커피컵을 받아서, 만들어진 우유거품(1)을 부어서 이 커피컵을 다시 리턴하는 함수
  addMilkform(cup: CoffeeCup): CoffeeCup {
    this.steamCheeseMilk();
    return {
      ...cup,
      hasMilk: true,
    };
  }
}

//유기농 우유 거품기//////////////////////////////////////////////////
class OrganicMilkSteamer implements MilkFrother {
  //(1)우유 거품을 만드는 내부 함수
  private steamOrganicMilk(): void {
    console.log("고급 유기농 우유로 만든 우유폼");
  }
  //(2)만들어진 커피컵을 받아서, 만들어진 우유거품(1)을 부어서 이 커피컵을 다시 리턴하는 함수
  addMilkform(cup: CoffeeCup): CoffeeCup {
    this.steamOrganicMilk();
    return {
      ...cup,
      hasMilk: true,
    };
  }
}

//소금 토핑 없음
class NoSaltMixer implements SaltTopping {
  //(1)받아온 컵에다 추가 작업하지않고, 그대로 다시 반환
  addSalt(cup: CoffeeCup): CoffeeCup {
    return cup;
  }
}

//소금믹서///////////////////////////////////////////////////////////////////////////////
class SaltMixer implements SaltTopping {
  //(1)소금을 집는 내부 함수
  private getSalt() {
    console.log("소금을 한꼬집 집었다");
    return true;
  }
  //(2)만들어진 커피컵을 받아서, 집은 소금(1)을 뿌려서 이 커피컵을 다시 리턴하는 함수
  addSalt(cup: CoffeeCup): CoffeeCup {
    const salt = this.getSalt();
    return {
      ...cup,
      hasSalt: salt,
    };
  }
}
// CoffeeMaker 인터페이스를 구현하는 CoffeMachine 클래스이다.////////////////////////////
class CoffeMachine implements CoffeeMaker {
  private static ONE_SHOT_CAPSULE: number = 3;
  private static ONE_CUP_WATER: number = 10;

  public constructor(
    private capsule: number = 3,
    private water: number = 10,
    private salt: SaltTopping,
    private milkform: MilkFrother
  ) {}

  makeCoffee(orderShot: number): CoffeeCup {
    this.checkMaterials(orderShot);
    console.log("캡슐쓰기 전 " + this.capsule);
    this.useCapsule(orderShot);
    console.log("물쓰기 전 " + this.water);
    this.useWater();
    this.heatWater();
    const coffeeCup = this.extract(orderShot);
    const saltAdded = this.salt.addSalt(coffeeCup);
    return this.milkform.addMilkform(saltAdded);
  }

  protected checkMaterials(orderShot: number) {
    if (this.capsule < orderShot * CoffeMachine.ONE_SHOT_CAPSULE) {
      throw new Error(`커피캡슐 부족!!! 현재 보유 캡슐 : ${this.capsule}`);
    }
    if (this.water < CoffeMachine.ONE_CUP_WATER) {
      throw new Error(`물 부족!!! 남은 물 ${this.water}`);
    }
  }
  clean(): void {
    console.log("커피머신 행구는 중!");
  }

  private extract(shots: number): CoffeeCup {
    return {
      orderShot: shots,
      hasMilk: false,
    };
  }
  private heatWater() {
    console.log("물 끓이는 중...");
  }

  private useCapsule(shot: number) {
    console.log("캡슐쓰러왔습니다.");
    this.capsule -= shot * CoffeMachine.ONE_SHOT_CAPSULE;
    console.log("캡슐 쓰고 난 후" + this.capsule);
  }

  protected useWater() {
    console.log("물쓰러왔습니다.");
    this.water -= CoffeMachine.ONE_CUP_WATER;
    console.log("물쓰고 난 후 " + this.water);
  }

  addCapsule(capsule: number) {
    this.capsule += capsule;
  }

  fulfillWater(water: number) {
    this.water += water;
  }

  get Water(): number {
    return this.water;
  }

  get Capsule(): number {
    return this.capsule;
  }
}

//소금관련
const nosaltMixer = new NoSaltMixer();
const saltMixer = new SaltMixer();

//우유관련
const noMilkSteamer = new NoMilkSteamer();
const cheapMilkSteamer = new CheapMilkSteamer();
const organicMilkSteamer = new OrganicMilkSteamer();
const cheeseMilkSteamer = new CheeseMilkSteamer();

const saltCoffeeMaker = new CoffeMachine(100, 100, saltMixer, noMilkSteamer);
const saltCafeLatteMaker = new CoffeMachine(
  100,
  100,
  saltMixer,
  cheapMilkSteamer
);
const saltCheeseCafeLatteMaker = new CoffeMachine(
  100,
  100,
  saltMixer,
  cheeseMilkSteamer
);
const saltOrganicCafeLatteMaker = new CoffeMachine(
  100,
  100,
  saltMixer,
  organicMilkSteamer
);
const latteMaker = new CoffeMachine(100, 100, nosaltMixer, cheapMilkSteamer);
const cheeselatteMaker = new CoffeMachine(
  100,
  100,
  nosaltMixer,
  cheeseMilkSteamer
);
const organicLatteMaker = new CoffeMachine(
  100,
  100,
  nosaltMixer,
  organicMilkSteamer
);
const coffeMakers: CoffeeMaker[] = [
  latteMaker,
  saltCoffeeMaker,
  saltCafeLatteMaker,
  cheeselatteMaker,
  organicLatteMaker,
  saltCheeseCafeLatteMaker,
  saltOrganicCafeLatteMaker,
];
coffeMakers.forEach((maker: CoffeeMaker) => {
  console.log("------------커피머신 가동~!-- ----------");
  console.log(maker.makeCoffee(1));
});

<최종 출력 결과>

------------커피머신 가동~!-- ----------
캡슐쓰기 전 100
캡슐쓰러왔습니다.
캡슐 쓰고 난 후97
물쓰기 전 100
물쓰러왔습니다.
물쓰고 난 후 90
물 끓이는 중...
몽글몽글 포삭포삭한 우유폼
{ orderShot: 1, hasMilk: true }
------------커피머신 가동~!-- ----------
캡슐쓰기 전 100
캡슐쓰러왔습니다.
캡슐 쓰고 난 후97
물쓰기 전 100
물쓰러왔습니다.
물쓰고 난 후 90
물 끓이는 중...
소금을 한꼬집 집었다
{ orderShot: 1, hasMilk: false, hasSalt: true }
------------커피머신 가동~!-- ----------
캡슐쓰기 전 100
캡슐쓰러왔습니다.
캡슐 쓰고 난 후97
물쓰기 전 100
물쓰러왔습니다.
물쓰고 난 후 90
물 끓이는 중...
소금을 한꼬집 집었다
몽글몽글 포삭포삭한 우유폼
{ orderShot: 1, hasMilk: true, hasSalt: true }
------------커피머신 가동~!-- ----------
캡슐쓰기 전 100
캡슐쓰러왔습니다.
캡슐 쓰고 난 후97
물쓰기 전 100
물쓰러왔습니다.
물쓰고 난 후 90
물 끓이는 중...
부드러운 치즈가 녹아든 우유폼
{ orderShot: 1, hasMilk: true }
------------커피머신 가동~!-- ----------
캡슐쓰기 전 100
캡슐쓰러왔습니다.
캡슐 쓰고 난 후97
물쓰기 전 100
물쓰러왔습니다.
물쓰고 난 후 90
물 끓이는 중...
고급 유기농 우유로 만든 우유폼
{ orderShot: 1, hasMilk: true }
------------커피머신 가동~!-- ----------
캡슐쓰기 전 100
캡슐쓰러왔습니다.
캡슐 쓰고 난 후97
물쓰기 전 100
물쓰러왔습니다.
물쓰고 난 후 90
물 끓이는 중...
소금을 한꼬집 집었다
부드러운 치즈가 녹아든 우유폼
{ orderShot: 1, hasMilk: true, hasSalt: true }
------------커피머신 가동~!-- ----------
캡슐쓰기 전 100
캡슐쓰러왔습니다.
캡슐 쓰고 난 후97
물쓰기 전 100
물쓰러왔습니다.
물쓰고 난 후 90
물 끓이는 중...
소금을 한꼬집 집었다
고급 유기농 우유로 만든 우유폼
{ orderShot: 1, hasMilk: true, hasSalt: true }