SOLID : 리스코프 치환

Liskov 대체의 정의는 다음과 같습니다.

🤔 The Liskov Substitution Principle (LSP) states that subtypes must be substitutable for their base types

하지만 간단히 말해서

😀 🎉🎉🎉🎉 follow the rules of parent class !🎉🎉🎉🎉

샘플 코드를 보여드리지만 제가 만든 이 간단한 정의를 잊지 마세요.

👎 잘못된 코드

물을 마시고 싶고, MountainWater와 RiverWater를 만들어서 마시고 싶다.

interface IWater {
  shower: () => void
  drink: () => void
  wash: () => void
}

class Water implements IWater{
  drink() {
    console.log('drink it !!')
  }
  shower() {
    console.log('take a shower!!')
  }
  wash() {
    console.log('wash somewhere with it !!')
  }
}

class MountainWater extends Water {
  drink() {
    console.log('drink it !! you even feel like were are in mountain !!')
  }
}

class RiverWater extends Water {
  // 🔥🔥🔥shouldn't change parent class rule !!🔥🔥🔥
  drink() {
    throw new Error('Do not drink it !! this is dirty !!!!! dangerous !!!!')
  }
  shower() {
    console.log('you could take a shower with it, but be careful')
  }
}

const makeWaterDrink = (water: IWater) => {
  water.drink()
}

const waterInEverest = new MountainWater()
const waterFromTap = new RiverWater()

makeWaterDrink(waterInEverest)
makeWaterDrink(waterFromTap)

// drink it !! it is pure
// throw new Error('Do not drink it !! this is dirty !!!!! dangerous !!!!')

이 코드의 문제는 drink() function 가 void 이어야 하지만 당신은 throw error 이라는 것입니다.
네, 부모 클래스의 규칙을 따르지 않습니다 !!

👍 좋은 코드

// ⭐⭐ Divide interfaces 
interface IPureWater {
  shower: () => void
  drink: () => void
}

interface IDirtyWater {
  shower: () => void
  wash: () => void
}

class PureWater implements IPureWater {
  shower() {
    console.log('you can take a shower with it normally !!')
  }
  drink() {
    console.log('drink it !!')
  }
}

class DirtyWater implements IDirtyWater {
  shower() {
    console.log('you could take a shower, but be careful')
  }
  wash() {
    console.log('you can wash somewhere')
  }
  // ⭐⭐ You don't need to write about drink() ⭐⭐
  // because you divided interfaces
}

class MountainWater extends PureWater{
  drink() {
    console.log('drink it !!!  you even feel like you were in mountain !!')
  }
}

class RiverWater extends DirtyWater{}

const makeWaterDrink = (water: IPureWater) => {
  water.drink()
}

const makeWashWater = (water: IDirtyWater) => {
  water.wash()
}

const waterInEverest = new MountainWater()
const waterFromTap = new RiverWater()

makeWaterDrink(waterInEverest)
makeWashWater(waterFromTap)

// drink it !!!  you even feel like you are in mountain !!
// you can wash somewhere

인터페이스를 Iwater에서 IPureWater 및 IDirtyWater로 나누어 주셔서 감사합니다. 이제 모든 클래스가 부모 클래스 규칙을 따릅니다!!

이것은 간단한 리스코프 대체 샘플입니다.

😀 follow the rules of parent class !

(너무 간단해서 동의하지 않는 사람도 있겠지만, 초보자에게는 충분하다고 생각합니다)

심판
https://youtu.be/dJQMqNOC4Pc?t=324
https://www.membersedge.co.jp/blog/typescript-solid-liskov-substitution-principle/