Bốn tính chất OOP

public class BankAccount {
    // State được giấu kín
    private decimal _balance;
    private readonly string _owner;
    
    public BankAccount(string owner, decimal initial) {
        _owner = owner;
        _balance = initial >= 0 ? initial : 0;
    }
    
    // API expose có kiểm soát
    public decimal Balance => _balance;
    public string Owner => _owner;
    
    public void Deposit(decimal amount) {
        if (amount <= 0) throw new ArgumentException("Must be positive");
        _balance += amount;
    }
    
    public bool TryWithdraw(decimal amount) {
        if (amount <= 0 || amount > _balance) return false;
        _balance -= amount;
        return true;
    }
}

class BankAccount {
    // # = TRULY private (runtime enforced)
    #balance: number;
    readonly #owner: string;
    
    constructor(owner: string, initial: number) {
        this.#owner = owner;
        this.#balance = initial >= 0 ? initial : 0;
    }
    
    get balance(): number { return this.#balance; }
    get owner(): string { return this.#owner; }
    
    deposit(amount: number): void {
        if (amount <= 0) throw new Error("Must be positive");
        this.#balance += amount;
    }
    
    tryWithdraw(amount: number): boolean {
        if (amount <= 0 || amount > this.#balance) return false;
        this.#balance -= amount;
        return true;
    }
}

// Abstraction qua interface
public interface IPaymentGateway {
    Task<PaymentResult> ChargeAsync(decimal amount, string currency);
    Task<bool> RefundAsync(string transactionId);
}

// Implementation cụ thể — Caller không cần biết
public class StripeGateway : IPaymentGateway {
    public Task<PaymentResult> ChargeAsync(decimal amount, string currency) {
        // gọi Stripe API
    }
    public Task<bool> RefundAsync(string transactionId) { ... }
}

public class VnPayGateway : IPaymentGateway {
    public Task<PaymentResult> ChargeAsync(decimal amount, string currency) {
        // gọi VnPay API
    }
    public Task<bool> RefundAsync(string transactionId) { ... }
}

// Service chỉ phụ thuộc abstraction
public class CheckoutService {
    private readonly IPaymentGateway _gateway;
    public CheckoutService(IPaymentGateway gateway) => _gateway = gateway;
    
    public async Task Checkout(Order order) {
        var result = await _gateway.ChargeAsync(order.Total, "VND");
        // ...
    }
}

interface PaymentGateway {
    charge(amount: number, currency: string): Promise<PaymentResult>;
    refund(transactionId: string): Promise<boolean>;
}

class StripeGateway implements PaymentGateway {
    async charge(amount: number, currency: string) { /* Stripe API */ }
    async refund(transactionId: string) { /* ... */ return true; }
}

class VnPayGateway implements PaymentGateway {
    async charge(amount: number, currency: string) { /* VnPay API */ }
    async refund(transactionId: string) { /* ... */ return true; }
}

class CheckoutService {
    constructor(private gateway: PaymentGateway) {}
    
    async checkout(order: Order) {
        const result = await this.gateway.charge(order.total, "VND");
    }
}

public abstract class Animal {
    public string Name { get; }
    
    protected Animal(string name) => Name = name;
    
    // Hành vi chung
    public void Sleep() => Console.WriteLine($"{Name} is sleeping");
    
    // Hành vi con phải define
    public abstract string Speak();
}

public class Dog : Animal {
    public Dog(string name) : base(name) {}
    public override string Speak() => "Woof!";
    public void Fetch() => Console.WriteLine($"{Name} fetches the ball");
}

public class Cat : Animal {
    public Cat(string name) : base(name) {}
    public override string Speak() => "Meow!";
    public void Scratch() => Console.WriteLine($"{Name} scratches");
}

abstract class Animal {
    constructor(public readonly name: string) {}
    
    sleep(): void { console.log(`${this.name} is sleeping`); }
    
    abstract speak(): string;
}

class Dog extends Animal {
    constructor(name: string) { super(name); }
    speak(): string { return "Woof!"; }
    fetch(): void { console.log(`${this.name} fetches the ball`); }
}

class Cat extends Animal {
    constructor(name: string) { super(name); }
    speak(): string { return "Meow!"; }
    scratch(): void { console.log(`${this.name} scratches`); }
}

Animal[] zoo = { new Dog("Rex"), new Cat("Tom") };
foreach (var a in zoo) {
    Console.WriteLine($"{a.Name}: {a.Speak()}");
    // Runtime gọi Dog.Speak() hoặc Cat.Speak() đúng,
    // dù biến a kiểu Animal
}

const zoo: Animal[] = [new Dog("Rex"), new Cat("Tom")];
for (const a of zoo) {
    console.log(`${a.name}: ${a.speak()}`);
}

public class Calculator {
    public int Add(int a, int b) => a + b;
    public double Add(double a, double b) => a + b;
    public string Add(string a, string b) => a + b;
}

class Calculator {
    add(a: number, b: number): number;
    add(a: string, b: string): string;
    add(a: any, b: any): any { return a + b; }
}