文章目录

  • 面向对象
  • 继承
  • 原型和原型链
  • 继承方式


面向对象

面向对象是一种程序设计的思想,与面向过程不同,它引入了类的概念,将性质相似的一类物体抽象出来,作为设计图一般的存在,以实体的方式描述业务,重心放在了参与事务的对象身上,而不是逐步分离的步骤上。
  面向对象有三个特征:封装、继承、多态

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()方法,这种方式是引用类型最理想的继承方式,但是…过程过于繁琐,如果可以的话,还是组合继承来的快一点。

参考链接:https://www.jianshu.com/p/270a037c46c9