javascript中的经典继承与原型继承

您在问题中演示的两个代码示例都使用了原型继承。事实上，你用 JavaScript 编写的任何面向对象的代码都是原型继承的范例。 JavaScript 根本没有经典继承。这应该清楚一点：

                                   Inheritance
                                        |
                         +-----------------------------+
                         |                             |
                         v                             v
                    Prototypal                     Classical
                         |
         +------------------------------+
         |                              |
         v                              v
Prototypal Pattern             Constructor Pattern

如您所见，原型继承和经典继承是两种不同的继承范例。一些语言，如 Self、Lua 和 JavaScript 支持原型继承。然而，大多数语言，如 C++、Java 和 C# 都支持经典继承。

面向对象编程的快速概述

原型继承和经典继承都是面向对象的编程范式（即它们处理对象）。对象只是封装了真实世界实体属性的抽象（即它们代表程序中的真实事物）。这被称为抽象。

抽象：计算机程序中现实世界事物的表示。

从理论上讲，抽象被定义为“通过从特定示例中提取共同特征而形成的一般概念”。然而，为了便于解释，我们将改用上述定义。

现在有些对象有很多共同点。例如泥地自行车和哈雷戴维森有很多共同点。

泥地自行车：

https://i.stack.imgur.com/Sk20o.jpg

哈雷戴维森：

https://i.stack.imgur.com/4hj6K.jpg

泥地自行车和哈雷戴维森都是自行车。因此，自行车是泥泞自行车和哈雷戴维森的概括。

                   Bike
                     |
    +---------------------------------+
    |                                 |
    v                                 v
Mud Bike                       Harley Davidson

在上面的例子中，自行车、泥地自行车和哈雷戴维森都是抽象的。然而，自行车是泥泞自行车和哈雷戴维森的更一般的抽象（即泥泞自行车和哈雷戴维森都是特定类型的自行车）。

泛化：更具体抽象的抽象。

在面向对象的编程中，我们创建对象（它们是现实世界实体的抽象），我们使用类或原型来创建这些对象的泛化。泛化是通过继承创建的。自行车是泥地自行车的概括。因此，泥地自行车继承自自行车。

经典的面向对象编程

在经典的面向对象编程中，我们有两种抽象类型：类和对象。如前所述，对象是现实世界实体的抽象。另一方面，一个类是一个对象或另一个类的抽象（即它是一个泛化）。例如，考虑：

+----------------------+----------------+---------------------------------------+
| Level of Abstraction | Name of Entity |                Comments               |
+----------------------+----------------+---------------------------------------+
| 0                    | John Doe       | Real World Entity.                    |
| 1                    | johnDoe        | Variable holding object.              |
| 2                    | Man            | Class of object johnDoe.              |
| 3                    | Human          | Superclass of class Man.              |
+----------------------+----------------+---------------------------------------+

正如您在经典的面向对象编程语言中看到的那样，对象只是抽象（即所有对象的抽象级别都为 1），而类只是泛化（即所有类的抽象级别都大于 1）。

经典的面向对象编程语言中的对象只能通过实例化类来创建：

class Human {
    // ...
}

class Man extends Human {
    // ...
}

Man johnDoe = new Man();

总之，在经典的面向对象编程语言中，对象是现实世界实体的抽象，类是泛化（即对象或其他类的抽象）。

因此，随着抽象级别的增加，实体变得更加普遍，而随着抽象级别的降低，实体变得更加具体。在这个意义上，抽象级别类似于从更具体的实体到更一般的实体的范围。

原型面向对象编程

原型面向对象编程语言比经典的面向对象编程语言简单得多，因为在原型面向对象编程中我们只有一种抽象类型（即对象）。例如，考虑：

+----------------------+----------------+---------------------------------------+
| Level of Abstraction | Name of Entity |                Comments               |
+----------------------+----------------+---------------------------------------+
| 0                    | John Doe       | Real World Entity.                    |
| 1                    | johnDoe        | Variable holding object.              |
| 2                    | man            | Prototype of object johnDoe.          |
| 3                    | human          | Prototype of object man.              |
+----------------------+----------------+---------------------------------------+

正如您在原型面向对象编程语言中看到的那样，对象是现实世界实体（在这种情况下它们被简单地称为对象）或其他对象（在这种情况下它们被称为它们抽象的那些对象的原型）的抽象。因此，原型是一种概括。

原型面向对象编程语言中的对象可以从无中生有（即无中生有）或从另一个对象（成为新创建对象的原型）创建：

var human = {};
var man = Object.create(human);
var johnDoe = Object.create(man);

在我看来，原型面向对象编程语言比经典的面向对象编程语言更强大，因为：

只有一种抽象类型。概括只是对象。

至此，您一定已经意识到经典继承和原型继承之间的区别。经典继承仅限于从其他类继承的类。然而，原型继承不仅包括从其他原型继承的原型，还包括从原型继承的对象。

原型类同构

您一定已经注意到原型和类非常相似。确实如此。他们是。事实上，它们非常相似，您实际上可以使用原型对类进行建模：

function CLASS(base, body) {
    if (arguments.length < 2) body = base, base = Object.prototype;
    var prototype = Object.create(base, {new: {value: create}});
    return body.call(prototype, base), prototype;

    function create() {
        var self = Object.create(prototype);
        return prototype.hasOwnProperty("constructor") &&
            prototype.constructor.apply(self, arguments), self;
    }
}

使用上面的 CLASS 函数，您可以创建类似于类的原型：

var Human = CLASS(function () {
    var milliseconds = 1
      , seconds      = 1000 * milliseconds
      , minutes      = 60 * seconds
      , hours        = 60 * minutes
      , days         = 24 * hours
      , years        = 365.2425 * days;

    this.constructor = function (name, sex, dob) {
        this.name = name;
        this.sex = sex;
        this.dob = dob;
    };

    this.age = function () {
        return Math.floor((new Date - this.dob) / years);
    };
});

var Man = CLASS(Human, function (Human) {
    this.constructor = function (name, dob) {
        Human.constructor.call(this, name, "male", dob);
        if (this.age() < 18) throw new Error(name + " is a boy, not a man!");
    };
});

var johnDoe = Man.new("John Doe", new Date(1970, 0, 1));

然而，反之则不成立（即您不能使用类来建模原型）。这是因为原型是对象，但类不是对象。它们是完全不同的抽象类型。

结论

总而言之，我们了解到抽象是“通过从特定示例中提取共同特征形成的一般概念”，而泛化是“更具体抽象的抽象”。我们还了解了原型继承和经典继承之间的区别，以及它们如何是同一枚硬币的两个面。

在临别之际，我想指出原型继承有两种模式：原型模式和构造函数模式。原型模式是原型继承的规范模式，而构造函数模式用于使原型继承看起来更像经典继承。我个人更喜欢原型模式。

---

在进入继承之前，我们将看一下在 javascript 中创建实例（对象）的两个主要模型：

经典模型：对象是从蓝图（类）创建的

class Person {
  fn() {...}
} // or constructor function say, function Person() {}

// create instance
let person = new Person();

原型模型：对象是直接从另一个对象创建的。

// base object
let Person = { fn(){...} }

// instance
let person = Object.create(Person);

无论哪种情况，继承*都是通过使用原型对象链接对象来实现的。

（*基类方法可以通过原型对象通过派生类访问，并且不需要在派生类中显式存在。）

这是一个很好的解释，可以更好地理解 (http://www.objectplayground.com/)

---

狗是一种动物。苏珊娜是条狗。在经典继承中，Animal 是一个类，Dog 是 Animal 的子类，suzanna 是 Dog 的实例。

在原型继承中，没有类。您有一个 animal，它是一个对象。 dog 是另一个对象，它克隆和扩展 animal（原型对象）。 suzanna 是第三个对象，它复制和扩展 dog。

let animal = {hasChlorophyl: false};

let dog = Object.create(animal);
Object.assign(dog, {
  speak() {
    console.log("Woof!");
  }
});

let suzanna = Object.create(dog);
Object.assign(suzanna, {
  name: "Suzanna"
});

suzanna.speak();

如果您编写 Dog 而不是 dog，尤其是如果您使 Dog 某种“构造函数”函数，那么 您不是在进行原型继承；你正在做（伪）经典继承。您使用 Object.create() 来实现这一点的事实并不意味着您正在进行原型继承。

事实上，JavaScript 只支持原型继承。令人困惑的 new 运算符和 .prototype 属性是为了使原型继承看起来像（伪）经典继承。

Douglas Crockford 在他的书“JavaScript: The Good Parts”中详细探讨了这一点。

---