Classes & OOP.
Runtime identity, when you need it.

// ─── A typed class ────────────────────────────
class User {
// Field declarations with types
id: string;
name: string;
email: string;
createdAt: Date;

// Constructor with typed parameters
constructor(id: string, name: string, email: string) {
this.id = id;
this.name = name;
this.email = email;
this.createdAt = new Date();
}

// Typed methods
greet(): string {
return Hi, I'm ${this.name}`;
}

rename(newName: string): void {
this.name = newName;
}
}

// ─── Using the class ──────────────────────────
const alice = new User('u_1', 'Alice', 'a@example.com');
alice.rename('Alicia');

// ─── Classes are types AND values ─────────────
// User is a type (for annotations) and a value (for new).
function greetUser(u: User): string {
return u.greet();
}

// ─── instanceof works — classes are runtime ────
if (alice instanceof User) {
console.log('confirmed User instance');
}

console.log(greetUser(alice));
console.log(alice.createdAt instanceof Date);

class Account {
readonly id: string; // public by default, read-only
public owner: string; // explicit public (same as default)
private balance: number = 0; // only this class can read/write
protected history: string[] = []; // this class + subclasses

constructor(id: string, owner: string) {
this.id = id;
this.owner = owner;
}

deposit(amount: number): void {
if (amount <= 0) throw new Error('Invalid amount');
this.balance += amount;
this.history.push(+${amount}`);
}

getBalance(): number {
return this.balance;
}
}

class SavingsAccount extends Account {
interestRate: number;

constructor(id: string, owner: string, rate: number) {
super(id, owner);
this.interestRate = rate;
}

showHistory(): string[] {
// ✅ protected is accessible in subclasses
return this.history;
// return this.balance; // ❌ private is NOT accessible
}
}

const a = new Account('a1', 'Alice');
a.deposit(100);
console.log(a.getBalance());
// console.log(a.balance); // ❌ Property 'balance' is private
// a.balance = 999; // ❌ Cannot assign to private

const s = new SavingsAccount('a2', 'Bob', 0.05);
s.deposit(200);
console.log(s.showHistory());

// ─── Without parameter properties (verbose) ──
class VerboseUser {
readonly id: string;
name: string;
private email: string;
protected role: 'user' | 'admin';

constructor(
id: string,
name: string,
email: string,
role: 'user' | 'admin'
) {
this.id = id;
this.name = name;
this.email = email;
this.role = role;
}
}

// ─── With parameter properties (concise) ──────
class ConciseUser {
constructor(
public readonly id: string,
public name: string,
private email: string,
protected role: 'user' | 'admin'
) {}
// Typescript generates:
// - field declarations
// - this.id = id; this.name = name; etc. in the constructor

getEmail(): string {
return this.email; // private is accessible inside
}
}

// ─── Mixed: parameter props + regular assignment
class Mixed {
private token: string;

constructor(
public name: string, // param property
token: string // plain param — not a field
) {
this.token = token.trim(); // custom logic before assigning
}

hasToken(): boolean {
return this.token.length > 0;
}
}

const u = new ConciseUser('u_1', 'Alice', 'a@x.com', 'admin');
u.name = 'Alicia'; // ✅ public
// u.id = 'new'; // ❌ readonly

const m = new Mixed('Bob', ' tok123 ');

console.log(u.getEmail(), u.name);
console.log(m.hasToken());

// ─── implements: satisfy a contract ──────────
interface Shape {
area(): number;
perimeter(): number;
}

class Circle implements Shape {
constructor(public radius: number) {}
area() { return Math.PI * this.radius ** 2; }
perimeter() { return 2 * Math.PI * this.radius; }
}

class Square implements Shape {
constructor(public side: number) {}
area() { return this.side ** 2; }
perimeter() { return 4 * this.side; }
}

// ─── A class can implement many interfaces ────
interface Named { name: string; }
interface Serializable { serialize(): string; }

class Widget implements Named, Serializable {
constructor(public name: string) {}
serialize() { return JSON.stringify({ name: this.name }); }
}

// ─── extends: inherit implementation ─────────
class Animal {
constructor(public name: string) {}
speak(): string { return '...'; }
introduce(): string { return I'm ${this.name}`; }
}

class Dog extends Animal {
speak(): string { return 'Woof'; } // overrides
// introduce() inherited for free
}

// ─── Combining both ──────────────────────────
interface Serializable2 { serialize(): string; }

class User extends Animal implements Serializable2 {
constructor(name: string, public email: string) {
super(name);
}
serialize() { return JSON.stringify({ name: this.name, email: this.email }); }
}

const shapes: Shape[] = [new Circle(2), new Square(3)];
shapes.forEach(s => console.log(s.area().toFixed(2)));

const d = new Dog('Rex');
console.log(d.speak(), d.introduce());

// ─── Abstract class ──────────────────────────
abstract class Shape {
constructor(public readonly name: string) {}

// Abstract methods: no body. Subclasses MUST implement.
abstract area(): number;
abstract perimeter(): number;

// Concrete method: shared by all subclasses.
describe(): string {
return ${this.name}: area=${this.area().toFixed(2)}, perimeter=${this.perimeter().toFixed(2)}`;
}
}

// ─── Subclasses implement abstract members ────
class Circle extends Shape {
constructor(public radius: number) { super('Circle'); }
area() { return Math.PI * this.radius ** 2; }
perimeter() { return 2 * Math.PI * this.radius; }
}

class Square extends Shape {
constructor(public side: number) { super('Square'); }
area() { return this.side ** 2; }
perimeter() { return 4 * this.side; }
}

// ─── Cannot instantiate the abstract class ───
// const s = new Shape('X'); // ❌ Cannot create an instance of an abstract class

// ─── But can use it as a type ────────────────
const shapes: Shape[] = [
new Circle(2),
new Square(3)
];

shapes.forEach(s => console.log(s.describe()));

// ─── Forgetting an abstract method errors ────
class Broken extends Shape {
constructor() { super('Broken'); }
area() { return 0; }
// ❌ Non-abstract class 'Broken' does not implement
// inherited abstract member 'perimeter'
}