TypeScript 类

类（Class）是把数据（字段）与行为（方法）打包在一起的模板，用 new 可以批量创建实例。TypeScript 在 ES6 类语法之上增加了类型标注与访问修饰符，让面向对象代码既好读又能在编译期被检查。

定义类并实例化

class Student {
  name: string;   // 字段声明类型
  age: number;
  constructor(name: string, age: number) { this.name = name; this.age = age; }
  intro(): string { return `我是${this.name}，今年${this.age}岁`; }
}
const s = new Student("小明", 12); // new 触发构造函数
console.log(s.intro()); // 输出：我是小明，今年12岁

继承与 super

extends 继承父类，子类通过 super 调用父类构造函数与方法；参数属性（constructor(public name: string)）声明同时自动赋值：

class Person {
  constructor(public name: string) {}
  greet(): string { return `你好，我是${this.name}`; }
}
class Teacher extends Person {
  subject: string;
  constructor(name: string, subject: string) { super(name); this.subject = subject; }
  greet(): string { return `${super.greet()}，教${this.subject}`; } // 覆盖并复用父类逻辑
}
const t = new Teacher("王老师", "数学");
console.log(t.greet()); // 输出：你好，我是王老师，教数学

访问修饰符

public（默认，处处可访问）、private（仅类内部）、protected（本类与子类）：

class Account {
  public user: string;
  private pass: string;
  protected level: number;
  constructor(user: string, pass: string, level: number) { this.user = user; this.pass = pass; this.level = level; }
  check(p: string): boolean { return this.pass === p; } // 类内部可读私有字段
}
const acc = new Account("alice", "123", 1);
console.log(acc.user, acc.check("123")); // 输出：alice true
// console.log(acc.pass); // 报错：pass 是私有属性

静态成员与存取器

static 成员挂在类上而非实例上；get/set 拦截字段读写并可加校验：

class Counter {
  static count = 0; // 静态属性
  constructor() { Counter.count++; }
  static total(): number { return Counter.count; }
}
new Counter();
new Counter();
console.log(Counter.total()); // 输出：2

class Circle {
  private _r = 0;
  get radius(): number { return this._r; }
  set radius(v: number) { this._r = v >= 0 ? v : 0; } // 负数一律按 0 处理
}
const c = new Circle();
c.radius = 5;
console.log(c.radius); // 输出：5

instanceof 判断实例来源

class Car {}
const car = new Car();
console.log(car instanceof Car); // 输出：true（typeof car 只会得到 "object"）

小结

TypeScript 类 = ES6 类 + 类型系统：字段声明类型、修饰符控制可见性、extends/super 实现继承、static 与存取器完善设计。掌握类之后，再结合接口与抽象类就能搭出完整的面向对象结构。