js class constructor类构造函数|极客笔记

js class constructor类构造函数

在JavaScript中，类是一种面向对象编程的基本概念。它是一种将相关数据和功能组合在一起的方式，以便更好地组织和管理代码。类可以用于创建多个对象实例，并提供了一种定义这些实例的结构和行为的机制。

什么是类构造函数

在JavaScript中，类是通过构造函数来定义和实现的。构造函数是一个特殊的函数，其名称通常以大写字母开头，用于创建类的实例。通过使用new关键字调用构造函数，可以创建一个新的对象实例。

类构造函数通常包含类的属性和方法。类的属性是属于类实例的变量，用于存储对象的状态。类的方法是定义在类原型上的函数，用于描述对象的行为。

下面是一个简单的示例代码展示了一个类构造函数的基本结构：

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

  getInfo() {
    return ` ${this.name} is$ {this.age} years old.`;
  }
}

const john = new Person("John", 25);
console.log(john.getInfo()); // 输出：John is 25 years old.

在上面的示例中，我们创建了一个名为Person的类构造函数。Person类有两个属性name和age，以及一个方法getInfo。当我们使用new关键字创建一个Person对象实例时，构造函数constructor将被调用，并将传入的参数赋值给实例的属性。然后，我们可以通过调用getInfo方法来获取实例的描述信息。

类的继承

继承是面向对象编程中另一个重要的概念，它允许我们从已有的类中派生出新的类，并且能够继承原有类的属性和方法。在JavaScript中，我们可以通过使用关键字extends来实现继承。

下面是一个示例代码，演示了如何使用继承创建一个新的类，并继承原有类的属性和方法：

class Student extends Person {
  constructor(name, age, grade) {
    super(name, age);
    this.grade = grade;
  }

  getInfo() {
    return `Name:  ${this.name}, Age:$ {this.age}, Grade: ${this.grade}`;
  }
}

const jane = new Student("Jane", 18, "A");
console.log(jane.getInfo()); // 输出：Name: Jane, Age: 18, Grade: A

在上面的示例中，我们创建了一个名为Student的新类，并使用extends关键字将其继承自Person类。Student类有一个额外的属性grade，并且重写了父类Person的getInfo方法。在Student类的构造函数中，我们使用super关键字调用了父类的构造函数，以便初始化继承的属性。

通过继承，我们可以复用现有的类的属性和方法，并且可以在新创建的类中进行扩展和修改。

类的静态方法

除了实例方法之外，类还可以定义静态方法。静态方法是类和实例都可以访问的方法，但是静态方法不能直接访问实例的属性。

下面是一个示例代码，演示了如何在类中定义和使用静态方法：

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

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

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

在上面的示例中，我们创建了一个名为MathUtils的类，并在其中定义了两个静态方法add和subtract。这些静态方法可以直接通过类名进行调用，而无需创建类的实例。

类的访问修饰符

在类中，我们可以使用访问修饰符来控制属性和方法的可访问性。访问修饰符有三种类型：public、private和protected。

public：公开的属性和方法可以在类的内部和外部访问。
private：私有的属性和方法只能在类的内部访问。
protected：受保护的属性和方法可以在类的内部和子类中访问。

下面是一个示例代码，演示了如何使用访问修饰符：

class BankAccount {
  private balance;

  constructor(balance) {
    this.balance = balance;
  }

  public deposit(amount) {
    this.balance += amount;
  }

  public withdraw(amount) {
    if (amount <= this.balance) {
      this.balance -= amount;
    } else {
      console.log("Insufficient balance.");
    }
  }

  protected getBalance() {
    return this.balance;
  }
}

class SavingsAccount extends BankAccount {
  constructor(balance) {
    super(balance);
  }

  public calculateInterest() {
    const balance = this.getBalance();
    const interest = balance * 0.05;
    console.log(`Interest: ${interest}`);
  }
}

const account = new BankAccount(1000);
account.deposit(500);
account.withdraw(200);
console.log(account.getBalance()); // 编译错误，无法访问私有方法

const savingsAccount = new SavingsAccount(2000);
savingsAccount.calculateInterest(); // 输出：Interest: 100

在上面的示例中，我们创建了一个名为BankAccount的类，并在其属性和方法中使用了不同的访问修饰符。私有属性balance只能在类的内部访问，对外部是不可见的。公开方法deposit和withdraw可以在类的内部和外部访问。受保护方法getBalance可以在类的内部和继承的子类中访问。

在SavingsAccount类中，我们继承了BankAccount类，并对外提供了额外的方法calculateInterest，该方法可以利用getBalance来获取账户余额，并计算利息。