JavaScript中的面向对象编程-CSDN博客

本文链接：https://blog.csdn.net/m0_61841474/article/details/136533244

当谈到JavaScript中的面向对象编程时，我们通常会涉及以下几个关键概念：类（Class）、对象（Object）、属性（Property）、方法（Method）、继承（Inheritance）、封装（Encapsulation）和多态（Polymorphism）等。

类（Class）

类（Class）是一种对象的蓝图或模板，用于创建具有相同属性和方法的多个对象。它是面向对象编程的基础概念之一。

下面是对类的几个重要概念的详细介绍：

构造函数（Constructor）：类中的构造函数在使用new关键字创建类的实例时被自动调用。它用于初始化对象的属性。构造函数的名称必须是constructor。
属性（Properties）：类可以定义属性，也称为实例变量或字段，用于存储对象的状态。属性在类内部被声明并初始化，在类的实例化对象中访问和修改。可以通过this关键字来引用当前对象的属性。
方法（Methods）：类可以定义方法，用于执行特定的操作或功能。方法是与类相关联的函数，可以访问和处理类的属性。方法被定义在类的原型上，从而在多个实例中共享。
继承（Inheritance）：类可以通过继承机制派生出子类（子对象），子类继承父类的属性和方法，并可以添加自己的属性和方法。继承可以实现代码的重用和层次结构的建立。
实例化（Instance）：类是一个抽象的概念，而实例是根据类创建的具体对象。通过new关键字和类的构造函数，可以创建一个类的实例对象。

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

  sayHello() {
    console.log(`Hello, my name is ${this.name}`);
  }

  getAge() {
    return this.age;
  }
}

// 创建一个Person类的实例
const person = new Person('Tom', 25);

console.log(person.name);       // 输出：Tom
console.log(person.getAge());   // 输出：25
person.sayHello();              // 输出：Hello, my name is Tom

对象（Object）

对象（Object）是值的集合，可以包含属性和方法。它是一种复合数据类型，可以用来表示实际世界中的事物、概念或抽象概念。对象具有特定的属性和行为，并且可以通过访问这些属性和调用这些方法来操作和获取数据。

下面是对对象的几个重要概念的详细介绍：

属性（Property）：对象的属性是与对象相关联的变量，用于存储对象的状态或描述对象的特性。属性由键和值对组成，键称为属性名（或属性标识符），值是属性的值。可以通过点符号.或方括号表示法访问属性。

方法（Method）：对象的方法是与对象关联的函数，表示对象可以执行的操作。方法定义在对象内部，并且可以访问和修改对象的属性。方法可以在对象上调用，使用点符号.或方括号表示法。

创建对象：可以使用对象字面量{}或通过new关键字和构造函数来创建对象。当使用构造函数创建对象时，会根据构造函数的定义来初始化对象的属性。

this 关键字：在对象的方法中，this关键字指代当前对象本身，可以用来引用对象的属性或调用对象的其他方法。

下面是一个示例代码，展示了一个人（Person）对象的创建和使用：

// 创建一个对象
const person = {
  name: 'Tom',
  age: 25,
  sayHello: function() {
    console.log(`Hello, my name is ${this.name}`);
  }
};

console.log(person.name);         // 输出：Tom
person.sayHello();                // 输出：Hello, my name is Tom

对象可以存储和操作相关数据，并且可以通过方法来执行特定的操作。它是 JavaScript 中的核心概念之一，可以用于组织和管理复杂的数据结构和行为，提供了一种灵活而强大的编程模型。

属性（Property）

属性（Property）是对象的特征，用于描述对象的状态、特性或数据。每个属性都由一个键和一个值组成，键表示属性名（也称为属性标识符），值表示属性的具体取值。属性可以是基本数据类型（如字符串、数字、布尔值）、函数、数组、甚至另一个对象。

以下是关于属性的一些重要概念：

属性访问：

可以通过点符号.或方括号[]来访问对象的属性。使用点符号访问属性时，将属性名直接放在点符号后；使用方括号访问属性时，需要将属性名以字符串形式传递给方括号。

const person = {
  name: 'Tom',
  age: 25
};

console.log(person.name);   // 使用点符号访问属性
console.log(person['age']); // 使用方括号访问属性

动态属性：

对象的属性可以动态添加、修改或删除。通过简单给对象赋予新的属性即可添加属性，通过赋值的方式可以修改属性的值，通过delete关键字可以删除属性。

const person = {
  name: 'Tom',
  age: 25
};

person.gender = 'male';    // 添加新属性
person.age = 26;           // 修改属性值
delete person.age;         // 删除属性

计算属性名：

ES6引入了计算属性名（Computed Property Names）的语法，允许在对象字面量中使用表达式作为属性名。

let propKey = 'name';
let person = {
  [propKey]: 'Alice'   // 计算属性名
};
console.log(person.name);   // 输出：Alice

####只读属性：
可以使用Object.defineProperty方法来定义只读属性，阻止对属性值的修改。

const obj = {};
Object.defineProperty(obj, 'readOnlyProp', {
  value: 'read only',
  writable: false
});

// 尝试修改只读属性将会失败
obj.readOnlyProp = 'attempt to modify';
console.log(obj.readOnlyProp); // 输出：read only

方法（Method）

方法（Method）是对象中定义的一种特殊属性，它与函数相关联，并允许对象执行特定的操作或功能。方法允许对象封装代码以实现特定行为，同时可以访问和操作对象的数据属性。

以下是关于方法的一些重要概念：

对象方法：

方法是对象的属性，其值为一个函数。通过对象.methodName()的方式来调用对象的方法。在方法中，关键字this指代当前对象，在方法内部可以使用this来访问当前对象的属性。

const person = {
  name: 'Tom',
  greet: function() {
    console.log(`Hello, my name is ${this.name}`);
  }
};

person.greet(); // 调用对象的方法

方法定义：

方法可以在对象字面量中定义，也可以在对象创建后通过赋值的方式动态添加。可以直接将一个函数赋值给对象的属性。

const obj = {
  sayHello() {
    console.log('Hello!');
  }
};

obj.sayHello(); // 调用对象的方法

对象原型方法：

除了在对象字面量中定义方法外，还可以通过原型对象为所有实例共享方法。这样可以节省内存空间，同时使对象实例中不包含方法定义，提高性能。

function Person(name) {
  this.name = name;
}

Person.prototype.sayHello = function() {
  console.log(`Hello, my name is ${this.name}`);
};

const person1 = new Person('Alice');
person1.sayHello(); // 调用原型方法

箭头函数方法：

ES6中引入的箭头函数语法可以更简洁地定义方法。箭头函数没有自己的this，会捕获其所在上下文的this值。

const obj = {
  numbers: [1, 2, 3],
  sum: function() {
    return this.numbers.reduce((total, num) => total + num, 0);
  }
};

console.log(obj.sum()); // 输出：6

继承（Inheritance）

继承（Inheritance）是面向对象编程中的一种重要概念，它允许一个对象（称为子类或派生类）从另一个对象（称为父类或基类）继承属性和方法。通过继承，子类可以共享父类的特性，并可以在此基础上添加、覆盖或修改自己的属性和方法。

以下是关于继承的一些重要概念：

类和实例：类是一个抽象的概念，代表一类对象的通用特性和行为。实例则是类的具体实现，是根据类创建的对象。类定义了对象的属性和方法，实例则具有这些属性和方法的具体实现。
父类和子类：父类是具有通用特性和行为的类，子类继承父类的属性和方法，并可以根据需要添加自己的属性和方法。子类可以有多个，它们都继承自同一个父类。
继承关系：通过将子类的原型对象设置为父类的实例，子类可以继承父类的属性和方法。子类可以使用extends关键字来声明继承关系。

class Animal {
  constructor(name) {
    this.name = name;
  }

  eat() {
    console.log(`${this.name} is eating.`);
  }
}

class Dog extends Animal {
  bark() {
    console.log(`${this.name} is barking.`);
  }
}

const dog = new Dog('Bobby');
dog.eat();   // 调用父类的方法
dog.bark();  // 调用子类自己的方法

方法重写：子类可以重写继承自父类的方法，以实现子类特定的行为。在子类中重新定义同名的方法即可覆盖继承的方法。

class Animal {
  speak() {
    console.log('Animal is speaking.');
  }
}

class Dog extends Animal {
  speak() {
    console.log('Dog is barking.');
  }
}

const dog = new Dog();
dog.speak();  // 调用子类重写的方法

super 关键字：在子类中，super关键字可以用来调用父类的构造函数和方法。通过 super()调用父类的构造函数，确保父类的属性被正确初始化。

class Animal {
  constructor(name) {
    this.name = name;
  }

  speak() {
    console.log(`${this.name} is speaking.`);
  }
}

class Dog extends Animal {
  constructor(name, breed) {
    super(name);  // 调用父类的构造函数
    this.breed = breed;
  }
}

const dog = new Dog('Bobby', 'Labrador');
dog.speak();  // 调用父类的方法
console.log(dog.breed);  // 访问子类自己的属性

封装（Encapsulation）

封装（Encapsulation）是面向对象编程中的核心概念之一，它指的是将数据（属性）和操作数据的方法（行为）捆绑在一起，形成一个独立的单元。通过封装，对象可以隐藏内部的具体实现细节，只暴露必要的接口，从而保护数据不受外部直接访问和修改。

以下是关于封装的一些重要概念：

数据与方法：在面向对象编程中，每个对象都有其状态（数据）和行为（方法）。封装将数据和方法组合在一起形成一个类，对象可以通过方法来访问和操作数据。
访问控制：封装可以通过访问控制（Access Control）实现对对象数据的保护。在许多编程语言中，可以使用访问修饰符（如 private、protected、public）来限制对对象属性和方法的访问权限。

封装的优点：

优点	说明
隐藏实现细节	封装可以隐藏对象的内部实现细节，使外部对象无需关心对象内部的具体实现。
简化接口	通过封装，对象暴露出简单的接口，用户只需要知道如何使用对象的方法，而无需了解其具体实现。
提高安全性	封装可以防止外部直接访问和修改对象的数据，确保数据的安全性和完整性。
提高代码的可维护性	封装使代码更易于理解、调试和维护，因为对象的功能被封装在单独的模块中。

示例代码：

class Circle {
  #radius; // 使用私有字段进行封装

  constructor(radius) {
    this.#radius = radius;
  }

  get area() {
    return Math.PI * this.#radius ** 2;
  }

  set radius(newRadius) {
    if (newRadius > 0) {
      this.#radius = newRadius;
    } else {
      console.log("Radius must be a positive number");
    }
  }
}

const myCircle = new Circle(5);
console.log(myCircle.area);  // 访问计算属性 area
myCircle.radius = 10;       // 修改半径
console.log(myCircle.area);  // 重新计算面积
myCircle.radius = -5;       // 尝试设置负值，不会生效

在上面的示例中，Circle类封装了半径属性和面积计算方法，并且通过私有字段和 getter/setter 方法来实现封装和访问控制。

封装是面向对象编程的重要原则之一，它使得对象的设计更加模块化、可靠和可维护。通过封装，可以减少代码耦合度，提高代码的重用性和扩展性，同时保护数据的安全性和完整性。

多态（Polymorphism）

多态（Polymorphism）是面向对象编程中的一个重要概念，指的是同一个方法名可以在不同的对象类型上具有不同的行为。多态性使得我们可以使用统一的接口来处理不同类型的对象，而无需关心对象的具体类型，从而实现代码的灵活性和可扩展性。

以下是关于多态的一些重要概念和特点：

多态性的实现方式：

多态性主要通过方法的重写（override）和方法的重载（overload）来实现。方法的重写是指子类重写（覆盖）了父类的方法，从而改变了方法的实现；方法的重载是指在同一个类中根据参数的不同定义多个同名方法，根据不同的参数列表选择执行对应的方法。

多态性的优点：

优点	说明
简化代码	通过多态性，可以使用同一个接口处理不同类型的对象，避免大量的条件判断语句。
提高灵活性	多态性使得程序适应性更强，可以轻松地扩展和修改代码，无需改变原有代码结构。
增加可读性	采用多态性可以使代码更加简洁清晰，易于理解和维护。

运行时多态性：

运行时多态性（Runtime Polymorphism）是指根据对象的实际类型在运行时选择调用哪个方法。这种多态性通常通过继承和方法重写实现。

class Animal {
  speak() {
    console.log('Animal is speaking.');
  }
}

class Dog extends Animal {
  speak() {
    console.log('Dog is barking.');
  }
}

class Cat extends Animal {
  speak() {
    console.log('Cat is meowing.');
  }
}

function makeAnimalSpeak(animal) {
  animal.speak();
}

const dog = new Dog();
const cat = new Cat();

makeAnimalSpeak(dog); // 输出 Dog is barking.
makeAnimalSpeak(cat); // 输出 Cat is meowing.

在上面的示例中，makeAnimalSpeak数接受一个Animal象作为参数，在运行时根据对象的实际类型调用相应的speak法，实现了运行时多态性。

编译时多态性：

编译时多态性（Compile-time Polymorphism）也称为方法重载，是指在编译时根据不同参数列表选择调用对应的方法。

class Calculator {
  add(x, y) {
    return x + y;
  }

  add(x, y, z) {
    return x + y + z;
  }
}

const calc = new Calculator();
console.log(calc.add(1, 2));      // 调用第一个 add 方法
console.log(calc.add(1, 2, 3));   // 调用第二个 add 方法