从继承性谈谈对象的特性

继承性：对象之间的关系

继承性是对象之间的一种关系，子对象可以继承父对象的所有属性和方法。这使得子对象可以访问和使用父对象的所有成员，包括属性和方法。继承性可以帮助我们避免重复编写代码，并使代码更加灵活和可重用。

在 JavaScript 中，继承性可以通过两种方式实现：借用原型链和借用构造函数。

• 借用原型链实现继承

在 JavaScript 中，每个对象都有一个内部属性[[Prototype]]，该属性指向该对象的原型对象。原型对象是一个特殊的对象，它包含了该对象的所有属性和方法。当子对象访问一个属性或方法时，JavaScript 首先会检查子对象本身是否有该属性或方法。如果没有，JavaScript 会沿着原型链向上查找，直到找到该属性或方法。

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

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

function Student(name, major) {
  Person.call(this, name);
  this.major = major;
}

Student.prototype = Object.create(Person.prototype);

const student = new Student('John', 'Computer Science');

student.sayHello(); // Hello, my name is John!

在这个例子中，Student 对象继承了 Person 对象的所有属性和方法。当我们调用 student.sayHello() 方法时，JavaScript 会沿着原型链向上查找，直到找到 sayHello 方法。然后，JavaScript 会执行 sayHello 方法，并将 this 指向 student 对象。

• 借用构造函数实现继承

另一种实现继承性的方法是借用构造函数。在 JavaScript 中，每个函数都有一个内部属性[[Construct]]，该属性指向该函数的构造函数。当一个函数被调用时，JavaScript 会创建一个新的对象，并将 this 指向该对象。然后，JavaScript 会执行函数体，并将对象作为参数传递给函数。

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

function Student(name, major) {
  Person.call(this, name);
  this.major = major;
}

const student = new Student('John', 'Computer Science');

console.log(student.name); // John
console.log(student.major); // Computer Science

在这个例子中，Student 函数借用了 Person 函数的构造函数。当我们调用 new Student('John', 'Computer Science') 时，JavaScript 会创建一个新的对象，并将 this 指向该对象。然后，JavaScript 会执行 Student 函数体，并将对象作为参数传递给函数。

封装性：对象的私有属性和方法

封装性是指对象可以将自己的属性和方法隐藏起来，防止外部访问。这有助于保护对象的内部状态，并使对象更加安全和可靠。

在 JavaScript 中，可以通过使用私有属性和私有方法来实现封装性。私有属性和私有方法只能在对象的内部访问，不能在对象的外部访问。

class Person {
  #name;

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

  getName() {
    return this.#name;
  }
}

const person = new Person('John');

console.log(person.getName()); // John
console.log(person.#name); // undefined

在这个例子中，#name 是一个私有属性，只能在 Person 对象的内部访问。当我们调用 person.getName() 方法时，JavaScript 会返回 #name 的值。但是，当我们直接访问 person.#name 时，JavaScript 会返回 undefined。

多态性：对象的行为可以根据不同的情况而有所不同

多态性是指对象的行为可以根据不同的情况而有所不同。这使得对象更加灵活和可重用。

在 JavaScript 中，可以通过函数重载和方法重写来实现多态性。

• 函数重载

函数重载是指同一个函数可以有多个不同的参数列表。当我们调用函数时，JavaScript 会根据参数列表来选择要执行的函数体。

function add(a, b) {
  return a + b;
}

function add(a, b, c) {
  return a + b + c;
}

console.log(add(1, 2)); // 3
console.log(add(1, 2, 3)); // 6

在这个例子中，add 函数有两个不同的参数列表。当我们调用 add(1, 2) 时，JavaScript 会执行第一个函数体，并将 a 和 b 的值分别设置为 1 和 2。当我们调用 add(1, 2, 3) 时，JavaScript 会执行第二个函数体，并将 a、b 和 c 的值分别设置为 1、2 和 3。

• 方法重写

方法重写是指子对象可以覆盖父对象的方法。当子对象调用一个父对象的方法时，JavaScript 会执行子对象自己的方法，而不是父对象的方法。

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

class Student extends Person {
  sayHello() {
    console.log(`Hello, my name is ${this.name} and I'm a student!`);
  }
}

const person = new Person('John');
const student = new Student('Mary');

person.sayHello(); // Hello, my name is John!
student.sayHello(); // Hello, my name is Mary and I'm a student!

在这个例子中，Student 类重写了 Person 类的 sayHello 方法。当我们调用 person.sayHello() 方法时，JavaScript 会执行 Person 类的 sayHello 方法。当我们调用 student.sayHello() 方法时，JavaScript 会执行 Student 类的 sayHello 方法。