[타입스크립트] Abstract 클래스와 abstract method

상속 클래스를 이용할 때, 위 클래스에서 반복되는 것이 있고 어떤 특정 기능만 자식 클래스에서 그 양태가 달라진다면

Abstract 클래스를 만들 것을 고려해보자.

abstract 클래스와 abstract 함수는 프로그래머의 실수를 사전에 예방해주는 매력적인 기능들을 갖추고 있다.

 

abstract 클래스와 abstract 함수를 이용했을 때의 이점은,

무작정 오버라이딩 + super()호출하기 활동을 어느 정도 대체하면서

자식클래스에서 부모클래스와 차별화되는 추상화 함수들을 반드시 구현할 것을 강제할 수 있기 때문이다. 

 

 

아래와 같은 코드베이스부터 시작한다.

//   //커피머신 만들기
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); //기본적인 캡슐 소비, 물 소비, 물 가열 다 끝나고 완성된 커피가 반환
    const saltAdded = this.milkFrother.addMilkform(coffee);
    return this.milkFrother.addMilkform(saltAdded);
  }
}

// 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);
  }
}

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

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

<추상클래스 작업 전 출력 결과>

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

 

 

 

 

부모클래스

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;
  }
}

 

자식클래스 1,2

// 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); //기본적인 캡슐 소비, 물 소비, 물 가열 다 끝나고 완성된 커피가 반환
    const saltAdded = this.milkFrother.addMilkform(coffee);
    return this.milkFrother.addMilkform(saltAdded);
  }
}

 

지금은 const coffee = super.makeCoffee(orderShot); 식으로 부모 클래스의 함수를 호출해주지만

실수로 이 코드를 작성하지 않으면?

makeCoffee를 위한 핵심 단계를 놓칠 수가 있게 된다.

이런 실수들을 방지하고 싶다면 안전하게 Abstract class를 만드는 것을 고려해볼 수 있다.

// 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);
  }
}

 

 

abstract class 

// CoffeeMaker 인터페이스를 구현하는 CoffeMachine 클래스이다.////////////////////////////
abstract class CoffeMachine implements CoffeeMaker {

 

이것은 추상적인 클래스이다. 이 자체로는 오브젝트를 만들 수 없다.

추상적인 부모클래스로서 본질적으로 필요한 것들을 정의해놓고,

자식클래스마다 달라질 수 있는 행동이 있다면 그 행동에 해당하는 함수 앞에 abstract 키워드를 붙여주자.

  abstract extract(shots: number): CoffeeCup {
    return {
      orderShot: shots,
      hasMilk: false,
    };
  }

키워드를 붙여주자 마자 빨간줄이 그어진다.

위에서 빨간 밑줄이 그어진 abstrct extract 함수는 자식 클래스에서  자식 클래스마다 다르게 구현을 해야 하기 때문에

접근지정제한자도 private가 아닌 protected로 달아주어야 하고,

추상적인 메소드이기 때문에 구현 사항은 작성하면 안된다.

 

바로 이렇게

  protected abstract extract(shots: number): CoffeeCup;

extract 함수는 추상클래스의 추상함수이기 때문에 추상함수 구현 클래스에서 구현해주어야 한다.

 

 

기존 자식 클래스에서 makeCoffee함수를 오버라이딩할 필요가 없어졌다.

대신에 extract 함수를 구현해주도록 한다.

 

<변경 전>

// 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); //기본적인 캡슐 소비, 물 소비, 물 가열 다 끝나고 완성된 커피가 반환
    const saltAdded = this.milkFrother.addMilkform(coffee);
    return this.milkFrother.addMilkform(saltAdded);
  }
}

// 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);
  }
}

<변경 후>

// CoffeMachine 클래스를 상속받은 CafeLatteMachine 클래스이다.
// tslint:disable-next-line: max-classes-per-file
class CafeLatteMachine extends CoffeMachine {
  public constructor(
    protected capsule: number = 3,
    protected water: number = 10,
    private milkFrother: CheapMilkSteamer
  ) {
    super(capsule, water);
  }
  protected extract(shots: number): CoffeeCup {
    const blackCoffee = {
      orderShot: shots,
    };
    return this.milkFrother.addMilkform(blackCoffee);
  }
}

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

 

<지금까지 진행된 전체 코드>

//   //커피머신 만들기
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 클래스이다.////////////////////////////
abstract class CoffeMachine implements CoffeeMaker {
  protected static ONE_SHOT_CAPSULE: number = 3;
  protected static ONE_CUP_WATER: number = 10;

  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("커피머신 행구는 중!");
  }

  protected abstract extract(shots: number): CoffeeCup;

  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 클래스이다.
// tslint:disable-next-line: max-classes-per-file
class CafeLatteMachine extends CoffeMachine {
  public constructor(
    protected capsule: number = 3,
    protected water: number = 10,
    private milkFrother: CheapMilkSteamer
  ) {
    super(capsule, water);
  }
  protected extract(shots: number): CoffeeCup {
    const blackCoffee = {
      orderShot: shots,
    };
    return this.milkFrother.addMilkform(blackCoffee);
  }
}

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

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

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

 

<출력 결과> 잘 동작한다.

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

 

 

정리하자면, 추상클래스는 인스턴스를 만들 수 없다.

공통적인 기능들은 다 추상클래스 안에서 구현해주고,

단 상속받은 자식클래스 별로 달라져야 하는 기능(메소드)가 있다면,

그 부분만 abstract method로 정의할 수 있다.(구현x)

 

인터페이스에서 함수의 규격을 정의한 것 처럼

추상클래스의 abstract method는 함수의 이름은 무엇이고 어떤 것들을 매개변수로 받아야하는지 어떤 것을 리턴해야하는지만 정의할 수 있다.

공통적으로 쓰이는 기능들은 내부에서만 필요한 것은 private로,

외부에서 호출되야 하는 기능들은 public으로 만들 수 있고,

구현하는 클래스마다 달라져야 하는 abstract method만 이를 구현하는 자식 클래스에서 구현해주면 된다. 

(추상클래스를 상속받았음에도 불구하고 abstract method를 구현하지 않으면 에러메시지를 받는다)

 

 

이렇게 추상클래스를 사용하면 조금 더 안전하게 프로그래머가 의도한 대로 공통적인 기능들을 수행하고

달라져야 하는 것만 상속하는 클래스에게 그것을 꼭 구현할 것을 강제할 수 있다.

 

 

<최종 코드>

//   //커피머신 만들기
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 클래스이다.////////////////////////////
abstract class CoffeMachine implements CoffeeMaker {
  protected static ONE_SHOT_CAPSULE: number = 3;
  protected static ONE_CUP_WATER: number = 10;

  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("커피머신 행구는 중!");
  }

  protected abstract extract(shots: number): CoffeeCup;

  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 클래스이다.
// tslint:disable-next-line: max-classes-per-file
class CafeLatteMachine extends CoffeMachine {
  public constructor(
    protected capsule: number = 3,
    protected water: number = 10,
    private milkFrother: CheapMilkSteamer
  ) {
    super(capsule, water);
  }
  protected extract(shots: number): CoffeeCup {
    const blackCoffee = {
      orderShot: shots,
    };
    return this.milkFrother.addMilkform(blackCoffee);
  }
}

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

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

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

 

<출력 결과>

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