我来从新学习js的面向对象（part 4）

我来从新学习js 的面向对象（part 4）

续上一篇，随着业务愈来愈大，要考虑一些继承的玩意了，大千世界，各类东西咱们要认识和甄别是须要靠大智慧去分门别类，生物学中把动植物按界、门、纲、目、科、属、种进行分类的方法多是最有表明的实例之一.........

说人话就是，咱们终于要学习继承的知识了，而后用这些知识去解决老板的问题。

1、继承-原型链

继承是 OOP 开发中的一个极为重要的概念，而在javascript 里面，实现继承的方式主要依靠原型链来实现的。

图片来自：https://www.lieyuncj.com/p/3087

图一，一环扣一环，造成了链条，能够适当帮助理解原型链的概念，原型链，换言之就是原型对象构成的链。

图片来源于：https://hackernoon.com/unders...

回顾一下，构造函数，原型和实例的关系：每一个构造函数都有一个原型对象，原型对象都包含一个指向构造函数的指针，而实例都包含一个指向原型对象的内部指针，当咱们将原型对象等于另一个类型的实例的时候，就会出现原型对象包含一个指向另一个原型的指针，例如 dog原型对象 指向了 animal原型对象。

继续回到现场，咱们作了一些分类，食物下面分了水果分类：

// 定义一个 Food 的构造函数
function Food() {
  this.type = "食物";
}
// 定义了 Food 的原型对象的一个方法 getType
Food.prototype.getType = function() {
  return this.type;
};
// 定义一个 Fruit 的构造函数
function Fruit() {
  this.type = "水果";
}
// 将 Fruit 的原型对象指向 Food 的实例
Fruit.prototype = new Food();
// 定义 Fruit 的原型对象的一个方法 getType
Fruit.prototype.getType = function() {
  return this.type;
};

var food1 = new Fruit();
console.log(food1.getType()); // 返回 水果

• 前半段都是同样的，直至将 Fruit 的原型对象指向 Food 的实例，因而Fruit原型不只拥有了 Food 实例的所有属性和方法，也拥有了 Food 实例的原型对象（由于 Food 实例里面有 prototype 指向Food Prototype）
• 这种粗暴的直接将父对象的实例塞进去子对象的原型里面的方式，直接促成了Fruit 继承 Food。

我最喜欢用《javascript 高级程序设计》第三版的图来讲明，由于他画的比较详细并且容易看明白（虽然我也是看了十来遍才看懂），借用他的例子和图来解释咱们的例子：

能够看到如今这里子对象 subtype 的 原型对象是 superType，由于也是直接粗暴的塞进去的。

若是要看完整的他的原型链，能够参看这个图：

至关详细，这里之因此有 Object 是由于 javascript 里面一切皆是对象，默认的最顶级的原型就是 Object Prototype。（怎么看这个图，能够翻看以前一集介绍原型的内容）

下面须要注意一些原型对象的问题和技巧

1.1 肯定原型和实例的关系

没办法准确知道是继承于哪个，只要是在链条里面的，都会被认为是继承过来的。

console.log(food1 instanceof Fruit) // 返回 true
console.log(food1 instanceof Food) // 返回 true
console.log(food1 instanceof Object) // 返回 true

console.log(Fruit.prototype.isPrototypeOf(food1)) // 返回 true
console.log(Food.prototype.isPrototypeOf(food1)) // 返回 true
console.log(Object.prototype.isPrototypeOf(food1)) // 返回 true

这里也跟javascript 的原型搜索机制有关系，当访问一个实例属性时候，首先会在实例中搜索该属性，若是没有找到该属性，就会继续搜索实例的原型对象，在经过原型链实现继承的状况下，搜索过程就会一直沿着原型链继续向上搜索。

相似下图：

图片来源于：http://www.cnblogs.com/keepfo...

1.2 谨慎定义方法

① 给原型添加方法的代码必定要放在替换原型的语句以后

正确的例子：

// 定义一个 Food 的构造函数
function Food() {
  this.type = "食物";
}
// 定义了 Food 的原型对象的一个方法 getType
Food.prototype.getType = function() {
  return "food 的 getType 方法";
};
// 定义一个 Fruit 的构造函数
function Fruit() {
  this.type = "水果";
}
// 将 Fruit 的原型对象指向 Food 的实例
Fruit.prototype = new Food();
// 给子类 Fruit 的原型添加一个新方法getSubType
Fruit.prototype.getSubType = function() {
  return "Fruit 的getSubType";
};
// 重写父类 Food 的方法getType
Food.prototype.getType = function() {
  return false;
};
var food1 = new Fruit();

console.log(food1.getSubType()); // 返回 Fruit 的getSubType
console.log(food1.getType()); // 返回 false

• 子类 Fruit 重写父类（超类）的原型对象的方法getType，在调用的时候会覆盖屌父类 Food的原型对象的getType方法，直接使用子类Fruit的getType
• 子类 Fruit 添加一个方法到本身的原型对象里面，也是很正常的，可以被直接使用。

错误的例子：

// 定义一个 Food 的构造函数
function Food() {
  this.type = "食物";
}
// 定义了 Food 的原型对象的一个方法 getType
Food.prototype.getType = function() {
  return "food 的 getType 方法";
};
// 定义一个 Fruit 的构造函数
function Fruit() {
  this.type = "水果";
}
// 给子类 Fruit 的原型添加一个新方法getSubType
Fruit.prototype.getSubType = function() {
  return "Fruit 的getSubType";
};
// 重写父类 Food 的方法getType
Food.prototype.getType = function() {
  return false;
};
// 将 Fruit 的原型对象指向 Food 的实例
Fruit.prototype = new Food();

var food1 = new Fruit();

console.log(food1.getSubType()); // 抛出 error 异常
console.log(food1.getType()); // 返回 false

• food1.getSubType() 直接抛出异常，提示说方法找不到或者未定义

主要就是由于子原型对象被替换的时候会被彻底覆盖。

1.3 在经过原型链实现继承时，不能使用对象字面量方法建立原型

主要是由于对象字面量方法会重写原型链，这个原理在以前章节说过，这里只是再次提醒。

// 省略。。。
Fruit.prototype = new Food();

Fruit.prototype = { // 被重写了原型链，就不属于原来的原型链范围了。
//  xxxxxxx
}
// 省略。。。

1.4 原型链的问题

1. 原型链最大的问题是来自包含引用类型值的原型，这种类型值的原型属性会被全部实例共享，致使没办法很好隔离，因此以前也是使用构造函数和原型模式组合使用来解决这个问题，但当时没有触及真正的继承。
2. 原型链另一个问题是，在建立子类型的实例时，不能向超类型的构造函数中传递参数，或者说，是没办法在不影响全部对象实例状况下，给超类型的构造函数传递参数。

基于以上2个问题，致使了实际环境中，不多会单独使用原型链，会结合其余方式来使用原型链，毕竟 javascript 里，全部的继承其实也是以原型链为基础的。

2、继承-借用构造函数、伪造对象、经典继承

图片来自：https://www.tvmao.com/drama/K...

鉴于以前原型链的问题两大问题，因此机智的工程师想出来利用构造函数来搭配使用，这个技术就叫作借用构造函数 constructor stealing（很 low 有没有！），有时候叫伪造对象，或者叫经典继承（逼格瞬间飙升到彻底看不懂，但以为很厉害，有木有！）

核心思想是在子类型构造函数的内部调用超类型改造函数。

单纯使用原型链继承的时候：

function Food() {
  this.colors = ["red", "blue"];
}

function Fruit() {}

Fruit.prototype = new Food();

var food1 = new Fruit();
var food2 = new Fruit();
console.log(food1.colors); // 返回 [ 'red', 'blue' ]
console.log(food2.colors); // 返回 [ 'red', 'blue' ]
food1.colors.push("yellow");
console.log(food1.colors); // 返回 [ 'red', 'blue', 'yellow' ]
console.log(food2.colors); // 返回 [ 'red', 'blue', 'yellow' ]

使用借用构造函数模式继承的时候：

function Food() {
  this.colors = ["red", "blue"];
}

function Fruit() {
  Food.call(this); // call 能够改变函数的this对象的指向
}

var food1 = new Fruit();
console.log(food1.colors); // 返回 [ 'red', 'blue' ]

food1.colors.push("yellow");
console.log(food1.colors); // 返回 [ 'red', 'blue', 'yellow' ]

var food2 = new Fruit();
console.log(food2.colors); // 返回 [ 'red', 'blue' ]

能够看到大相径庭的两种效果，后者的实例的数组（引用类型的数据）并无跟随其余实例变化而变化，是互相独立的。

为何能够这样呢？

• 利用了函数的执行环境上下文，这里的“继承”的目的只是为了可以使用超类的属性和方法（不算是真正的继承），因此直接将超类的构造函数放到子类的构造函数里面执行，从而将他们进行合体。
• 利用了 call（或者 apply 或者 bind 这种函数）改变了构造函数的 this 指向，才得以实现上面说到的将不一样的构造函数放到同一个执行环境中执行。

2.1 传参

下面两个例子分别说明了，这种继承方式能够传参的，而且传参以后也是能够重写超类的属性的。

例子1：

function Food(name) {
  this.name = name;
  this.colors = ["red", "blue"];
}

function Fruit() {
  Food.call(this, "苹果"); // call 能够改变函数的this对象的指向
}

var food1 = new Fruit();
console.log(food1.name); // 返回 苹果

例子2：

function Food(name) { // 参数
  this.name = name;
  this.colors = ["red", "blue"];
}

function Fruit() {
  Food.call(this, "苹果"); // call 能够改变函数的this对象的指向，加上了传参
  this.place = "非洲"; // 添加属性
  this.name = "香蕉"; // 重写超类属性
}

var food1 = new Fruit();
console.log(food1.name); // 返回 苹果
console.log(food1.place); // 返回 非洲

2.2 这种方式的问题

图片来自：https://www.youtube.com/watch...

正如以前所说，这种不是真正的继承，只是想子类和父类进行了强行合体罢了，这种合体方式可以知足通常继承的要求，可是带了其余问题：

• 没办法使用超类的原型对象里面定义的方法。

function Food() {
  this.colors = ["red", "blue"];
}
Food.prototype.getType = function () {
  console.log("我是 food 的getType");
}
function Fruit() {
  Food.call(this); // call 能够改变函数的this对象的指向
}

var food1 = new Fruit();
console.log(food1.getType()); // 抛出异常，没有这个 function

• 由于子类和超类都是构造函数，那么就会有以前说的，构造函数在 new 的时候，里面的方法（函数）会重复建立 function 实例， 致使资源浪费。

function Food() {
  this.colors = ["red", "blue"];
}

function Fruit() {
  Food.call(this); // call 能够改变函数的this对象的指向
  this.getType = function() {
    console.log("我是 food 的getType");
  };
}

var food1 = new Fruit();
var food2 = new Fruit();

console.log(food1.getType == food2.getType); // 返回 false

鉴于这种问题，在小规模程序设计里面还好，可是一旦规模稍微变得复杂以后，就无法控制代码了，那咱们机智的工程师们还要继续想一想办法。

参考内容

1. 红宝书，javascript 高级程序设计第三版

原文转载：https://www.godblessyuan.com/...