面向对象
面向对象是一种程序设计的思想，与面向过程不同，它引入了类的概念，将性质相似的一类物体抽象出来，作为设计图一般的存在，以实体的方式描述业务，重心放在了参与事务的对象身上，而不是逐步分离的步骤上。
面向对象有三个特征：封装、继承、多态
JS中的对象
JS是解释性的脚本语言，对于类的概念并没有JAVA那般严谨和规范，且拥有自己的特性和方法。
创建对象的过程，便是画一份设计图，JS一共提供了 7 种创建的方式（来自高程三），包括：
1.工厂模式
2.构造函数模式
3.原型模式
4.组合使用构造函数模式和原型模式
5.动态原型模式
6.寄生构造函数模式
7.稳妥构造函数模式
其中使用最广泛、认同度最高的方式是第四种：组合使用构造函数模式和原型模式，下面对每种方式进行粗略的描述。
创建对象
1.工厂模式
function createPerson(name,age){
var o = new Object();
o.name = name;
o.age = age;
o.sayName = function(){
alert(this.name)
};
return o;
}
var person = createPerson("亚当",99);
接收两个参数，在函数内部创建一个对象，然后将参数绑定后再返回，可以实现封装一个类的功能，但缺点是所有的对象的都是Object，无法准确判断它们的类型，比如“人”类是Object，“动物”类也是Object。
于是出现了构造函数模式。
2.构造函数模式
function Person(name,age){ //注意：首字母大写（惯例）
this.name = name;
this.age = age;
this.sayName = function(){
alert(this.name)
};
}
var person = new Person("亚当",99);
不用return对象，将属性和方法直接给了this对象，这样便可以用alert(person instanceof Person);//ture来检测对象的类型，这意味着将来可以将Person标识为一种特定的类型，更利于类的概念。
有了“类”的模板，就可以照着模子捏人了，使用构造函数创建对象，必须使用到new操作符，若是当做普通函数来使用，就相当是为全局对象添加了属性，最后会出现window.sayName();//打印出传入的name变量，而使用new来调用构造函数会经历一下四个步骤：
1.创建一个新对象
2.将构造函数的作用域赋给新对象
3.执行构造函数中的代码（为新对象添加属性）
4.返回这个新对象
构造函数模式同样有其缺陷，比如上面的例子中，如果创建了两个“人”，就有两个同样的sayName()方法，可以实现同样的功能（打印名字），一个两个还好，如果我们有成百上千个Person实例的话，name就有千百个satName()方法，这在内存中的开销无疑是极大的，既然是同样的功能，那么让它们共同使用一个函数就足够了，因此可以将这个函数摘出来，这样写：
function Person(name,age){ //注意：首字母大写（惯例）
this.name = name;
this.age = age;
this.sayName = sayName;
}
function sayName(){
alert(this.name);
}
将内部引用外部命名的函数，而将函数体放在外面，这样指向的就是同一个方法了，只是如此一来sayName这个方法相当于是放在了全局作用域中，但方法本身却只想让Person的对象使用，大炮打蚊子，有点小尴尬，同时类的封装性也遭到了破坏，由此问题，便引出了第三种创建方法——原型模式。
3.原型模式
每个构造函数都有一个prototype属性，这个属性是一个指针，指向一个对象，而这个对象的用途，便是容纳同一类下所有实例公有的方法和属性，写法如下。
function Person(){
}
Person.prototype.name = "亚当";
Person.prototype.age = "99";
Person.prototype.sayName= function(){
alert(this.name)
};
var person = new Person();
//或者写的更简洁一些：
Person.prototype = {
name : "亚当",
age : "99",
sayName : function(){
alert(this.name);
}
}
好处很明显，同一类下所有对象可以共享属性和方法，当然，缺点一样明显，创建对象的时候无法传入自定义参数，除非设置如person1.name = “夏娃”;才会覆盖掉原来的名字，更为严重的是，如果Person的原型中包含了一个数组（引用类型），如果一个对象修改了这个数组，其他对象的数组都会发生变化，因为引用类型的变量指向的是同一块内存地址，这样事情就变得很麻烦了。
构造函数模式无法设置共享的属性，而原型模式无法自定义属性，那如果将两者优点结合起来，那不是天下无敌了吗！？
所以，我们有了第四种方式——组合使用构造函数模式和原型模式。
4.组合使用构造函数模式和原型模式
function Person(name,age){
this.name = name;
this.age = age;
}
Person.prototype = {
constructor : Person, //确保实例的构造函数指向Person
sayName : function(){
alert(this.name);
}
}
var person = new Person("亚当",99);
可以自定义的属性（包括引用类型）都放在构造函数里，随便修改都不会影响其他实例，而公共的方法则放在原型对象中，避免资源浪费。
这种模式也是目前在ECMAScript中使用最广泛、认同度最高的一种创建自定义的方法。
至此，基本的几种已经介绍完了，后面三种会简单介绍一下
5.动态原型模式
当我们为对象定义一个方法时，有时可能存在冲突，必要的情况下，我们可以检查某个应该存在的方法是否有效，如果有效，看一眼走人，如果无效，我们再初始化原型。
function Person(name,age){
this.name = name;
this.age = age;
}
//方法
if(typeof this.sayName != "function"){ //如果sayName不是函数
Person.prototype.sayName= function(){
alert(this.name)
}
};
如上述代码，仅当sayName方法不存在的情况下，才会在原型中添加此方法，而且只会在初次调用构造函数的时候才会执行这条语句，一旦定义后，由于是定义在原型上的方法，所有对象之后都可以直接调用了。
这种方法的缺陷，同样是不能重写原型，否则会切断现有实例与心源性之间的联系。
6.寄生构造函数模式
唔…在前面几种模式都不适用的情况下（应该不会遇到吧…），可以使用寄生构造函数模式创建对象，基本思想是：创建一个函数，其作用仅仅只是封装创建对象的代码，然后再返回新创建的对象。
function Person(name,age){
var o = new Object();
o.name = name;
o.age = age;
o.sayName = function(){
alert(this.name)
};
return o;
}
var person = new Person("亚当",99);
除了用new操作符以外，其余写法和工厂模式一模一样，一般会在特殊情况下使用它，例如要创建一个数组对象（Array），但在这个对象中要添加新的方法，直接修改Array的构造函数的话，程序里所有的数组都变了，GG，所以可以使用这个模式。代码如下：
function specialArray(){
var arr = new Array();
arr.newFunction = function(){
alert("我叫数组的新方法")
}
balabalabala... //其他要添加的新方法或操作
return arr;
}
var list = new specialArray();
list.newFunction(); //我叫数组的新方法
要注意，返回的对象与构造函数之间没有关系，不能使用instanceof来确定对象类型，这一点与工厂模式相同，因此建议尽可能不要使用这种方法。
7.稳妥构造函数模式
稳妥对象，指的是没有公共属性，也不引用this对象，这种模式适合在禁止使用 this 和 new 的环境中，或者在防止数据被其他应用程序（如Mashup程序）改动时使用，除了不使用 this 和 new 以外，和寄生构造函数模式类似，代码如下：
function Person(name,age){
var o = new Object();
//可以在这里定义私有变量和属性
o.sayName = function(){
alert(name)
};
return o;
}
var person = Person("亚当",99);
person.sayName(); //亚当
除了使用sayName() 方法外，没有其他办法访问 name 的值，方法中定义的私有变量和属性也无法影响传入的 name 值，安全性杠杠的！
当然，与寄生构造函数模式、工厂模式相同，它也不能使用 instanceof 检测其类型。
继承
有了实体，为了简化定义，自然就有了继承的概念，比如已经定义了一个“人”类，后面需要详细分出“男人”和“女人”，若是在后者的定义中再重述一边“人”的相关属性，就相当于重复的内容写了三次，麻烦且多余，若是有一个方法，在已有类的基础上，还能再根据要求添加新的属性，便能极大地简化效率，继承的作用便是这样！
原型和原型链
继承和原型链息息相关，关于面向对象和原型的定义，我写的上一篇文章中已经解释过了，这里不再赘述，有需要的小伙伴可以翻阅一下。
prototype是个指向对象的指针，可以简单一点来记忆，它揍是原型对象！咱们依旧用 Person 这个类来简单描述一下：
Person() 是构造函数，也就是设计图、模板，照着这个模板，我们可以捏出来一个有名字、有年龄、活生生的“人”，这个过程就叫做实例化，被捏出来的这个“人”就是 Person 类的一个实例，而 在原型（prototype） 上，我们则可以放置一些公有的属性和方法，比如捏出来（实例化）的人，名字虽然都不一样，但可以定义一个共享的方法，让每个人都能说出自己的名字。
但是 prototype 只有构造函数，或者说只有函数才有，普通的实例不存在原型这么个玩意，那它是肿么访问到原型上的方法的呢？这里就需要介绍到对象拥有的一种属性: proto（注意：前后都是两个下划线）
__proto__同样是个指针，而且指向的是原型对象（prototype），另外，由于原型对象也是个对象，所以他也有__proto__属性（ Person.prototype.proto）
根据上面所说的总结一下：
1、每个构造函数（ Person() ）都有一个原型对象（ prototype）
2、原型对象都包含一个指向构造函数的指针（ constructor )
3、实例都包含一个指向原型对象的内部指针（ proto）
所以创建一个“人（person）”后，通过这一些系列的操作，最终就会使得person.proto== Person().prototype。
那如果我们让原型对象和另一个类型的实例相等，比如我们还有一个类：function Biology(){} //生物类，我们让Person.prototype = new Biology(),OK，现在 Biology 里拥有的属性和方法 Person 都可以用了，就好比说人类也是生物，都有新陈代谢，都能发育繁殖，之后我们只需要在 Person() 中再添加一些关于“人”独有的属性，这样就成功定义出来了一个“人”类，同理，一个Animal（动物）类也可以通过这种方式来定义，而不用每次都重写那些生物共有的属性和方法，这，就叫做继承！
如果在 Person 下还有 Father() Son() Grandson() 等一系列类，他们同样通过上述的方式一层又一层的继承下来，实例和原型组合成一根长长的链条，我们就将之形象的称为原型链。
继承方式
高程三上详细记录了六种继承方式，分别如下所示：
1.原型继承
2.借用构造函数继承
3.组合继承（最优方式）
4.原型式继承
5.寄生式继承
6.寄生组合式继承
1.原型继承
原型继承其实就是上面原型链里的那个例子，即：
function Biology() { //父类--生物类
this.kind = "我是生物";
}
Biology.prototype.growUp = function () {
console.log(this.kind+"，生物都会长大");
}
function Person(name,age) { //子类--人类
this.name = name;
this.age = age;
}
Person.prototype = new Biology(); //让人类 继承 生物类
Person.prototype.sayName = function () { //注意：新定义的方法要放在替换原型的语句之后
console.log(this.name);
}
//实例化对象
var biology = new Biology();
biology.growUp(); //我是生物，生物都会长大
var person = new Person("亚当",99);
person.growUp(); //我是生物，生物都会长大
person.sayName(); //亚当
上述代码中定义了两个类，一个是‘生物’类，一个是‘人’类，从结果上显而易见，实例化的“亚当”可以轻松的调用属于 Biology 的方法（growUp()），而且“人”类还有属于自己的属性（name）和方法（sayName()），实现了我们所要的功能。
这是继承最基本的写法，也是最原始的方法，问题有很多：
第一：无法确定实例和原型的关系，比如上述的亚当，既是“人”类，也是“生物”类，还是一个物体对象（Object），使用instranceof操作符判断时，三者都返回true，
第二：使用字面量添加新方法时，会重写原型链，导致继承无效，如：
Person.prototype = {
sayName : function(){
//balabala...
}
}
这样写完以后，person就无法调用Biology的growUp 方法了。
第三：如果超类存在引用类型的属性（如数组等），所有的实例在访问这个引用类型的属性时都指向同一块内存地址，一个做出操作，剩下的都会跟着变化。
第四：创建子类型的实例时，不能向超类中传递参数。
有鉴于此，实践中一般很少单独使用原型链实现继承。
2.借用构造函数（经典继承）
基本方法是在子类中调用超类的构造函数，需要借用call()和apply()方法，如下所示：
function Biology(kind) { //父类--生物类
this.kind = kind;
}
function Person(name,age) { //子类--人类
Biology.call(this,"我是人类");
this.name = name;
this.age = age;
}
使用call()和apply()方法，可以在借用超类构造函数时传递参数（kind），并且在子类中还可以定义新的属性（name、age）。注意，传递的参数只有一个的话，使用call()，若是多个参数，则用apply()方法。
借用构造函数实现继承的方法，其问题与用构造函数定义对象相同，即方法全放在了构造函数中，子类实例化时产生了多个同样的方法，复用性太差，而且超类型原型中定义的方法，对子类不可见，因此，这种方式也很少单独使用。
3.组合继承（伪经典继承）
顾名思义，就是将原型链和构造函数两种方法组合在一起，取长补短的一种继承模式。
function Biology(kind) { //父类--生物类
this.kind = kind;
}
Biology.prototype.growUp = function () {
console.log(this.kind+"，生物都会长大");
}
function Person(name,age) { //子类--人类
Biology.call(this,"我是人类"); //继承属性
this.name = name;
this.age = age;
}
Person.prototype = new Biology(); //让人类 继承 生物类
Person.prototype.constructor = Person;
Person.prototype.sayName = function () {
console.log(this.name);
}
这种方法是JS中最常用的集成模式，原理是将每个实例独有的属性放在构造函数中，而将共享的方法放在原型链中，这样每个实例既有各自独有的空间，又有公共共享的空间。
这一方法与组合使用构造函数模式和原型模式的创建对象方法类似，上一篇创建对象文章中有详细讲解，这里不再重复。而且组合继承同样存在不足之处，这里暂且按下，待会解释。
4.原型式继承
在没有必要兴师动众的创建构造函数，而只是想让一个对象与另一个对象保持类似的时候，可以考虑使用原型式继承，其原理如下：
function newObject(obj){
function F(){}
F.prototype = obj;
return new F();
}
var child = newObject(person)
child.name = "亚当的孩子"
创建一个临时的构造函数，然后将传入的对象（obj）作为这个构造函数的原型（prototype），最后返回一个临时类型的实例（new F()）。
ES5中已经将原型式函数规范化，即新增的Object.create()方法，在传入一个参数的情况下，与上述的newObject()方法相同，如var child = Object.create(person)，也可以通过传入第二个可选的参数，自定义传入一个对象，覆盖原型对象上的同名属性，如下所示。
var child = Object.create(person,{
name:{
value:"亚当的孩子"
}
})
这种方式的缺陷依旧在于引用类型的属性，所有继承了超类的实例，都可以随意改变引用类型的内容，而且会互相影响，共享内存空间。
5.寄生式继承
这种方式可以创建一个仅用于封装继承过程的函数，在内部可以让对象做出某些增强，这种方式与原型式继承密切相关，如下代码所示：
function createAnother(obj){
var clone = Object.create(obj);
clone.saySpecial = function(){
alert("我变秃了，也变强了");
}
return clone;
}
var child = createAnother(person);
child.saySpecial(); //我变秃了，也变强了
在主要考虑对象，而不是自定义类型和构造函数的情况下，寄生式继承也是一种有用的模式，而且Object.create();函数并不是必须的，任何能返回新对象的函数都适用于这种模式。它可以说是原型式继承的一种拓展，但依旧没有类的概念，无法做到函数复用，与构造函数模式类似。
6.寄生组合式继承
上面说到，组合继承是JS最常用的继承模式，但它也有不足之处，那就是无论什么情况下，都会调用两次超类型的构造函数，一次是在创建子类型原型的时候（new），另一次是在子类型构造函数内部（call()），最终子类型会包含超类型对象的全部实例属性，我们要在调用子类型构造函数的时候重写这些属性。如下所示：
function Biology(kind) { //父类--生物类
this.kind = kind;
}
Biology.prototype.growUp = function () {
console.log(this.kind+"，生物都会长大");
}
function Person(name,age) { //子类--人类
Biology.call(this,"我是人类"); //第二次调用Biology()
this.name = name;
this.age = age;
}
Person.prototype = new Biology(); //第一次调用Biology()
Person.prototype.constructor = Person;
Person.prototype.sayName = function () {
console.log(this.name);
}
调用了两次，就是创建了两次同名的属性，只不过后面那次把前面的覆盖掉了而已。基于这种情况，便有了更进一步的寄生组合式继承，总结起来就是一句话：
通过借用构造函数来继承属性，通过原型链的混成形式来继承方法。
简单一点的原理就是：不必每次都调用父类型的设计图（构造函数），拷个副本下来就可以喽！所以，先用寄生式继承来继承超类型的原型，然后再将结果指定给子类型的原型。如下代码所示：
function inheritPrototype(Super,Sub){
var superProtoClone = Object.Create(Super.prototype)
superProtoClone.constructor = Sub
Sub.prototype = Super
}
第一步：通过寄生式继承，创建一个超类原型的副本。
第二步：弥补因重写原型而失去的默认的constructor属性。
第三部：将新创建的对象（副本）赋给子类型的原型。
这样，我们就可以通过调用这个函数，省去Person.prototype = new Biology();这一步，后续代码如下所示：
inheritPrototype(Person,Child)
Person.prototype.sayName = function () {
console.log(this.name);
}
这样做便实现了只调用一次Person的构造函数，避免在子类的原型上创建了多余的属性，而且原型链还能保持不变，可以正常使用instranceof()方法，这种方式是引用类型最理想的继承方式，但是…过程过于繁琐，如果可以的话，还是组合继承来的快一点。
161
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
