[타입스크립트] 추상화를 이용해서 클래스 개선하기

 

- 외부에서 클래스를 바라 봤을 때,  사용해야 할 함수가 너무 많이 뜨면 사용자는 무엇을 사용해야 할지 혼란스러울 수 있다.

 

이를 개선하기 위한 도입할 수 있는 개념이 바로 '추상화'이다.

 

정말 필요한 api들만 노출함으로써 클래스를 보다 사용하게 쉽게 만들어 줄 수 있다.  

 

 

다음 아래와 같은 커피머신 클래스가 있다고 가정한다. 

 

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

class coffeeMachine {
  private static ONE_SHOT_CAPSULE: number = 3;
  private static ONE_CUP_WATER: number = 10;

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

  constructor(private capsule: number = 3, private 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);
  }

  checkMaterials(orderShot: number) {
    if (this.capsule < orderShot * coffeeMachine.ONE_SHOT_CAPSULE) {
      throw new Error(`커피캡슐 부족!!! 현재 보유 캡슐 : ${this.capsule}`);
    }
    if (this.water < coffeeMachine.ONE_CUP_WATER) {
      throw new Error(`물 부족!!! 남은 물 ${this.water}`);
    }
  }

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

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

  useWater() {
    console.log("물쓰러왔습니다.");
    this.water -= coffeeMachine.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;
  }
}

console.log("/* 첫번째 주문 */");
let normalMachine = new coffeeMachine(10, 10);
console.log(normalMachine.Water); //10
console.log(normalMachine.Capsule); //10
let order1 = normalMachine.makeCoffee(2);
console.log(order1); //{ orderShot: 2 }
console.log("물 상태" + normalMachine.Water); //0
console.log("캡슐 상태" + normalMachine.Capsule); //4

console.log("/* 두번째 주문 */");
normalMachine.fulfillWater(100);
let order2 = normalMachine.makeCoffee(1);
console.log(order2); //{ orderShot: 1 }
console.log("물 상태" + normalMachine.Water); //90
console.log("캡슐 상태" + normalMachine.Capsule); //1

console.log("/* 세번째 주문 */");
let order3 = normalMachine.makeCoffee(3);
console.log(order3); //Error: 커피캡슐 부족!!! 현재 보유 캡슐 : 1

굉장히 많은 함수가 있는 것을 확인할 수 있다... 이렇게 많아 버리면 사용자가 함수를 써야할 순서를 헷갈릴 수 있게 된다. 이럴 때 추상화가 빛을 발하게 된다. 인터페이스를 굉장히 간단하고 심플하게 만듬으로써 사용자가 큰 고민을 하지 않고도 간편하게 사용할 수 있도록 도와준다.

-1.  일단 외부에서 쓸 필요가 없는 함수들에 키워드 private 달아준다 : 외부에 정말 필요한 함수만 보여주자는 관점 (이건사실 캡슐화 개념)

-2.  인터페이스를 통한 추상화

 

-1.

일단 외부에서 부를 필요가 없는 함수들에 private를 달아주니

type CoffeeCup = {
  orderShot: number;
};

class coffeeMachine {
  private static ONE_SHOT_CAPSULE: number = 3;
  private static ONE_CUP_WATER: number = 10;

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

  constructor(private capsule: number = 3, private 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);
  }

  private checkMaterials(orderShot: number) {
    if (this.capsule < orderShot * coffeeMachine.ONE_SHOT_CAPSULE) {
      throw new Error(`커피캡슐 부족!!! 현재 보유 캡슐 : ${this.capsule}`);
    }
    if (this.water < coffeeMachine.ONE_CUP_WATER) {
      throw new Error(`물 부족!!! 남은 물 ${this.water}`);
    }
  }

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

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

  private useWater() {
    console.log("물쓰러왔습니다.");
    this.water -= coffeeMachine.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;
  }
}

console.log("/* 첫번째 주문 */");
let normalMachine = new coffeeMachine(10, 10);
console.log(normalMachine.Water); //10
console.log(normalMachine.Capsule); //10
let order1 = normalMachine.makeCoffee(2);
console.log(order1); //{ orderShot: 2 }
console.log("물 상태" + normalMachine.Water); //0
console.log("캡슐 상태" + normalMachine.Capsule); //4

console.log("/* 두번째 주문 */");
normalMachine.fulfillWater(100);
let order2 = normalMachine.makeCoffee(1);
console.log(order2); //{ orderShot: 1 }
console.log("물 상태" + normalMachine.Water); //90
console.log("캡슐 상태" + normalMachine.Capsule); //1

console.log("/* 세번째 주문 */");
let order3 = normalMachine.makeCoffee(3);
console.log(order3); //Error: 커피캡슐 부족!!! 현재 보유 캡슐 : 1

와! 확실히 보다 간결해졌다. 이렇게 클래스 내부에서만 호출할 동작(함수)들은 private 달아주어, 외부에 느낄 혼란을 줄여주자! 물과 커피캡슐 갯수를 확인하는 프로퍼티와 캡슐과 물 추가 및 커피 만들기 함수만 노출되어서 벌써부터 시중에 파는 커피머신 같다~ 이 클래스를 사용할 사람이 나 혹은 동료가 될 터인데 접근이 훨씬 간결하고 쉬워졌다!

-2. 인터페이스를 통한 추상화

 

인터페이스 왈 "나랑 행동하려면 나는 이러이러이러한 규약을 가지고 있어. 이런 행동들을 할 수 있어~"라고 명시해놓는 계약서이자 약속!

 

interface CoffeeMaker{
//상세하게 명세서 작성, 몇번의 샷을 받을 건지, 어떤 타입을 리턴할건지
  makeCoffee(shots:number):CoffeeCup;
}

이 인터페이스를 이용하면 CoffeeCup을 리턴하는 makeCoffee() 함수를 이용할 수 있다.

인터페이스 규격을 따르길 원하는 클래스에 필요한 키워드는

implements 이다. 

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

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

---

extends, implements 차이 : 자바 자료지만 정말 정리를 잘 해놓으셔서 본 포스팅을 작성하면서 많이 참고하였다. 링크를 달아둔다.

참고블로그: https://velog.io/@hkoo9329/%EC%9E%90%EB%B0%94-extends-implements-%EC%B0%A8%EC%9D%B4

자바 extends, implements 차이

https://velog.io/@hkoo9329/OOPObject-Oriented-Programming-%EA%B0%9D%EC%B2%B4-%EC%A7%80%ED%96%A5-%ED%94%84%EB%A1%9C%EA%B7%B8%EB%9E%98%EB%B0%8D-%EC%9D%B4%EB%9E%80

OOP(Object-Oriented Programming, 객체 지향 프로그래밍) 이란?

---

 

 

인터페이스를 구현하는 클래스에서는 인터페이스에서 규약된 모든 함수를 구현해야 한다.

어쨌든, 이렇게 인터페이스를 사용하면 추상화를 극대화해서 사용할 수 있다.

 

클래스 타입으로 오브젝트를 받게 되면 그 인스턴스에서 클래스 안 퍼블릭프로퍼티들에 다 접근이 가능

인터페이스로 타입을 제한해서 받게 되면 이 인터페이스에서 정의(규약)된 아이들만 사용할 수가 있다.

 

 

 

이런 소스에 대하여

type CoffeeCup = {
  orderShot: number;
};

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

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

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

  constructor(private capsule: number = 3, private 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);
  }

  private checkMaterials(orderShot: number) {
    if (this.capsule < orderShot * coffeeMachine.ONE_SHOT_CAPSULE) {
      throw new Error(`커피캡슐 부족!!! 현재 보유 캡슐 : ${this.capsule}`);
    }
    if (this.water < coffeeMachine.ONE_CUP_WATER) {
      throw new Error(`물 부족!!! 남은 물 ${this.water}`);
    }
  }

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

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

  private useWater() {
    console.log("물쓰러왔습니다.");
    this.water -= coffeeMachine.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 maker: CoffeMachine = CoffeMachine.makeMachine(32, 100);
maker.makeCoffee(2);

공개 상태인 class api들이 보이는 상태

maker2의 타입은 CoffeeMaker로 해줄 수도 있다.

const maker2: CoffeeMaker = CoffeMachine.makeMachine(32, 100);
maker2.makeCoffee(2);

 

커피메이커라는 인터페이스 안에는 메이크커피라는 함수밖에 없기 때문에(즉, 캡슐, 물, 캡슐채우기, 물채우기 등의 기타 api 들은 커피메이커 인터페이스에 없단 말)

그래서 인터페이스에 없는 함수는 사용할 수가 없다. 아래 캡처처럼

인터페이스에 규약된 함수만 보이는 상태

그래서 인터페이스를 사용하면 개발자가 얼마만큼의 규약을 세울 것인지, (보장-허용,의 느낌)를 결정할 수가 있다.

 

 

인터페이스를 하나 더 만들어보자.

상업적으로 이용되는 커피메이커(커피전문숍에서 사용할 만한 인터페이스) 더 다양한 apis를 달아주자.

interface CommercialCoffeeMaker {
  makeCoffee(shots: number): CoffeeCup;
  addCapsule(capsule: number):void;
  fulfillWater(water: number):void;
  clean():void; 
}

 

 

인터페이스는 다중 상속이 가능하다.

class CoffeMachine implements CoffeeMaker,CommercialCoffeeMaker {

당연한 추천(물론 clean 함수는 적당히 구현해주었다.)

<현재까지 진행상황>

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

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

interface CommercialCoffeeMaker {
  makeCoffee(shots: number): CoffeeCup;
  addCapsule(capsule: number): void;
  fulfillWater(water: number): void;
  clean(): void;
}

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

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

  constructor(private capsule: number = 3, private 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);
  }

  private 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,
    };
  }
  private heatWater() {
    console.log("물 끓이는 중...");
  }

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

  private 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 maker: CoffeMachine = CoffeMachine.makeMachine(32, 100);
maker.makeCoffee(2);

const maker2: CoffeeMaker = CoffeMachine.makeMachine(12, 12);
maker2.makeCoffee(1);

const maker3: CommercialCoffeeMaker = CoffeMachine.makeMachine(30, 60);
maker3.makeCoffee(2);
maker3.clean();

<출력 결과>

캡슐쓰기 전 32
캡슐쓰러왔습니다.
캡슐 쓰고 난 후26
물쓰기 전 100
물쓰러왔습니다.
물쓰고 난 후 90
물 끓이는 중...
캡슐쓰기 전 12
캡슐쓰러왔습니다.
캡슐 쓰고 난 후9
물쓰기 전 12
물쓰러왔습니다.
물쓰고 난 후 2
물 끓이는 중...
캡슐쓰기 전 30
캡슐쓰러왔습니다.
캡슐 쓰고 난 후24
물쓰기 전 60
물쓰러왔습니다.
물쓰고 난 후 50
물 끓이는 중...
커피머신 행구는 중!

 

 

 

인터페이스를 매개변수의 타입으로 하고 싶을 때의 대응

this.매개변수식별자. 하면 인터페이스의 api들이 짜라라란 나옴

아래 캡처 참고

 

아마추어 유저

프로 바리스타

<현재까지 소스코드>

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

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

interface CommercialCoffeeMaker {
  makeCoffee(shots: number): CoffeeCup;
  addCapsule(capsule: number): void;
  fulfillWater(water: number): void;
  clean(): void;
}

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

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

  constructor(private capsule: number = 3, private 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);
  }

  private 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,
    };
  }
  private heatWater() {
    console.log("물 끓이는 중...");
  }

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

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

// tslint:disable-next-line: max-classes-per-file
class AmateurUser {
  constructor(private machine: CoffeeMaker) {}
  makeCoffee() {
    console.log("초심자가 내린 커피");
    const coffee = this.machine.makeCoffee(1);
    console.log(coffee);
  }
}

// tslint:disable-next-line: max-classes-per-file
class ProBarista {
  constructor(private machine: CommercialCoffeeMaker) {}
  makeCoffee() {
    console.log("프로바리스타가 내린 커피");
    const coffee = this.machine.makeCoffee(1);
    console.log(coffee);
    this.machine.clean();
    this.machine.fulfillWater(10);
    this.machine.addCapsule(10);
  }
}

const maker: CoffeMachine = CoffeMachine.makeMachine(32, 100);

//아마추어와 프로는 동일한 커피머신을 받았음에도 불구하고,
//amateur는 클래스AmateurUser가 인자를 받을 때 CoffeeMaker 인터페이스를 기준으로 받아오고,
//pro는 클래스ProBarista가 인자를 받을 때 CommercialCoffeeMaker 안토패아수룰 기준으로 받아오기 때문에,
//각각 인터페이스에 제약된 항목들만 쓸 수 있게된다.(순식간에 가용 범위가 달라짐!!!)

const amateur = new AmateurUser(maker);
const pro = new ProBarista(maker);
amateur.makeCoffee();
pro.makeCoffee();

<출력 결과> : 프로바리스타는 프로답게 작업 후 커피머신을 헹구는 작업을 잊지 않았다는 시나리오

초심자가 내린 커피
캡슐쓰기 전 32
캡슐쓰러왔습니다.
캡슐 쓰고 난 후29
물쓰기 전 100
물쓰러왔습니다.
물쓰고 난 후 90
물 끓이는 중...
{ orderShot: 1 }
프로바리스타가 내린 커피
캡슐쓰기 전 29
캡슐쓰러왔습니다.
캡슐 쓰고 난 후26
물쓰기 전 90
물쓰러왔습니다.
물쓰고 난 후 80
물 끓이는 중...
{ orderShot: 1 }
커피머신 헹구는 중!

 

 

이처럼 동일한 오브젝트 인스턴스일지라도 이 오브젝트의 클래스가 두가지 인터페이스를 상속받아 구현을 했기에 다채롭게 프로그래밍할 수 있다.

이를 인자로 받아갈 두 클래스(아마추어, 프로)는 각기 다른 인터페이스 타입을 받기로 매개인자에 명시해주었기 때문에 그에 맞게 생성자에서 받아오고, this.식별자.을 했을 때 인터페이스에서 규약된( 클래스보다는 범위가 좁은 ) api들만 접근이 가능하다는 것을 알 수 있다.

 

 

결론적으로 아마추어유저나 프로바리스타 클래스에서는 인터페이스가 어떻게 구현되어 있는지,

본래 클래스에서 얼마나 많은 함수들이 있는지 신경쓰지 않아도 된다.

인터페이스에 규약된 함수들만 이용해서 생성된 오브젝트와 의사소통을 할 수 있다. 

그렇기에 사용자(프로그래머)들은 본래 클래스의 다른 복잡한 기능들을 알 필요도 없고,

인터페이스만 어떻게 사용하면 되는지를 알면 되는 것이다! 

 

 

 

<최종 코드>

type CoffeeCup = {
  orderShot: number;
};

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

interface CommercialCoffeeMaker {
  makeCoffee(shots: number): CoffeeCup;
  addCapsule(capsule: number): void;
  fulfillWater(water: number): void;
  clean(): void;
}

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

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

  constructor(private capsule: number = 3, private 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);
  }

  private 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,
    };
  }
  private heatWater() {
    console.log("물 끓이는 중...");
  }

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

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

// tslint:disable-next-line: max-classes-per-file
class AmateurUser {
  constructor(private machine: CoffeeMaker) {}
  makeCoffee() {
    console.log("초심자가 내린 커피");
    const coffee = this.machine.makeCoffee(1);
    console.log(coffee);
  }
}

// tslint:disable-next-line: max-classes-per-file
class ProBarista {
  constructor(private machine: CommercialCoffeeMaker) {}
  makeCoffee() {
    console.log("프로바리스타가 내린 커피");
    const coffee = this.machine.makeCoffee(1);
    console.log(coffee);
    this.machine.clean();
    this.machine.fulfillWater(10);
    this.machine.addCapsule(10);
  }
}

const maker: CoffeMachine = CoffeMachine.makeMachine(32, 100);

//아마추어와 프로는 동일한 커피머신을 받았음에도 불구하고,
//amateur는 클래스AmateurUser가 인자를 받을 때 CoffeeMaker 인터페이스를 기준으로 받아오고,
//pro는 클래스ProBarista가 인자를 받을 때 CommercialCoffeeMaker 인터페이스를 기준으로 받아오기 때문에,
//각각 인터페이스에 제약된 항목들만 쓸 수 있게된다.(순식간에 가용 범위가 달라짐!!!)

const amateur = new AmateurUser(maker);
const pro = new ProBarista(maker);
amateur.makeCoffee();
pro.makeCoffee();

 

<출력>

초심자가 내린 커피
캡슐쓰기 전 32
캡슐쓰러왔습니다.
캡슐 쓰고 난 후29
물쓰기 전 100
물쓰러왔습니다.
물쓰고 난 후 90
물 끓이는 중...
{ orderShot: 1 }
프로바리스타가 내린 커피
캡슐쓰기 전 29
캡슐쓰러왔습니다.
캡슐 쓰고 난 후26
물쓰기 전 90
물쓰러왔습니다.
물쓰고 난 후 80
물 끓이는 중...
{ orderShot: 1 }
커피머신 행구는 중!