面向对象编程 (OOP) 是构建结构良好、模块化和可重用代码的基础。虽然 JavaScript 最初是过程性的，但 ES6 及更高版本引入了 OOP 语法，使其成为掌握函数式和面向对象范例的理想语言。本文涵盖了 JavaScript 中的基本 OOP 概念，包括类、继承、多态性和抽象，以及 JavaScript 特定的功能，例如原型继承和对象组合。
1.封装：
封装允许对对象内的数据和方法进行分组，限制对对象状态的直接访问。这可以保护数据免受意外修改并允许受控交互。
class Car {
constructor(make, model) {
this.make = make;
this.model = model;
this._engineOn = false;
}
startEngine() {
this._engineOn = true;
console.log(`${this.make} ${this.model} engine started.`);
}
stopEngine() {
this._engineOn = false;
console.log(`${this.make} ${this.model} engine stopped.`);
}
}
const myCar = new Car("Toyota", "Corolla");
myCar.startEngine(); // Output: Toyota Corolla engine started.
2.继承：
继承允许基于父类创建子类，允许代码重用和定义层次结构。
class Animal {
constructor(name) {
this.name = name;
}
speak() {
console.log(`${this.name} makes a sound.`);
}
}
class Dog extends Animal {
speak() {
console.log(`${this.name} barks.`);
}
}
const myDog = new Dog("Max");
myDog.speak(); // Output: Max barks.
3.多态性：
多态性让不同的类响应相同的函数或方法调用。 JavaScript 通过方法重写实现多态性。
class Printer {
print() {
console.log("Printing document...");
}
}
class PDFPrinter extends Printer {
print() {
console.log("Printing PDF document...");
}
}
const printer = new Printer();
const pdfPrinter = new PDFPrinter();
printer.print(); // Printing document...
pdfPrinter.print(); // Printing PDF document...
4.摘要：
抽象通过仅暴露必要的部分来简化复杂的系统。 ES2020引入了带有#的私有字段，允许封装在类中。
class Account {
#balance;
constructor(initialBalance) {
this.#balance = initialBalance;
}
deposit(amount) {
this.#balance += amount;
}
getBalance() {
return this.#balance;
}
}
const myAccount = new Account(1000);
myAccount.deposit(500);
console.log(myAccount.getBalance()); // Output: 1500
JavaScript 是基于原型的，这意味着对象可以直接从其他对象而不是类继承。这是通过原型实现的，原型是其他对象继承方法和属性的对象。
function Vehicle(type) {
this.type = type;
}
Vehicle.prototype.start = function() {
console.log(`${this.type} is starting.`);
};
const car = new Vehicle("Car");
car.start(); // Car is starting.
组合是继承的替代方案，您无需在层次结构中创建类，而是创建包含较小的可重用对象的对象来实现所需的功能。
const canFly = {
fly() {
console.log("Flying!");
}
};
const canSwim = {
swim() {
console.log("Swimming!");
}
};
function Fish(name) {
this.name = name;
}
Object.assign(Fish.prototype, canSwim);
const fish = new Fish("Nemo");
fish.swim(); // Swimming!
1。工厂模式：
工厂模式是一种设计模式，您可以在不指定确切类的情况下创建对象。它对于封装对象的创建逻辑很有用。
function createUser(name, role) {
return {
name,
role,
describe() {
console.log(`${this.name} is a ${this.role}`);
}
};
}
const admin = createUser("Alice", "Administrator");
admin.describe(); // Alice is an Administrator
2。单例模式：
Singleton 是一种设计模式，其中一个类只有一个实例。它对于创建全局可访问的对象（例如配置或应用程序状态）非常有用。
const Singleton = (function () {
let instance;
function createInstance() {
return new Object("I am the instance");
}
return {
getInstance: function () {
if (!instance) {
instance = createInstance();
}
return instance;
}
};
})();
const instance1 = Singleton.getInstance();
const instance2 = Singleton.getInstance();
console.log(instance1 === instance2); // true
3。观察者模式：
观察者模式定义了一种依赖关系，其中一个对象（主题）的更改会导致其他对象（观察者）的通知。
class Car {
constructor(make, model) {
this.make = make;
this.model = model;
this._engineOn = false;
}
startEngine() {
this._engineOn = true;
console.log(`${this.make} ${this.model} engine started.`);
}
stopEngine() {
this._engineOn = false;
console.log(`${this.make} ${this.model} engine stopped.`);
}
}
const myCar = new Car("Toyota", "Corolla");
myCar.startEngine(); // Output: Toyota Corolla engine started.
1。避免继承过度使用： 倾向于组合以获得更好的灵活性和重用性。
2.最大限度地减少副作用： 保持数据封装以防止意外更改。
3.使用 Object.freeze： 这可以防止不可变对象的意外修改。
JavaScript 的 OOP 方法提供了一种灵活的混合模型，结合了基于原型的继承和经典的 OOP。借助 ES6 的进步（例如类和私有字段），JavaScript 允许开发人员构建复杂的应用程序，同时保持干净的代码结构。通过掌握 JavaScript 中的 OOP，您可以为实际应用程序构建可扩展、可维护且高性能的代码。
我的个人网站：https://shafayet.zya.me
给你的表情包？？？
以上是主导 JavaScript 中的面向对象编程 (OOP)。的详细内容。更多信息请关注PHP中文网其他相关文章！
