再谈JavaScript面向对象思想及继承

前言

为何说是再谈呢，网上讲解这个的博客的不少，我开始学习也是看过，敲过就没了，自觉得理解了就结束了，书到用时方恨少啊。实际开发中一用就打磕巴，因而在从新学习了以后分享出来。开了这么一个宏观的题目，须要作一下简单说明，这篇文章将会讲解如下几个问题：

1. 什么是面向对象编程思想，为何要用面向对象思想。
2. js中的面向对象思想和其余静态语言相比有什么不一样。
3. js中prototype，constructor，__proto__这些都是什么鬼？怎么用他们实现面向对象中的继承。
4. 一些小感悟小建议之类的吧啦吧啦。

下面咱们直接开始干货。。。

面向对象 what's it? why ues it?

什么是面向对象编程？看成者刚开始工做时，怀着对面向对象编程的无限敬仰和好奇，问了同事Java大牛这个问题，他的回答引我深思：不要面向对象编程，要面向工资编程。言归正传，面向对象中的对象，固然不是男女友的对象，ECMAScript中，对象是一个无序属性集，这里的“属性”能够是基本值、另外一个对象或者函数。实际应用能够理解为一本书，一我的，一个班级，因此万物都是对象。对象的属性怎么理解，以人为例，指人的名字、身高、体重等等，对象的属性还能够是函数称之为方法，指代对象的一些操做，动做。如人的说话，走路等等。提到面向对象，那就须要提到面向过程，咱们不用官方的方式来解释，从实际问题中思考。

假设如今项目需求为画一个三角形，一个矩形。直接编写代码时，咱们确定考虑的是第一步 画三角形 第二步 画矩形。咱们会编写一个三角形函数triangle() 一个矩形函数rect() 而后一步步调用，这是面向过程的思想。

function triangle() {...}
function rect() {...}

triangle();
rect();

面向对象中咱们首先会抽象问题，矩形三角形都是对象，他们的类型都是形状。他们有各自的边长顶点，那么咱们会先建立一个基本对象 形状 Shape 属性有顶点、边长，三角形Triangle和矩形Rect都是基本对象扩展出的新对象，有各自的画图方法draw()，而后用对象获得具体的指向对象(即实例，后文解释)triangle调用draw方法

function Shape() {...}
function Triangle() {...}
function Rect() {...}

let triangle = new Triang();
triangle.draw();
let rect = new Rect();
rect.draw();

面对一个问题，面向过程的思路是第一步作什么，第二步作什么 面向对象则须要先分析出问题中的对象都有什么，对象的属性、方法是什么，让对象要作什么。
假设如今须要得到画出矩形的边长，面向对象中只须要在Rect中加上一个方法就能够，面向过程则须要拿到画出的矩形，再获得边长，相比较而言面向对象易于扩展。

面向对象中有三大特征，封装，继承，多态。封装指将变化封装起来，外面调用时不须要知道内部的实现，继承指的是一个对象能够共享父级对象的一些属性，好比上文的问题中，形状Shape有顶点这个属性，三角形和矩形均可以继承该属性而不须要再从新定义。多态指的是封装以后的变化如何处理，好比上文中将draw函数放在形状Shape中，内部实现就是链接点，三角形和矩形调用父级对象的draw，三角形与矩形的顶点不一样。

为何要使用面向对象？面向对象由于封装，继承，多态的特征使程序更易于扩展，维护，重用。好比在另一个环境中咱们须要画三角形，咱们只须要将三角形这个对象及形状父级对象引入，剩下关于三角形的操做都是三角形这个对象的内部实现。维护起来去该对象的该方法找错，比在整个环境中找三角形函数要好不少。

js中的面向对象

面向对象中类指的是同一类型对象的抽象，首字母大写，好比上文中的形状 Shape 类，三角形是经过Shape扩展而来，则也是一个类，Shape称之为它的父类，它是Shape的子类，同理 Rect也是Shape的一个子类。类的具体抽象称之为实例，一般为小写，建立实例的过程称之为实例化。上文中triangle就是一个Triangle三角形的实例，指具体画出的那个三角形。关于父类，子类，实例咱们再用一个一个示例来展现

父类 Animal 
子类 Cat 实例 cat1_tom
子类 Dog 实例 dog1

Animal 指全部动物，Cat 指全部猫 继承Animal 是动物的一个子类，cat1_tom 指的具体一个叫 tom 的猫。有了类咱们就须要给类加一些标识，以区分类之间的区别、即属性和方法。

1.走出‘类’，走进原型

当咱们弄清楚了类是什么，JavaScript没有类的概念，是经过原型来实现面向对象。在以类为中心的面向对象编程语言中，类和对象的关系能够想象成铸模和铸件的关系，对象老是从类中建立而来。而在原型编程的思想中，类并非必需的，对象未必须要从类中建立而来，一个对象是经过克隆另一个对象所获得的。

从设计模式的角度讲，原型模式是用于建立对象的一种模式，若是咱们想要建立一个对象，一种方法是先指定它的类型，而后经过类来建立这个对象。原型模式选择了另一种方式，咱们再也不关心对象的具体类型，而是找到一个对象，而后经过克隆来建立一个如出一辙的对象。而克隆出来的这个对象会记住他的原型，由谁克隆而来，同时也会共享原型的属性和方法。这样一个一个对象克隆而来，则造成了一条原型链。对上文中的例子而言，三角形的原型是形状，猫和狗的原型是动物。

2.构造函数

在java中new Class()new 以后跟的是一个类名，而在js中类以后跟的是一个构造函数。

function Shape(name) {
  this.val = 1;
  this.name = name;
  this.all = '图形';
  return this.name
}
let a = Shape('a'); // 'a'

let shape1 = new Shape('triangle'); 
let shape2 = new Shape('rect');

构造函数的定义与通常函数的定义相同，注意首字母大写。构造函数本质上仍是一个函数，能够传参能够有返回值，只是内部使用了this变量，函数存在调用问题：

1. 直接调用：在浏览器环境中至关于在window上挂在了val这个属性，值为1。请注意这个特色，若是Shape.call(obj) 即至关于设定obj对象的val为1。
2. new 调用：生成一个实例，即生成一个新对象，这个this指向当前新生成的对象。

constructor和prototype

这里的概念还但愿你们阅读缓慢 最好能在浏览器或者node环境下敲一下理解更深。请首先必定理解何为实例何为构造函数(构造器)。他们的关系是
__A为B的构造函数 则 B为A的一个实例__。

在山的那边，海的那边，有一个prototype ，还有一个__proto__

首先建立一个Cat的构造函数，但愿say是Cat的实例共享属性，

function Cat(name) {
  this.name = name;
  this.say = function() {console.log(this.name)};
}

let cat1 = new Cat('tom'); 
let cat2 = new Cat('bob');
cat1.say === cat2.say // false

可是发现cat1 cat2的共有方法all并无共享，每个实例对象，都有本身的属性和方法的副本。这不只没法作到数据共享，也是极大的资源浪费， 那么引入prototype对象：

function Cat(name) {
  this.name = name;
}
Cat.prototype.say = function() {
  console.log(this.name);
}
let cat1 = new Cat('tom'); 
let cat2 = new Cat('bob');
cat1.say === cat2.say 
cat1.say === Cat.prototype.say; // true
cat1.prototype; // undefined
cat1.hasOwnProperty('say');// false

__实例对象的constructor属性指向其构造函数(1)__，这样看起来实例对象好像“继承”了prototype对象同样。__实例没有prototype__，上文最后一行代码经过hasOwnPropertyk能够判断say这个方法并非cat1本身的方法，__若是一个方法没有在实例对象自身找到，则向其构造函数prototype中开始寻找(2)__。

既然实例是继承自构造器的prototype，那么有没有一个属性能够直接表示对象的继承关系呢？答案是有的__proto__，不少浏览器都实现了这个属性，以下所示。

cat1.__proto__ === Cat.prototype // true
Cat.__proto__ === Function.prototype; // true
Function.prototype.__proto__ === Object.prototype; // true

从上咱们能够发现 Cat 构造器的原型为Function.prototype ，Cat.prototype的原型为Object.prototype，因此当cat1调toString时 Cat.prototype上没有找到 就去Function.prototype上寻找，这就构成了原型链。可是对象的原型链查找和构造函数的原型查找又有一点小区别(不查Function)，构造器生成的实例对象原型链的查找过程能够以下表示：

cat1 
 => cat1.__proto__(Cat.prototype) 
 => cat1.__proto__.__proto__(Function.prototype) 
 => cat1.__proto__.__proto__.__proto__ (Object.prototype)

还有经过对象字面量建立的对象的原型链查找方式

let obj = {};
obj => obj.__proto__(Object.prototype) ;

这里根据上文__加粗(2)__的语言能够获得__Function.prototype 的构造函数是Object(3)__。关于二者的关系，咱们后续继续讨论。

你们都有constructor

上文的两个实例对象cat1 cat2，他们都具备一个属性constructor，指向实例的构建函数Cat，意思是他们由Cat建立而来。__实例有一个constructor属性，指向其构造函数(4)__

cat1.constructor === Cat; // true
cat1.constructor === Cat; // true
Cat.constructor === Function; // true
Cat.prototype.constructor === Cat; // true

Object.constructor === Function;// true

构造函数一样具备construtor，指向Function，Cat.prototype一样具备construtor，指向他自身，__构造函数的prototype对象的constructor指向该构造函数(5)__。

根据上文最后一行代码 能够判断Object 的构造函数 是Function。则咱们能够获得Object是Function的一个实例。以下Object 与 Function的关系是

1. Object是Function的一个实例。
2. Function.prototype 是 Object 的 一个实例。

根据上文总结以下：

1. 实例对象的constructor指向其构造器。
2. 实例对象没有prototype。
3. 实例对象能够经过构造函数的prototype对象实现属性方法共享。’
4. 实例对象的__proto__原型指向其构造函数的prototype对象
5. 构造器的constructor指向 Function。
6. 构造函数的prototype能够挂在公共属性方法，prototype的constructor属性指向该构造函数。
7. 构造函数的__proto__原型指向 Function.prototype。
8. 构造函数prototype对象的__proto__原型指向Object.prototype。
9. 对象原型指的是对象的__proto__属性。

继承方式的渐进式

经过上面的知识咱们已经了解了原型的概念，接下来咱们来一步一步实现基于原型的继承。
在继承以前，咱们有必要统一一下概念及名词，

实例的归实例 构造器的归构造器

function Animal(name) {
  let name = name; // 私有属性
  this.getName = function() { // 特权方法 也是实例方法
      this.log(name);
    return name;
  }
  this.color = 'none'; // 实例属性
  this.say = function() { // 实例方法
    console.log(this.color);
  }
}
Animal.prototype.a = 1; // 公共属性
Animal.prototype.log = function(sth) { // 公共方法
  consoel.log(sth)
}

js没有严格意义的私有成员，因此对象属性都算作公开，因此咱们在私有 公有上不作赘述，只是判断改属性是在实例上 仍是在构造函数的prototype上。

1. 私有属性：指的是构造器内部的属性，构造器外部不能够得到，只能经过特权方法来访问。
2. 特权方法：通常称有权访问私有变量和私有函数的公有方法为特权方法，可是js没有共有方法的概念，这个方法是挂载在实例上的。
3. 实例属性(方法)：实例属性指的是挂载在实例自身的属性。
4. 公共属性(方法)：公共属性指的是挂在在构造器的prototype对象上的属性。

1. 直接修改prototype

咱们已经知道实例对象能够经过构造函数的prototype对象实现属性方法共享。即实例对象继承了构造器的.prototype对象，那么构造器和构造器之间的继承是否是也能够用这样的方式。

function Animal() {
  this.special = '猫';
};
function Cat() {}
let cat1 = new Cat();

如上，cat1要继承Animal的special属性，

1. 首先 cat1 做为构造器Cat 的一个实例能够继承 Cat.prototype 对象中得属性。
2. Cat.prototype 做为一个对象则应该继承 Animal.protoype.
3. Cat.prototype 应该做为构造函数Animal的一个实例。

function Animal() {
  this.special = '猫';
  this.arr = [2,3];
};
function Cat() {}
Cat.prototype = new Animal();
let cat1 = new Cat();
cat1.special; // '猫';

let cat2 = new Cat();
cat1.special = '狗';
cat2.special; // '猫'
cat1.special === Cat.prototype.special; // false
cat1.arr.push(1);
cat1.arr; // [2,3,1];
cat1.arr; // [2,3,1];

虽然咱们很简单就实现了继承，可是问题一转变，就出现了bug。好比我如今但愿cat1 cat2 的special 都是公共属性，arr 是实例属性。能够发现cat1操做了special 这个公共属性，cat2.special并无改变，可是cat1.arr 改变后 cat2.arr 也改变了。其次，构造器之间的继承不能传递参数，那让咱们更正2.0

2. 构造函数的函数特性

function Animal(name) {
  this.name = name;
  this.arr = [2,3];
};
Animal.prototype.special = '猫';

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

Cat.prototype = new Animal();

let cat1 = new Cat('tom');
let cat2 = new Cat('mary');

cat1.special = '狗'; 
cat2.special; // 猫;
cat1.hasOwnProperty('special'); // true
cat2.hasOwnProperty('special;); // false,

cat1.arr.push(1);
cat1.arr; // [2,3,1];
cat2.arr; // [2,3];

cat1.name; // 'tom'
cat2.name; // 'mary'

special做为公共的属性挂载在父级构造器prototype上，虽然咱们修改了cat1.special cat2.special没有改变，这主要是由于cat1.special 的改变是做用在实例而不是原型上，你们能够把这个公共属性改为数组或对象 做为一个引用存储，就能够发现special是公共属性。cat1.arr的操做不影响cat2.arr的操做。并且能够实现构造器直接传参，这里实在子级构造器的内部直接调用父级构造器，构造器调用方式的区别前文也介绍过了。

看到这里，好像咱们已经实现继承了，可是依然存在问题啊。代码的构建历来都是改大于写。

cat1.constructor; // [Function: Animal]

前文提到实例对象的constructor属性应该指向其构造函数，这里直接指向了父级构造器；在Cat构造器内部有一份Animal的实例属性，在Cat.prototype上一样有一份Animal的实例属性，属性重复。

3. 利用空构造器过滤实例属性

function Animal(name) {
  this.name = name;
  this.arr = [2,3];
};
Animal.prototype.special = '猫';

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

let F = function() {};
F.prototype = Animal.prototype;
Cat.prototype = new F();
Cat.prototype.constructor = Cat;
Cat.__proto__ = Animal.prototype;

let cat1 = new Cat('tom');
let cat2 = new Cat('mary');

cat1.constructor;

这里新建了一个空构造器 F() 让F.prototype = Animal.prototype，子级构造器
Cat.prototype = new F(); 这样在Cat.prototype中就没有那一份Animal实例化以后的数据。再将Cat.prototype.constructor 从新指会 构造器自己，则cat1.constructor ye的指向也没有问题了。同时修正了Cat的原型指向。

最后

首先感谢阅读彻底文，到这里，相信基本对于原型继承实现面向对象编程没有什么问题了。以后的主要矛盾在于问题的抽象上，如何抽象合适的对象，哪些属性和方法做为公共的，哪些做为实例的，这只有日积月累的经验才能给本身最好的答案。关键仍是在于理解了基础概念，多用，多练，就会发先问题。我就是自觉得理解了，可是在construtor指向上老犯糊涂，还有关于Object 与 Function，多用是加深理解的最好方式了，不妨之后再解决问题是，多考虑一下面向对象。

其次，不能限定本身必须使用什么，无论是黑猫仍是白猫，抓住老鼠就是好猫，代码的最终目的是为解决问题而生，同时代码是用来读的，不管是什么样的编程思路，逻辑清晰，可扩展，可复用，健壮性无缺那就是好代码。

最后的最后，文中如有错误，还请及时指正。最后一个学习方法的分享，当接触一个新的知识点或者工具，1.先会用 知道这个东西是什么(what?) 怎么用(how?)， 2. 会用以后不妨了解一下原理看看内部实现（why?)，3. 等研究的比较深入了，天然而然对在何种状况使用(where, when)。编程学习仍是要带着问题去学习，有问题，才会记得更深入，没问题的两种人，要么真的会了，要么一点都不会，再次感谢阅读~~~~