7.3 静态方法与私有字段（# 语法）

7.3 静态方法与私有字段（# 语法）

在 JavaScript 的面向对象编程中，静态方法和私有字段是两种重要的特性。静态方法属于类本身而不是实例，而私有字段则用于限制类内部属性的访问。ES6 引入了静态方法，而 ES2022 引入了私有字段的 # 语法。本节将详细介绍这两种特性的用法。

7.3.1 静态方法

静态方法是属于类本身的方法，而不是类的实例。它们通常用于实现与类相关的工具函数或工厂方法。

1. 定义静态方法
使用 static 关键字定义静态方法：

class MathUtils {
  static add(a, b) {
    return a + b;
  }

  static subtract(a, b) {
    return a - b;
  }
}

console.log(MathUtils.add(1, 2)); // 输出 3
console.log(MathUtils.subtract(5, 3)); // 输出 2

2. 静态方法的继承
静态方法可以被继承：

class Animal {
  static info() {
    console.log("This is an animal class.");
  }
}

class Dog extends Animal {}

Dog.info(); // 输出 "This is an animal class."

3. 静态方法中的 this
在静态方法中，this 指向类本身，而不是实例：

class Counter {
  static count = 0;

  static increment() {
    this.count++;
    console.log(`Count: ${this.count}`);
  }
}

Counter.increment(); // 输出 "Count: 1"
Counter.increment(); // 输出 "Count: 2"

7.3.2 私有字段（# 语法）

私有字段是类内部使用的属性，外部无法直接访问。ES2022 引入了 # 语法来定义私有字段。

1. 定义私有字段
使用 # 前缀定义私有字段：

class Person {
  #name; // 私有字段
  age;   // 公共字段

  constructor(name, age) {
    this.#name = name;
    this.age = age;
  }

  getName() {
    return this.#name;
  }
}

const person = new Person("Alice", 25);
console.log(person.getName()); // 输出 "Alice"
console.log(person.age); // 输出 25
console.log(person.#name); // 报错：Private field '#name' must be declared in an enclosing class

2. 私有字段的限制

• 私有字段只能在类的内部访问，外部无法直接访问。
• 私有字段不能被继承。

3. 私有方法
私有字段的概念也可以扩展到方法：

class Counter {
  #count = 0;

  #increment() {
    this.#count++;
  }

  tick() {
    this.#increment();
    console.log(`Count: ${this.#count}`);
  }
}

const counter = new Counter();
counter.tick(); // 输出 "Count: 1"
counter.tick(); // 输出 "Count: 2"
counter.#increment(); // 报错：Private field '#increment' must be declared in an enclosing class

7.3.3 示例代码

示例 1：静态方法

class Logger {
  static log(message) {
    console.log(`[LOG] ${message}`);
  }

  static error(message) {
    console.error(`[ERROR] ${message}`);
  }
}

Logger.log("This is a log message."); // 输出 "[LOG] This is a log message."
Logger.error("This is an error message."); // 输出 "[ERROR] This is an error message."

示例 2：私有字段

class BankAccount {
  #balance = 0;

  deposit(amount) {
    this.#balance += amount;
    console.log(`Deposited ${amount}. New balance: ${this.#balance}`);
  }

  withdraw(amount) {
    if (amount > this.#balance) {
      console.log("Insufficient funds.");
    } else {
      this.#balance -= amount;
      console.log(`Withdrew ${amount}. New balance: ${this.#balance}`);
    }
  }
}

const account = new BankAccount();
account.deposit(100); // 输出 "Deposited 100. New balance: 100"
account.withdraw(50); // 输出 "Withdrew 50. New balance: 50"
account.withdraw(100); // 输出 "Insufficient funds."

7.3.4 总结

• 静态方法：属于类本身，通过 static 关键字定义，通常用于工具函数或工厂方法。
• 私有字段：使用 # 语法定义，只能在类的内部访问，外部无法直接访问。
• 私有方法：类似于私有字段，只能在类的内部调用。

通过掌握静态方法和私有字段，你可以编写更安全、更模块化的面向对象代码。在接下来的学习中，我们将继续探索 JavaScript 的其他高级特性。

思考题：

1. 静态方法的主要用途是什么？
2. 私有字段如何提高代码的安全性？
3. 在什么情况下应该使用私有方法？