100天精通鸿蒙从入门到跳槽——第6天：TypeScript 知识储备：类

在这里插入图片描述

博主猫头虎的技术世界

🌟 欢迎来到猫头虎的博客 — 探索技术的无限可能！

专栏链接：

🔗 精选专栏：

《面试题大全》 — 面试准备的宝典！
《IDEA开发秘籍》 — 提升你的IDEA技能！
《100天精通Golang》 — Go语言学习之旅！
《100天精通鸿蒙》 — 从Web/安卓到鸿蒙大师！

100天精通鸿蒙OS（基础篇）

100天精通鸿蒙从入门到跳槽——第6天：TypeScript 知识储备：类
- 摘要🌟
- 一、引言📘
- 二、正文📝
- - 1. 类的定义
  - 2. 构造函数
  - 3. 成员变量
  - 4. 成员方法
  - 5. 静态成员和方法
- 三、总结📊
- 四、参考资料📚

100天精通鸿蒙从入门到跳槽——第6天：TypeScript 知识储备：类

在这里插入图片描述

摘要🌟

探索TypeScript的世界，第6天的篇章专注于类的结构与功能。在这里，我们将深入探讨类的定义、构造函数、成员变量和方法，这些是构建高效、安全、可靠代码的基石。TypeScript提供的类机制不仅加强了JavaScript的面向对象能力，还增强了代码的可读性和可维护性。本文是鸿蒙开发者和JavaScript程序员深化TypeScript技能的绝佳资源。关键词: TypeScript类, JavaScript面向对象, 高效代码编写, 安全编程实践, 鸿蒙开发技巧。

一、引言📘

随着 JavaScript 的广泛应用，开发人员越来越关注代码质量、可读性和可维护性。为了解决这些问题，TypeScript 应运而生。它为 JavaScript 添加了更多的类型信息，使得代码更加清晰、简洁和可维护。在 TypeScript 中，类是一种创建对象的蓝图，它定义了对象的结构和行为。通过类，我们可以创建更加高效、安全和可靠的代码。

二、正文📝

1. 类的定义

使用 class 关键字声明类。

以下是一个使用 class 关键字声明类的 TypeScript 代码案例：

// 使用 class 关键字声明一个类
class Animal {
  // 成员变量
  private name: string;
  age: number;

  // 构造函数
  constructor(name: string, age: number) {
    this.name = name;
    this.age = age;
  }

  // 成员方法
  public sayHello(): void {
    console.log(`Hello, my name is ${this.name} and I am ${this.age} years old.`);
  }
}

// 创建 Animal 类的实例
const dog = new Animal("Dog", 3);
dog.sayHello(); // 输出 "Hello, my name is Dog and I am 3 years old."

const cat = new Animal("Cat", 2);
cat.sayHello(); // 输出 "Hello, my name is Cat and I am 2 years old."

在这个示例中，我们使用 class 关键字声明了一个名为 Animal 的类。类中包含两个成员变量 name 和 age，以及一个构造函数，用于初始化这些变量。我们还定义了一个名为 sayHello 的成员方法，用于输出动物的个人信息。

然后，我们创建了两个 Animal 类的实例，分别赋值给 dog 和 cat。通过调用 sayHello 方法，我们可以看到每个实例的个人信息。

2. 构造函数

类中的构造函数用于初始化成员变量。

以下是一个使用构造函数初始化类成员变量的 TypeScript 代码案例：

// 使用 class 关键字声明一个类
class Person {
  // 成员变量
  private name: string;
  age: number;

  // 构造函数用于初始化成员变量
  constructor(name: string, age: number) {
    this.name = name;
    this.age = age;
  }

  // 成员方法
  public sayHello(): void {
    console.log(`Hello, my name is ${this.name} and I am ${this.age} years old.`);
  }
}

// 创建 Person 类的实例
const person = new Person("Alice", 30);

// 访问成员方法
person.sayHello(); // 输出 "Hello, my name is Alice and I am 30 years old."

在这个示例中，我们使用 class 关键字声明了一个名为 Person 的类。类中包含两个成员变量 name 和 age，以及一个构造函数，用于初始化这些变量。

然后，我们创建了一个 Person 类的实例，并使用构造函数的参数初始化成员变量。最后，我们访问了实例的 sayHello 成员方法，可以看到它使用了实例中的成员变量进行了输出。

3. 成员变量

类中的成员变量用于存储对象的属性。

以下是一个使用成员变量存储对象属性的 TypeScript 代码案例：

// 使用 class 关键字声明一个类
class Person {
  // 成员变量
  private name: string;
  age: number;

  // 构造函数用于初始化成员变量
  constructor(name: string, age: number) {
    this.name = name;
    this.age = age;
  }

  // 成员方法
  public sayHello(): void {
    console.log(`Hello, my name is ${this.name} and I am ${this.age} years old.`);
  }
}

// 创建 Person 类的实例
const person = new Person("Alice", 30);

// 访问成员变量
console.log(person.name); // 输出 "Alice"
console.log(person.age); // 输出 30

在这个示例中，我们使用 class 关键字声明了一个名为 Person 的类。类中包含两个成员变量 name 和 age，以及一个构造函数，用于初始化这些变量。

然后，我们创建了一个 Person 类的实例，并使用 person.name 和 person.age 访问了成员变量。通过访问成员变量，我们可以获取到实例的属性值。

4. 成员方法

类中的成员方法用于实现类的功能。

以下是一个使用成员方法实现类功能的 TypeScript 代码案例：

// 使用 class 关键字声明一个类
class Calculator {
  // 成员方法
  public add(a: number, b: number): number {
    return a + b;
  }

  public subtract(a: number, b: number): number {
    return a - b;
  }

  public multiply(a: number, b: number): number {
    return a * b;
  }

  public divide(a: number, b: number): number {
    if (b === 0) {
      throw new Error("除数不能为0");
    }
    return a / b;
  }
}

// 创建 Calculator 类的实例
const calculator = new Calculator();

// 使用成员方法
console.log(calculator.add(1, 2)); // 输出 3
console.log(calculator.subtract(4, 2)); // 输出 2
console.log(calculator.multiply(2, 3)); // 输出 6
console.log(calculator.divide(10, 2)); // 输出 5

在这个示例中，我们使用 class 关键字声明了一个名为 Calculator 的类。类中包含四个成员方法，分别用于实现加法、减法、乘法和除法功能。这些成员方法的名称与要实现的功能相关。

然后，我们创建了一个 Calculator 类的实例，并使用其成员方法进行计算。通过调用成员方法，我们可以看到它们实现了预期的功能。

5. 静态成员和方法

类中的静态成员和方法可以在不创建类实例的情况下使用。

以下是一个使用静态成员方法和静态方法在类外使用类的 TypeScript 代码案例：

// 使用 class 关键字声明一个类
class Animal {
  // 静态成员变量
  private static count: number = 0;

  // 构造函数
  constructor(name: string) {
    this.name = name;
    Animal.count++;
  }

  // 成员方法
  public sayHello(): void {
    console.log(`Hello, my name is ${this.name}.`);
  }

  // 静态成员方法
  public static incrementCount(): void {
    Animal.count++;
    console.log(`The total number of animals is ${Animal.count}.`);
  }
}

// 在类外部使用静态成员方法
Animal.incrementCount(); // 输出 "The total number of animals is 1."

// 创建 Animal 类的实例
const dog = new Animal("Dog");
dog.sayHello(); // 输出 "Hello, my name is Dog."

Animal.incrementCount(); // 输出 "The total number of animals is 2."

// 在类外部使用静态成员变量
console.log(Animal.count); // 输出 2

在这个示例中，我们使用 class 关键字声明了一个名为 Animal 的类。类中包含一个静态成员变量 count，以及一个构造函数、一个成员方法 sayHello 和一个静态成员方法 incrementCount。静态成员方法可以在不创建类实例的情况下使用，它们可以直接访问静态成员变量，而不需要创建类实例。

然后，我们在类外部使用静态成员方法 incrementCount 进行了一次调用，可以看到类中的静态成员变量 count 也得到了增加。最后，我们在类外部访问了静态成员变量 count，可以看到它的值已经发生了变化。

三、总结📊

在本篇博客中，我们全面探索了TypeScript中类的精髓，深入理解了类的定义、构造函数、成员变量和方法等核心概念。这些知识不仅加深了我们对面向对象编程的理解，也使我们能够更加熟练地运用TypeScript的强大特性，进而打造出既高效又安全的代码。对于致力于提升代码质量和开发效率的鸿蒙开发者和JavaScript程序员来说，这些概念是至关重要的。掌握它们，意味着我们在编程的道路上又向前迈进了一大步。

🔍 接下来的探索

如果你对TypeScript和鸿蒙开发充满兴趣，不要错过我们的下一篇博客：“100天精通鸿蒙——第7天：深入探讨TypeScript中的接口 ”。在那里，我们将继续探索TypeScript的高级特性，帮助你进一步提升开发技能。🌟

👉 点击这里继续阅读下一篇

我们期待与您一起在鸿蒙开发的旅程中不断成长和探索新的高度！🚀💡🌐