您在问题中演示的两个代码示例都使用了原型继承。事实上，你用JavaScript编写的任何面向对象的代码都是原型继承的范例。JavaScript根本没有经典的继承。这应该可以澄清一些问题：
Inheritance
|
+-----------------------------+
| |
v v
Prototypal Classical
|
+------------------------------+
| |
v v
Prototypal Pattern Constructor Pattern
如您所见，原型遗传和经典遗传是两种不同的继承范式。一些语言，如Self，Lua和JavaScript支持原型继承。但是，大多数语言（如C++，Java和C#）都支持经典继承。
面向对象编程快速概述
原型继承和经典继承都是面向对象的编程范式（即它们处理对象）。对象只是抽象，它封装了现实世界实体的属性（即它们在程序中表示真实的单词事物）。这称为抽象。
抽象化：计算机程序中现实世界事物的表示。
从理论上讲，抽象被定义为“通过从特定示例中提取共同特征而形成的一般概念”。但是，为了这个解释，我们将使用上述定义。
现在有些物体有很多共同点。例如，泥泞自行车和哈雷戴维森有很多共同点。
泥泞自行车：
哈雷戴维森：
泥泞自行车和哈雷戴维森都是自行车。因此，自行车是泥泞自行车和哈雷戴维森的推广。
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));
然而，反之亦然（即，您不能使用类对原型进行建模）。这是因为原型是对象，但类不是对象。它们是一种完全不同类型的抽象。
结论
总而言之，我们了解到抽象是“通过从特定示例中提取共同特征而形成的一般概念”，而泛化是“更具体抽象的抽象”。我们还了解了原型和经典继承之间的差异，以及它们如何是同一枚硬币的两面。
在临别的笔记中，我想指出，原型继承有两种模式：原型模式和构造函数模式。原型模式是原型继承的规范模式，而构造函数模式用于使原型继承看起来更像经典继承。就个人而言，我更喜欢原型模式。
