javascript面向对象的结构 js中面向对象

文章目录

• 面向对象
• 继承

• 原型和原型链
• 继承方式

面向对象

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

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