Class（类）-CSDN博客

本文链接：https://blog.csdn.net/2302_81009692/article/details/142416042

前言

一、类的表达式和声明

二、constructor()方法

三、Class的静态属性和静态方法（static）

四、Class的私有属性和方法（#）

五、继承（ extends）

前言

类是用于创建对象的模板，它们用代码封装数据以对其进行处理。JS 中的类建立在原型之上。

类的主体是其被花括号 {} 包裹的部分。这里是你定义方法或构造函数等类成员的地方。

一、类的表达式和声明

类实际上是“特殊的函数”，类也有两种定义方式：类表达式和类声明

与函数表达式类似，然而，不同于函数声明的是，类声明具有与 let 和 const 相同的暂时性死区限制，并且表现得像是没有被提升一样。

1、类声明

// 声明一个class   
class Person {


}

2、类表达式

// 类是匿名的，但是它被赋值给了变量
const Rectangle = class {



};

// 类有它自己的名字
const Rectangle = class Rectangle2 {



};

二、constructor()方法

constructor() 方法是类的默认方法，通过 new 命令生成对象实例时，自动调用该方法。

一个类必须有 constructor() 方法，如果没有显式定义，一个空的 constructor() 方法会被默认添加

class Point {

}

// 等同于

class Point {

  constructor() {}

}

使用代码：

    // 声明一个class
    class Person {
        // 构造函数
        constructor(a, b) {
            this.a = a;
            this.b = b;
        }
    }


 var p1 = new Person(1, 2);
 console.log(p1);

这段代码定义了一个名为 Person 的 JavaScript 类，并创建了一个该类的实例 p1，然后打印了这个实例

Class里面的constructor(a, b){}定义了一个构造函数，用于创建类的新实例时初始化属性。构造函数接受两个参数 a 和 b

constructor里面的this.a = a; 和 this.b = b;：在构造函数内部，使用 this 关键字将传入的参数 a 和 b 分别赋值给实例的属性 a 和 b

后台打印结果：

三、Class的静态属性和静态方法（static）

类的静态属性是定义在类本身上的属性，而不是定义在类的实例上的属性。

关键词：static

使用方法：

    class Person {
        // 静态属性：
        // 类本身就含有而不是实例特有的，直接可以通过类名来调用
        static type = 'people'
        // 构造函数
        constructor(name, age) {
            this.name = name;
            this.age = age;
        }
        // 静态方法
        static eat() {
            console.log('肉');
        }
    }

   //打印静态属性
   console.log(Person.type);
   //调用静态方法
   Person.eat();

后台打印结果：

四、Class的私有属性和方法（#）

私有属性和方法是指那些只能在类内部访问的属性和方法。它们对于类的外部是不可见的，这有助于封装和隐藏类的内部实现细节。

私有属性和方法的名称前使用 # 符号来表示

    class Person {
        // 私有属性
        #name;
        #age;
        constructor(name, age) {
            this.#name = name;
            this.#age = age;
        }
        // 私有方法
        #my() {
           return 'I like you'
            
        }

        introduce() {
            console.log(`Hello, my name is ${this.#name} and I am ${this.#age} years old and ${this.#my()}`);
        }
    }

const p = new Person('Alice', 30);

//p.#name; // 错误: 私有属性不能在类外部访问

//p.#age; // 错误: 私有属性不能在类外部访问

p.introduce(); // 输出:Hello, my name is Alice and I am 20 years old and I like you

如果要在外面使用，可以在Class里面声明一个方法获取私有属性和方法，然后把他们返回出去

    class Point {
        // 私有属性
        // 只能在类的内部使用，如果要在类的外面使用，可以声明一个方法把私有属性返回出去
        #number = 1;
        constructor() {
           
        }
        // 私有方法
        #getSelf() {
            console.log('我是私有的');
        }
        // 获取私有属性（声明一个方法把私有属性和方法返回出去）
        getA() {
            // 获取私有方法
            this.#getSelf()
            // 这里的this指向的是类的实例
            return console.log(this.#number);
        }
    }
    var p = new Point()
    // 获取私有属性和方法
     p.getA()

返回结果：

五、继承（ extends）

类的继承允许一个类（称为子类或派生类）继承另一个类（称为父类或基类）的属性和方法。这使得子类可以扩展或修改父类的行为

实现类的继承的步骤：

使用 extends 关键字：子类通过 extends 关键字继承父类。
调用父类的构造函数：子类的构造函数中可以使用 super() 调用父类的构造函数，以确保父类的属性被正确初始化。
重写和扩展方法：子类可以重写父类的方法，也可以添加新的方法。
静态属性和方法的继承：子类会继承父类的静态属性和方法，除非它们在子类中被重写。

// 定义父类
class Animal {
  constructor(name) {
    this.name = name;
  }

  speak() {
    console.log(`${this.name} makes a noise.`);
  }
  //静态方法
  static species() {
    return 'Animal';
  }
}

// 定义子类
//子类通过 extends 关键字继承父类
class Dog extends Animal {
  constructor(name, breed) {
     // 调用父类的构造函数
    super(name);
    this.breed = breed;
  }

  speak() {
    console.log(`${this.name} barks.`);
  }
  //静态方法
  static species() {
    return 'Dog';
  }
}

// 创建子类实例
const dog = new Dog('Rex', 'German Shepherd');

// 调用子类的方法
dog.speak(); // 输出: Rex barks.

// 调用静态方法
console.log(Dog.species()); // 输出: Dog
console.log(Animal.species()); // 输出: Animal