在 TypeScript 中，类（Class） 是面向对象编程的核心，它是创建对象的模板，封装了属性与方法，让代码更具模块化、可复用性。本文将带你系统掌握 TS 类的核心知识点：类属性、构造函数、普通方法、访问修饰符、继承、抽象类与抽象方法，所有示例代码严格遵循规范编码格式。

一、类的基础：属性与构造函数

类是对象的抽象，我们通过class关键字定义类，用构造函数初始化对象属性，这是创建类的基础写法。

class Person {
    // 类属性定义
    NAME: string;
    AGE: number;

    // 构造函数：初始化对象
    constructor(name: string, age: number) {
        this.NAME = name;
        this.AGE = age;
    }

    // 普通方法
    show_info(): void {
        console.log("姓名：" + this.NAME + "，年龄：" + this.AGE);
    }
}

// 创建对象
const PERSON_OBJ = new Person("张三", 20);
PERSON_OBJ.show_info();

核心说明

• 类属性直接声明在类内部，用于存储对象状态。
• 构造函数constructor在创建对象时自动执行，完成属性初始化。
• 方法用于定义对象行为，通过对象调用执行。

---

二、类的访问修饰符

TypeScript 提供访问修饰符，控制类中属性和方法的访问权限，提升代码安全性。

常用修饰符

1. public：公共权限，默认值，类内外均可访问。
2. private：私有权限，仅当前类内部可访问。
3. protected：受保护权限，当前类与子类可访问，外部无法访问。
4. readonly：只读属性，初始化后不可修改。

class Student {
    // 公共属性
    public STU_ID: string;
    // 私有属性
    private GRADE: string;
    // 只读属性
    public readonly SCHOOL: string = "第一中学";

    constructor(stu_id: string, grade: string) {
        this.STU_ID = stu_id;
        this.GRADE = grade;
    }

    // 公共方法
    public show_stu(): void {
        // 类内可访问私有属性
        console.log("学号：" + this.STU_ID + "，年级：" + this.GRADE);
    }

    // 私有方法
    private check_grade(): boolean {
        return this.GRADE.length > 0;
    }
}

const STU_OBJ = new Student("S1001", "高一");
STU_OBJ.show_stu();
// 外部无法访问私有属性
// console.log(STU_OBJ.GRADE); 报错
// 只读属性不可修改
// STU_OBJ.SCHOOL = "第二中学"; 报错

---

三、类的继承

继承是面向对象的重要特性，通过extends关键字，子类可复用父类的属性与方法，还能扩展自身功能。

// 父类
class Animal {
    public TYPE: string;

    constructor(type: string) {
        this.TYPE = type;
    }

    public eat(): void {
        console.log(this.TYPE + "在进食");
    }
}

// 子类继承父类
class Dog extends Animal {
    public BARK: string;

    constructor(type: string, bark: string) {
        // 调用父类构造函数
        super(type);
        this.BARK = bark;
    }

    // 子类独有方法
    public sound(): void {
        console.log(this.TYPE + "：" + this.BARK);
    }

    // 重写父类方法
    public eat(): void {
        console.log(this.TYPE + "吃骨头");
    }
}

const DOG_OBJ = new Dog("小狗", "汪汪汪");
DOG_OBJ.eat();
DOG_OBJ.sound();

继承核心点

• 子类用super()调用父类构造函数，必须在构造函数第一行。
• 子类可重写父类方法，覆盖原有逻辑。
• 子类可访问父类public和protected成员。

---

四、抽象类与抽象方法

抽象类使用abstract关键字定义，不能直接创建对象，只能被继承。抽象方法只有声明，没有实现，必须由子类重写。

// 抽象类
abstract class Shape {
    // 抽象方法：无具体实现
    public abstract get_area(): number;

    // 普通方法
    public show_shape(): void {
        console.log("这是一个图形");
    }
}

// 子类继承抽象类，必须实现抽象方法
class Circle extends Shape {
    public RADIUS: number;

    constructor(radius: number) {
        super();
        this.RADIUS = radius;
    }

    // 实现抽象方法
    public get_area(): number {
        return 3.14 * this.RADIUS * this.RADIUS;
    }
}

// 子类继承抽象类
class Rectangle extends Shape {
    public WIDTH: number;
    public HEIGHT: number;

    constructor(width: number, height: number) {
        super();
        this.WIDTH = width;
        this.HEIGHT = height;
    }

    // 实现抽象方法
    public get_area(): number {
        return this.WIDTH * this.HEIGHT;
    }
}

const CIRCLE_OBJ = new Circle(5);
console.log("圆形面积：" + CIRCLE_OBJ.get_area());

const RECT_OBJ = new Rectangle(4, 6);
console.log("矩形面积：" + RECT_OBJ.get_area());

抽象类规则

• 包含抽象方法的类，必须是抽象类。
• 抽象方法不能有方法体，结尾用分号。
• 子类必须实现所有抽象方法，否则子类也需声明为抽象类。

---

五、静态属性与静态方法

使用static定义静态成员，属于类本身，不属于单个对象，直接通过类名访问。

class Math_tool {
    // 静态常量属性
    public static readonly PI: number = 3.14159;

    // 静态方法
    public static add(num1: number, num2: number): number {
        return num1 + num2;
    }
}

// 直接通过类名访问静态成员
console.log("圆周率：" + Math_tool.PI);
console.log("求和结果：" + Math_tool.add(10, 20));

---

六、总结

TypeScript 类与对象是前端工程化开发的基础，掌握以下核心点即可灵活运用：

1. 类封装属性与方法，构造函数完成初始化。
2. 修饰符控制访问权限，保护代码安全。
3. 继承实现代码复用，子类可扩展与重写。
4. 抽象类定义规范，子类强制实现逻辑。
5. 静态成员属于类，无需创建对象即可调用。