Object oriented programming

Every program is data, plus the code that changes it. The only real question is where you keep the two. Keep them apart and, six months in, twelve functions across nine files all edit the same order object, and nobody can tell you which one set the total to zero.

Object oriented programming is one answer to that. Put the data and the code that is allowed to change it in the same place, and give that place a name.

A class is a recipe, an object is the dosa

A class describes what a thing knows and what it can do. An object is one actual thing made from that description. One recipe, many dosas, and eating one does not change the others.

class Rider {
  name: string
  deliveries = 0
 
  constructor(name: string) {
    this.name = name
  }
 
  deliver(): void {
    this.deliveries += 1
  }
}
 
const asha = new Rider('Asha')
const ravi = new Rider('Ravi')
 
asha.deliver()
asha.deliver()
 
console.log(asha.deliveries) // 2
console.log(ravi.deliveries) // 0

Four words carry this whole snippet. constructor runs once when an object is made. new is what makes it. this is the particular object the method was called on, which is why asha.deliver() did not touch Ravi’s count. And deliveries = 0 is a field with a default, so TypeScript infers it is a number.

The four pillars

Each pillar is an answer to one question you will keep asking about your own code. Learn the question and the name looks after itself.

All four in one screen

Do not try to learn the syntax here. Read the four comments, and notice that the pillars are not four separate features. They are four views of the same thirty lines.

// Abstraction: callers only know that a payment method can pay.
interface PaymentMethod {
  pay(amount: number): string
}
 
class Wallet implements PaymentMethod {
  // Encapsulation: nothing outside this class can touch the balance.
  private balance = 500
 
  pay(amount: number): string {
    this.balance -= amount
    return `Wallet paid ${amount}, ${this.balance} left`
  }
}
 
class Card implements PaymentMethod {
  pay(amount: number): string {
    return `Card charged ${amount}`
  }
}
 
// Inheritance: a credit card is a card, plus a little more.
class CreditCard extends Card {
  override pay(amount: number): string {
    return `${super.pay(amount)} on credit`
  }
}
 
// Polymorphism: one call, three different behaviours.
const methods: PaymentMethod[] = [
  new Wallet(),
  new Card(),
  new CreditCard(),
]
for (const method of methods) {
  console.log(method.pay(200))
}
// > Wallet paid 200, 300 left
// > Card charged 200
// > Card charged 200 on credit

The loop at the bottom is the payoff. It does not know which kind of payment method it is holding, and it does not need to. Add a fourth kind next month and the loop does not change.

Which pillar is this?

The four pages

Read them in this order. Each one uses the one before it.

Checkpoint