Javascript基于对象三大特性（封装性、继承性、多态性）

JavaScript是基于对象设计的一种编程语言，其三大特性分别是封装性、继承性和多态性。下面我们将对这三个特性分别进行详细的介绍和示例说明。

封装性

封装性是指将对象的属性和方法组合成一个单独的单元，即封装成一个类。封装性可以隐藏对象的具体实现方式，只暴露必要的接口给外部使用，提高代码的安全性和可维护性。

示例一

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

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

const person = new Person('Tom', 18);
person.sayHello(); // Hello, my name is Tom
console.log(person.age); // 18

在上面的示例代码中，我们通过定义一个Person类，将对象的name和age属性和sayHello()方法封装成一个单独的单元。外部只需要通过类的实例对象即可访问类中的属性和方法。

示例二

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

person.sayHello(); // Hello, my name is Tom
console.log(person.age); // 18

在上面的示例代码中，我们通过一个对象字面量来封装对象。对象的属性和方法都集中在一个对象内部，只暴露必要的接口给外部访问。

继承性

继承是指子类可以继承父类的属性和方法，同时也可以覆盖父类的方法和属性。继承可以减少重复代码和提高代码的可重用性。

示例一

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

  speak() {
    console.log(`${this.name} makes a noise.`);
  }
}

class Dog extends Animal {
  speak() {
    console.log(`${this.name} barks.`);
  }
}

const dog = new Dog('Fido');
dog.speak(); // Fido barks.

在上面的示例代码中，我们定义了一个Animal类，拥有一个name属性和speak()方法。然后我们将Animal类作为父类，定义一个Dog类继承自Animal类。在Dog类中，我们定义了一个speak()方法，覆盖了父类的speak()方法。这样Dog类就继承了Animal类的属性和方法，并且扩展自己的行为。

示例二

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

Animal.prototype.speak = function() {
  console.log(`${this.name} makes a noise.`);
}

function Dog(name) {
  Animal.call(this, name);
}

Dog.prototype = Object.create(Animal.prototype);
Dog.prototype.constructor = Dog;

Dog.prototype.speak = function() {
  console.log(`${this.name} barks.`);
}

const dog = new Dog('Fido');
dog.speak(); // Fido barks.

在上面的示例代码中，我们通过构造函数的方式实现了继承。首先我们定义了一个Animal构造函数，拥有一个name属性和speak()方法。然后我们定义了Dog构造函数，通过调用Animal构造函数的call()方法来继承Animal的属性和方法。同时通过修改Dog类的原型，使其继承自Animal的原型，并且通过重新指定constructor属性来修正指向。在Dog类中，我们定义了一个speak()方法，覆盖了父类的speak()方法。这样Dog类就继承了Animal类的属性和方法，并且扩展自己的行为。

多态性

多态性是指同一种方法可以在不同的对象上有不同的行为。多态性可以提高代码的灵活性和可扩展性。

示例一

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

  speak() {
    console.log(`${this.name} makes a noise.`);
  }
}

class Dog extends Animal {
  speak() {
    console.log(`${this.name} barks.`);
  }
}

class Cat extends Animal {
  speak() {
    console.log(`${this.name} meows.`);
  }
}

const dog = new Dog('Fido');
const cat = new Cat('Nyan');
const animals = [dog, cat];

animals.forEach(animal => {
  animal.speak();
});

在上面的示例代码中，我们定义了一个Animal类，和两个继承自Animal类的子类Dog和Cat。在Dog和Cat类中，我们覆盖了Animal类的speak()方法，拥有了自己的行为。在主程序中，我们创建了一个Dog类和一个Cat类对象，并将它们放在一个数组中。然后我们通过数组的forEach()方法，遍历数组中的每个元素，并执行animal.speak()方法。由于Dog和Cat类都实现了speak()方法，并且具有不同的行为，所以在遍历数组时会执行不同的行为。

示例二

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

Animal.prototype.speak = function() {
  console.log(`${this.name} makes a noise.`);
}

function Dog(name) {
  Animal.call(this, name);
}

Dog.prototype = Object.create(Animal.prototype);
Dog.prototype.constructor = Dog;

Dog.prototype.speak = function() {
  console.log(`${this.name} barks.`);
}

function Cat(name) {
  Animal.call(this, name);
}

Cat.prototype = Object.create(Animal.prototype);
Cat.prototype.constructor = Cat;

Cat.prototype.speak = function() {
  console.log(`${this.name} meows.`);
}

const dog = new Dog('Fido');
const cat = new Cat('Nyan');
const animals = [dog, cat];

animals.forEach(animal => {
  animal.speak();
});

在上面的示例代码中，我们通过构造函数的方式实现了多态性。首先我们定义了一个Animal构造函数，拥有一个name属性和speak()方法。然后我们定义了Dog和Cat构造函数，通过调用Animal构造函数的call()方法来继承Animal的属性和方法。同时通过修改Dog和Cat类的原型，使其继承自Animal的原型，并且通过重新指定constructor属性来修正指向。在Dog和Cat类中，我们定义了一个speak()方法，分别覆盖了Animal类的speak()方法，拥有了自己的行为。在主程序中，我们创建了一个Dog类和一个Cat类对象，并将它们放在一个数组中。然后我们通过数组的forEach()方法，遍历数组中的每个元素，并执行animal.speak()方法。由于Dog和Cat类都实现了speak()方法，并且具有不同的行为，所以在遍历数组时会执行不同的行为。