🎬 HoRain云小助手：个人主页

 🔥 个人专栏: 《Linux 系列教程》《c语言教程》

⛺️生活的理想，就是为了理想的生活!

---

⛳️ 推荐

前些天发现了一个超棒的服务器购买网站，性价比超高，大内存超划算！忍不住分享一下给大家。点击跳转到网站。

专栏介绍

专栏名称	专栏介绍
《C语言》	本专栏主要撰写C干货内容和编程技巧，让大家从底层了解C，把更多的知识由抽象到简单通俗易懂。
《网络协议》	本专栏主要是注重从底层来给大家一步步剖析网络协议的奥秘，一起解密网络协议在运行中协议的基本运行机制！
《docker容器精解篇》	全面深入解析 docker 容器，从基础到进阶，涵盖原理、操作、实践案例，助您精通 docker。
《linux系列》	本专栏主要撰写Linux干货内容，从基础到进阶，知识由抽象到简单通俗易懂，帮你从新手小白到扫地僧。
《python 系列》	本专栏着重撰写Python相关的干货内容与编程技巧，助力大家从底层去认识Python，将更多复杂的知识由抽象转化为简单易懂的内容。
《试题库》	本专栏主要是发布一些考试和练习题库（涵盖软考、HCIE、HRCE、CCNA等）

目录

⛳️ 推荐

专栏介绍

🧱 1. 类的基本构成与实例化

🔐 2. 访问修饰符 (Access Modifiers)

📏 3. 只读属性 (readonly)

📊 4. 静态成员 (static)

🧬 5. 类的继承 (extends与 super)

🌀 6. 抽象类 (abstract)

📑 7. 接口与类 (implements)

🔍 8. 存取器 (Getters 和 Setters)

🧪 9. 参数属性 (Parameter Properties)

💡 总结与最佳实践

---

TypeScript 中的类是面向对象编程（OOP）的核心，它基于 ES6 的类，并通过类型系统、访问控制等特性增强了代码的安全性、可读性和可维护性。下面我将为你系统梳理 TypeScript 类的核心知识点。

🧱 1. 类的基本构成与实例化

类作为对象的蓝图，封装了属性（数据）和方法（行为）。

• ​​定义类​​：使用 class关键字。

  class Person {
    name: string;   // 属性声明
    age: number;
  
    constructor(name: string, age: number) { // 构造函数
      this.name = name;
      this.age = age;
    }
  
    greet(): void { // 方法
      console.log(`Hello, my name is ${this.name}.`);
    }
  }

• ​​实例化​​：使用 new关键字创建对象实例。

  const person = new Person("Alice", 30);
  person.greet(); // 输出: Hello, my name is Alice.

🔐 2. 访问修饰符 (Access Modifiers)

TypeScript 提供了三种访问修饰符来控制类成员的可见性：

修饰符	类内部	子类	类外部	说明
public	✅	✅	✅	默认修饰符，成员在任何地方都可见。
private	✅	❌	❌	成员只能在声明它的​​类内部​​访问。
protected	✅	✅	❌	成员只能在声明它的​​类及其子类​​中访问。

class Example {
  public publicField: string;
  private privateField: string;
  protected protectedField: string;

  constructor(pub: string, pri: string, pro: string) {
    this.publicField = pub;
    this.privateField = pri;
    this.protectedField = pro;
  }
}

class SubExample extends Example {
  show(): void {
    console.log(this.publicField);    // OK
    console.log(this.protectedField); // OK
    // console.log(this.privateField); // Error: 私有成员，无法访问
  }
}

const ex = new Example("pub", "pri", "pro");
console.log(ex.publicField);    // OK
// console.log(ex.privateField);  // Error: 私有成员，无法访问
// console.log(ex.protectedField); // Error: 受保护成员，无法访问

📏 3. 只读属性 (readonly)

使用 readonly关键字声明的属性必须在声明时或构造函数中初始化，之后不能再被修改。

class Circle {
  readonly PI: number = 3.14159;
  readonly radius: number;

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

  calculateArea(): number {
    return this.PI * this.radius * this.radius;
  }
}

const circle = new Circle(5);
// circle.radius = 10; // Error: 无法分配到 "radius" ，因为它是只读属性

📊 4. 静态成员 (static)

静态成员属于类本身，而不是类的实例。通过 类名.静态成员名访问。

class MathUtils {
  static PI: number = 3.14159;

  static calculateCircumference(radius: number): number {
    return 2 * this.PI * radius;
  }
}

console.log(MathUtils.PI); // 输出: 3.14159
console.log(MathUtils.calculateCircumference(5)); // 输出: 31.4159

🧬 5. 类的继承 (extends与 super)

TypeScript 支持使用 extends关键字实现单继承。

• ​​基本继承​​：

  class Animal {
    name: string;
  
    constructor(name: string) {
      this.name = name;
    }
  
    move(distance: number = 0): void {
      console.log(`${this.name} moved ${distance}m.`);
    }
  }
  
  class Dog extends Animal {
    constructor(name: string) {
      super(name); // 调用父类的构造函数
    }
  
    bark(): void {
      console.log("Woof! Woof!");
    }
  }
  
  const dog = new Dog("Rufus");
  dog.bark();  // 输出: Woof! Woof!
  dog.move(10); // 输出: Rufus moved 10m.

• ​​方法重写 (Override)​​：子类可以重写父类的方法。

  class Cat extends Animal {
    constructor(name: string) {
      super(name);
    }
  
    move(distance: number = 5): void { // 重写move方法
      console.log(`${this.name} moved ${distance}m silently.`);
    }
  }
  
  const cat = new Cat("Whiskers");
  cat.move(); // 输出: Whiskers moved 5m silently.

🌀 6. 抽象类 (abstract)

抽象类作为其他类的基类，不能直接实例化。抽象方法不包含实现且必须在派生类中实现。

abstract class Shape {
  constructor(public color: string) {}

  abstract getArea(): number; // 抽象方法，无实现

  displayColor(): void { // 具体方法
    console.log(`Color: ${this.color}`);
  }
}

class Circle extends Shape {
  constructor(color: string, public radius: number) {
    super(color);
  }

  getArea(): number { // 实现抽象方法
    return Math.PI * this.radius * this.radius;
  }
}

// const shape = new Shape("blue"); // Error: 无法创建抽象类的实例
const circle = new Circle("red", 5);
console.log(circle.getArea()); // 输出: ~78.54
circle.displayColor(); // 输出: Color: red

📑 7. 接口与类 (implements)

接口 (Interface) 用于定义类的公共契约（结构），类使用 implements关键字来实现一个或多个接口。

interface Drivable {
  start(): void;
  stop(): void;
  speed: number;
}

interface Fuelable {
  fuelType: string;
  refuel(amount: number): void;
}

class Car implements Drivable, Fuelable { // 实现多个接口
  speed: number = 0;
  fuelType: string = "gasoline";

  start(): void {
    console.log("Car started.");
  }

  stop(): void {
    console.log("Car stopped.");
    this.speed = 0;
  }

  refuel(amount: number): void {
    console.log(`Refueled with ${amount} liters of ${this.fuelType}.`);
  }
}

🔍 8. 存取器 (Getters 和 Setters)

通过 get和 set关键字拦截对对象成员的访问和赋值，常用于数据验证或关联操作。

class Employee {
  private _fullName: string = "";

  get fullName(): string {
    return this._fullName;
  }

  set fullName(newName: string) {
    if (newName && newName.length > 0) {
      this._fullName = newName;
    } else {
      console.error("Invalid name!");
    }
  }
}

const emp = new Employee();
emp.fullName = "John Doe"; // 调用 setter
console.log(emp.fullName); // 调用 getter, 输出: John Doe
emp.fullName = ""; // 调用 setter, 输出: Invalid name!

🧪 9. 参数属性 (Parameter Properties)

参数属性允许在构造函数参数前直接使用修饰符（public, private, protected, readonly）来声明并初始化成员属性，简化代码。

class Person {
  // 直接在构造函数参数中声明并初始化属性
  constructor(public name: string, private age: number, readonly id: string) {}
}

// 等同于
// class Person {
//   name: string;
//   private age: number;
//   readonly id: string;
//   constructor(name: string, age: number, id: string) {
//     this.name = name;
//     this.age = age;
//     this.id = id;
//   }
// }

const person = new Person("Alice", 30, "ID-123");
console.log(person.name); // OK
// console.log(person.age); // Error: 私有成员
// person.id = "NEW-ID";   // Error: 只读属性

💡 总结与最佳实践

1. ​​封装与访问控制​​：善用 private和 protected修饰符来封装内部实现细节，只暴露必要的公共 API (public)。这有助于降低代码耦合度，提高健壮性。

2. ​​保持单一职责​​：一个类应该只有一个引起它变化的原因。确保类的职责清晰且单一。

3. ​​优先使用组合而非继承​​：继承虽然强大，但会带来较高的耦合度。在合适的情况下，考虑使用组合（将其他类的实例作为属性）来替代继承，以获得更大的灵活性。

4. ​​面向接口编程​​：多使用接口来定义契约，而不是依赖具体的类。这可以提高代码的模块化和可测试性。

5. ​​慎用 static​​：过度使用静态成员和方法可能导致代码难以测试和耦合度过高。

TypeScript 的类系统通过静态类型系统和丰富的面向对象特性，帮助你构建出结构清晰、易于维护和扩展的应用程序。希望这些信息能帮助你更好地理解和使用 TypeScript 类！

❤️❤️❤️本人水平有限，如有纰漏，欢迎各位大佬评论批评指正！😄😄😄

💘💘💘如果觉得这篇文对你有帮助的话，也请给个点赞、收藏下吧，非常感谢!👍 👍 👍

🔥🔥🔥Stay Hungry Stay Foolish 道阻且长,行则将至,让我们一起加油吧！🌙🌙🌙