类与面向对象

class Point {
    x: number
    y: number

    constructor(x: number, y: number) {
        this.x = x
        this.y = y
    }

    distance(): number {
        return Math.sqrt(this.x ** 2 + this.y ** 2)
    }
}

const p = new Point(3, 4)
console.log(p.distance()) // 5

class User {
    constructor(
        private name: string,
        private age: number = 18
    ) {}

    public toString(): string {
        return `[Name] ${this.name} [Age] ${this.age}`
    }
}

const u = new User("willow", 28)
console.log(u.toString()) // [Name] willow [Age] 28

class Point {
    x: number
    y: number
    constructor(x: number, y: number)
    constructor(xy: string)
    constructor(x: number | string, y?: number) {
        if (typeof x === "string") {
            const parts = x.split(",")
            this.x = parseInt(parts[0])
            this.y = parseInt(parts[1])
        } else {
            this.x = x
            this.y = y!
        }
    }
}

class Parent {
    protected method(): void {
        console.log("parent")
    }
}

class Child extends Parent {
    // ✅ OK: protected → public（更宽松）
    public method(): void {
        console.log("child")
    }
    // ❌ Error: protected → private（更严格）
    // private method(): void {}
}

class Config {
    readonly apiUrl: string = "https://api.example.com"

    constructor(url?: string) {
        if (url) this.apiUrl = url
    }
}

const config = new Config()
// config.apiUrl = "other"  // ❌ Error: Cannot assign to 'apiUrl' because it is a read-only property.

class User {
    private _name: string

    constructor(name: string) {
        this._name = name
    }

    get name(): string {
        return this._name
    }

    set name(value: string) {
        if (!value) throw new Error("Name required")
        this._name = value
    }
}

const user = new User("John")
user.name = "Jane"
console.log(user.name) // Jane

class MyMath {
    static readonly PI = 3.14159

    static circleArea(r: number): number {
        return this.PI * r * r
    }

    static sum(a: number, b: number): number {
        return a + b
    }
}

console.log(MyMath.sum(1, 2))       // 3
console.log(MyMath.circleArea(2))   // 12.56636

abstract class Mover {
    abstract move(x: number, y: number): void

    // 抽象类可以有具体方法
    logMove(x: number, y: number): void {
        console.log(`Moving to (${x}, ${y})`)
    }
}

class Person extends Mover {
    // ✅ 必须实现抽象方法
    move(x: number, y: number): void {
        this.logMove(x, y)
        console.log("Person is walking")
    }
}

const p = new Person()
p.move(1, 2)
// const m = new Mover()  // ❌ Error: Cannot create an instance of an abstract class.

interface Printable {
    print(): void
}

interface Storable {
    save(path: string): void
}

class Document implements Printable, Storable {
    print(): void {
        console.log("printing...")
    }

    save(path: string): void {
        console.log(`saving to ${path}`)
    }
}

class BankAccount {
    #balance: number = 0

    deposit(amount: number): void {
        this.#balance += amount
    }

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

const account = new BankAccount()
account.deposit(100)
console.log(account.getBalance()) // 100
// account.#balance  // ❌ SyntaxError: Private field '#balance' must be declared in an enclosing class

class Box<T> {
    contents: T

    constructor(value: T) {
        this.contents = value
    }

    unwrap(): T {
        return this.contents
    }
}

const stringBox = new Box("hello")     // Box<string>
const numberBox = new Box(42)          // Box<number>

console.log(stringBox.unwrap())        // "hello"

class Button {
    label: string = "Submit"

    click(this: Button): void {
        console.log(`Clicked: ${this.label}`)
    }
}

const btn = new Button()
btn.click() // ✅ OK

const detached = btn.click
// detached()  // ❌ Error: The 'this' context of type 'void' is not assignable to method's 'this' of type 'Button'.

class Config {
    static settings: Record<string, string>

    static {
        // 在类加载时执行一次
        this.settings = { env: "production", region: "us-east-1" }
    }
}

console.log(Config.settings.env) // "production"

function log(value: any, ctx: ClassMethodDecoratorContext) {
    const methodName = String(ctx.name)
    return function (this: any, ...args: any[]) {
        console.log(`[${methodName}] called with`, args)
        return value.call(this, ...args)
    }
}

class Service {
    @log
    getData(id: number): string {
        return `data-${id}`
    }
}

const svc = new Service()
svc.getData(5) // [getData] called with [5]

const Point = class {
    constructor(public x: number, public y: number) {}
}

const p = new Point(1, 2)
console.log(p.x, p.y) // 1 2