面向对象的程序设计(二)

tips：接下去会在github写博客，简书不再更新和修改文章，欢迎大家逛逛我的新博客点击查看 ，我会尽量用更容易理解的方式写好每一篇博客,大家一起学习交流😄。

继承

概念

OO语言中支持两种继承方式：实现继承，接口继承

• 实现继承：继承实际的方法
• 接口继承：继承函数签名

由于函数没有签名，在ECMAScript中只支持实现继承，而且是依靠原型链来实现的

原型链

[图片上传失败...(image-c69d0c-1522079505212)]

原型链的问题（缺点）

• 1、当在实例中对引用类型的值进行操作时，很有可能改变原型中的值。（共享问题）
• 2、在创建子类型的实例时，不能向超类型的构造函数中传递参数

默认的原型

• 所有函数的默认原型都是Object的实例，因此默认原型都会包含一个内部指针，指向Object.prototype。

如何确定原型和实例之间的关系

• 1、通过instanceof:测试实例与原型链中出现过的构造函数，结果会返回true

       alert(instance instanceof Object)    //true  
        alert(instance instanceof SuperType)    //true  
        alert(instance instanceof Subtype)    //true  

• 2、isPropertyOf()方法：只要是原型链中出现过的原型，都会返回true

        alert(Object.prtotype.isPropertyOf(instance))    //true  
        alert(SuperType.prtotype.isPropertyOf(instance))    //true  
        alert(Subtype.prtotype.isPropertyOf(instance))    //true  

定义方法时要注意的几个问题

• 场景：子类型优势需要覆盖超类型中的某个方法，或者需要添加类型中不存在的某个方法
• 2、不能通过对象字面量方法添加新方法（因为会重写原型链）
• 1、给子类型添加方法的代码一定要放在替换原型的语句之后（否则会因为重新定义了原型而导致添加代码无效）

基本思想：利用原型，让一个引用类型继承另一个引用类型的属性和方法

例子：

function SuperType(){  
    this.SuperProperty = true;  
};  
SuperType.prototype.getSuperProperty = function(){return this.SuperProperty};  
  
function SubType(){  
    this.SubProperty = false;  
};  
SubType.prototype = new SuperType();  
SubType.prototype.getSubProperty = function(){return this.getSubProperty};  
  
var instance = new SubType();  
alert(instance.getSuperProperty()) //true  

借用构造函数

缺点

• 1、方法都在构造函数中定义，函数无法复用，每个方法都是function的一个新实例
• 2、在超类型的原型中定义的方法，对子类型而言也是不可见的，结果所有类型都只能使用构造函数模式

传递参数

• 优点：借用构造函数有一个很大的优势，即可以在子类型构造函数中向超类型构造函数传递参数

  function SuperType (name) {function   
    this.name= name;  
    }  
    function SubType () {  
    //继承了Super'l'ype, 同时还传递了参数  
    superType.call(this, "Nicholas");  
    //实例属性  
    this.age= 29;}  
    var instance= new SubType();  
    alert(instance.name) ; //“Nicholas” alert(instance.age); //29  
    

基本思想：在子类型构造函数中调用超类型构造函数

    function SuperType(){  
    this.color = ["red","blue","yellow"]      
};  
function SubType(){  
    SuperType.call(this);  
};  
  

组合继承

概念

• 1、将原型链和借用构造函数的技术组合到一块，从而发挥二者之长的一种继承模式，又叫伪经典继承
• 2、基本思想：使用原型链实现对原型属性和方法的继承，而通过构造函数来实现对实例属性的继承
• 3.是JavaScript中最常用的继承模式

优点：既通过在原型上定义方法实现了函数的复用，又能够保证每个实例都有它自己的属性

组合继承避免了原型链和借用构造函数的缺陷，融合了它们的优点，成为javascript中最常用的继承模式

function SuperType(name){

    this.name = name;  
    this.color = ["red","blue","yellow"]  
};  
SuperType.prototype.sayName = function(){alert(this.name)};  
function SubType(name){  
    SuperType.call(this,name);  
    this.age = age;  
};  
SubType.prototype = new SuperType();  
SubType.prototype.constructor = SubType;  
SubType.prototype.sayAge = function(){alert(this.age)};  

原型式继承

Object.creat()

• 参数一
  • 用作新对象原型的对象

     var person = {name:"Nick" ,friends:["Tom","Sam"]};  
        var anotherPerson =Object.create(person);  

• 参数二
  • 为新对象定义额外属性的对象（以这种方式指定的任何属性都会覆盖原型对象上的同名属性），注意格式

       var person = {name:"Nick" ,friends:["Tom","Sam"]};  
        var anotherPerson =Object.create(person,{  
            name:{  
            value:"Greg"  
            }  
        });  

• ECMAScipt5通过新增的Object.create()规范化了原型式继承

核心

function object(o){  
    function F(){};  
    F.prototype = o;  
    return new F();  
}  

例子

var person = {name:"Nick" ,friends:["Tom","Sam"]};  
var anotherPerson =object(person);  
//person成为了anotherPerson的原型  

寄生式继承

寄生式继承的思路与寄生构造函数和工厂模式类似，即创建一个仅用于封装继承过程的函数，该函数在内部以某种方式来增强对象，最后再像真地是它做了所有工作一样返回对象。

缺点：不能实现函数复用

function creatAnother(original){  
    var clone = object(original);  
    clone.sayHi = function(){alert("Hi")};  
    return clone;  
}  

在主要考虑对象而不是自定义类型和构造函数的悄况下，寄生式继承也是一种有用的模式。

寄生组合式继承

所谓寄生组合式继承，即通过借用构造函数来继承属性， 通过原型链的混成形式来继承方法。

基本思路： 不必为了指定子类型的原型而调用超类型的构造函数，我们所需要的无非就是超类型原型的一个副本而已。本质上，就是使用寄生式继承来继承超类型的原型，然后再将结果指定给子类型的原型。

目的：解决组合继承模式中调用两次超类型构造函数，导致属性重写，影响性能的问题

• 组合继承例子：

function SuperType(name){  //超类型构造函数  
        this.name=name;  
        this.color={"red","blue","green"]  
      }  
     SuperType.prototype.sayName=function(){  
     alert(this.name);  
     function SubType(name,age){  
         SuperType.call(this,name) //第二次调用  
         this.age = age;  
     }  
     SubType.prototype = new SuperType(); //第一次调用  
     SubType.prototype.construtor =SuperType;  
     SubType.protptype.sayAge =function(){  
         alert(this.age)  

这个例子高效体现在它只调用了一次SuperType的构造函数，并且避免了再prototype上创建不必要的、多余的属性。同时还能保证原型链不变

   function inheritPrototype(subType,superType){  
    //prototype成为superType的一个副本，而不用调用构造函数  
    var prototype = SuperType.prototype;  
    prototype.constructor = SubType;  
    SubType.prototype = prototype;  
};  
  

例子

function SuperType(name){  
    this.name = name;  
};  
SuperType.prototype.sayName = function(){alert(this.name)};  
function SubType(name,age){  
    SuperType.call(this,name);  
    this.age = age;  
}  
inheritPrototype(Subtype,SuperType);  
SubType.prototype.sayAge = function(){alert(this.age)};  

    function inheritPrototype(SubType，SuperType){   
      var prototype = object(SuperType.prototype);//创建对象  
     prototype.constructor = subType;//增强对象  
      subType.prototype = prototype ;//指定对象  
  }  

• 在函数内部，第一步是创建超类型原型的一个副本。第二步是为创建的副本添加constructor屈性，从而弥补因重写原型而失去的默认的constructor属性。最后一步， 将新创建的对象（即副本）赋值给子类型的原型。