SOLID : liskov substitution

definiton of liskov substitution is like that

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

But simply put, it would be just

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

I'm gonna show you sample code, but don't forget this simple definition that I created

👎 Bad code

You want to drink water, and make MountainWater and RiverWater, then drink them

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 !!!!')

Problem in this code is that drink() function should be void, but you throw error.
Yeah you don't follow rules of parent class !!

👍 Good code

// ⭐⭐ 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

Thanks for dividing interface from just Iwater to IPureWater and IDirtyWater, all classes follow parent class rule now !!

This is simple liskov substitution sample

---

😀 follow the rules of parent class !

(Someone wouldn't agree with that, because it's too simple, but for beginners it's enough, I think)

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