javascript面向对象

时间 2019-11-12

原文原文链接

# javascript面向对象（一）

对象其实就是一种引用类型。而对象的值就是引用类型的实例。在JavaScript 中引用类型是一种数据结构，将数据和功能组织在一块儿。它也常被称作为类，但JavaScript 中却没有类的概念。虽然JavaScript 是一门面向对象的语言，却不具有传统面向对象语言所支持的类和接口等基本结构。

## 对象的建立以及经常使用操做 ##

1. **使用new运算符**
javascript

var user = new Object();        //使用new运算符建立一个对象

        user.name = 'tina;        //给对象添加属性

        user.age = 22;

        user.address = '四川成都';

2. **对象字面量(JSON方式)**
java

var user = {

            name:'编程浪子',

            age:22,

            address:'四川成都'    

        };

3. **简单方式(传统赋值方式)**
程序员

 var user = {};

        user.name = 'tina';        //给对象添加属性

        user.age = 22;

        user.address = '四川成都';

4. **属性的调用**

    对于对象属性的调用有两种方式：
    调用方法以下：
    alert(user.name + " " +user.age);//返回 '编程浪子四川成都'
    另外一种方法：
    alert(user['name'] + " " +user['age']);//返回 '编程浪子四川成都'

5. **添加方法**
    编程

var user = {
            name:'tina',        //给对象添加属性
            age:22,
            address:'四川成都',
            showInfo:function(){//添加一个方法
                alert(this.name+" "+this.age+" "+this.address);
            },
            showHello:showHello//将对象外部的方法添加到对象
        };
        function showHello(){
            alert("Hello!");    
        }
        user.showInfo();//调用方法
        user.showHello();

# javascript面向对象(二) #

## 建立对象 ##

咱们知道，要建立一个对象咱们能够用以下代码：

数组

  var user = new Object();  

    user.name = '编程浪子';

    user.age = 22;

    user.address = '四川成都';

用这样的方法建立对象比较简单直观，也是JavaScript种建立对象最基本的方法。可是这样就有一个问题，若是咱们须要建立多个对象，那么我就得写不少重复的代码。好比咱们想建立另外一个对象user1，咱们就得从新将上面的代码从新写一遍，这在实际开发过程当中是不合适的，这样若是对象过多，代码量将大大增长。

为了解决这样的问题，咱们可使用一种叫作**工厂模式**的方法，这种方法就是为了解决实例化对象产生大量重复代码的问题。

## 工厂模式 ##
浏览器

 1  function create(name, age) {
 2 
 3     　　var obj = new Object(); 
 4 
 5     　　obj.name = name; 
 6 
 7     　　obj.age = age;
 8 
 9     　　obj.show = function () {
10 
11     　　　　return this.name +' '+ this.age;
12 
13     　　};
14 
15     　　return obj;
16 
17     }
18 
19     var obj1= create('bclz', 30);    //第一个实例
20 
21     var obj2= create('bcxb', 20);    //第二个实例
22 
23     alert(obj1.show());
24 
25     alert(obj2.show());

从上面的代码咱们能够看出，工厂模式解决了实例化时代码大量重复的问题，但又出现了一个问题，那就是识别问题，咱们根本没法弄清楚他们究竟是哪一个对象的实例。好比
数据结构

alert(typeof obj1);  //Object
    alert(obj1 instanceof Object);  //true

以上代码标明obj1是Object对象，可是咱们没法知道具体是哪个对象建立的。

## 构造函数(构造方法) ##
函数

 1 function User(name, age) {    //构造函数模式
 2 
 3     　　this.name = name;
 4 
 5     　　this.age = age;
 6 
 7     　　this.show = function () {
 8 
 9     　　　　return this.name  + ' '+this.age;
10 
11     　　};
12 
13     }

建立对象的时候用new运算符就能够了：
测试

var user1 = new User('bclz', 30);    //第一个实例

    var user2 = new User('bcxb', 20);    //第二个实例

如今咱们就能够检测user1或者user2是否是属于User。

this

alert(user1 instanceof User);//true

可见，使用构造函数的方法，即解决了**重复实例化**的问题，又解决了**对象识别**的问题。

要建立User对象的新实例，就要使用new操做符，使用这个方式构建实例对象，会通过下面4个步骤：

1.建立一个新对象；
2.将构造函数的做用域给新对象(所以this指向的这个新对象)。
3.执行构造函数内的代码在(为新对象添加属性)；
4.返回新对象。

不过须要注意下面两个问题:

1)：构造函数也是函数**

构造函数与函数的惟一区别，就是调用方式的不一样，不过，构造函数毕竟也是函数，不存在什么特殊的定义构造函数的语法。任何函数，只要经过new操做符来调用，就能够把它看做是构造函数；而任何函数，若是不经过new操做符调用，它就和普通函数没有什么区别，例如前面定义的User:

 1 //看成构造函数调用
 2 
 3     var user1 = new User('bclz', 30);  
 4 
 5     user1.show(); //bclz 30;
 6 
 7 
 8 
 9     //看成普通函数调用
10 
11     User('bclz', 30);
12 
13     window.show(); //bclz 30;

结果上没有什么区别，只是你们能够看到，看成普通函数调用的话，函数里this对象的指向，实际上是指向的window全局对象。而经过new关键字调用，this指向的则是新对象而已，因此，其实还能够这么来写:

    var o = new Object();

    User.call(o,'bclz', 30)；

    o.show();

经过函数方法call来从新定义对象的做用域，这里很少作解释，讲到函数细节时再仔细介绍这种方法，这里只是说明能够改变对象的做用域的，其实就是**改变this的指向**

**2)：构造函数的问题**

构造函数的模式虽然好，可是并不是没有缺点。构造函数最大的问题就是，每一个方法都要在实例上从新建立一次。在前面的例子中,user1和user2中都有一个show方法，若是咱们执行如下语句：

 alert(user1.show==user2.show);//结果返回的是false

结果返回的是false，这就说明方法其实也是一种引用地址。若是咱们一样重复建立了多个对象，那么每一个对象中的方法都会在内存中开辟新的空间，这样浪费的空间就比较多。要解决这个问题，咱们就须要用到实例属性或者方法的共享。咱们可使用一种变通的方式，来达到咱们想要的效果，也就是让show方法再也不重复建立

 1  function User(name, age) {    
 2 
 3     　　this.name = name;
 4 
 5     　　this.age = age;
 6 
 7     　　this.show = show;
 8 
 9     } 
10 
11     function show(){
12 
13         alert(this.name + ' ' + this.age);
14 
15     }

将show方法移到外部，至关于show方法成了一个全局函数,而后再到User构造函数内部去引用show方法，这样User内部的this.show都指向了同一个全局函数show，所以，咱们实例化的user1和user2就实现了共享，能够再次调用:

 alert(user1.show==user2.show);//结果返回的是true

可是这只是一个测试，若是你要让更多的属性或者方法实现共享，那不是要定义更多的全局函数或者变量，这种方式是不科学也不可行的。所以，咱们须要引入另一个javascript面向对象的重要概念**原型**

# javascript面向对象(三) #

## Prototype原型模式 ##

## 经过构造函数的弊端引出原型概念 ##

为了讲清楚原型，咱们仍是必须先回顾一下构造函数的问题，用一个简单的例子再次讲解一下,咱们有一只猫的构造函数，以下:

1   function Cat(name,color){
2         this.name = name;
3         this.color = color;
4     }

这个构造函数很简单，再也不多说，那么如今再为这个函数添加一个不变的属性"type"（种类），再添加一个方法eat（吃老鼠）。那么，Cat就变成了下面这样:

 1     function Cat(name,color){
 2         this.name = name;
 3         this.color = color;
 4         this.type = "猫科动物";
 5         this.eat = function(){alert("吃老鼠");};
 6     }
 7 
 8 
 9 //生成实例:  
10 
11     var cat1 = new Cat("大毛","黄色");
12     var cat2 = new Cat ("二毛","黑色");
13     alert(cat1.type); // 猫科动物
14     cat1.eat(); // 吃老鼠

表面上好像没什么问题，可是实际上这样作，有一个很大的弊端。那就是对于每个实例对象，type属性和eat()方法都是如出一辙的内容，每一次生成一个实例，都必须为重复的内容，多占用一些内存。这样既不环保，也缺少效率。

   alert(cat1.eat == cat2.eat); //false

所以，为了让type属性和eat()方法在内存中**只生成一次**，而后全部实例都指向那个内存地址，引出了原型

## 什么是原型？ ##

> 原型对象实际上就是构造函数的一个实例对象，和普通的实例对象没有本质上的区别。能够包含特定类型的全部实例的共享属性或者方法。这个prototype的属性值是一个对象（属性的集合），默认的只有一个叫作constructor的属性，指向这个函数自己。
好比咱们简单定义一个SuperType名字的函数，里面什么属性也没有在函数内部是这个样子的

  function SuperType(){

    }

从上图咱们看到，函数里面虽然什么都没有，可是有一个默认的prototype属性,它是一个对象，它指向的是本身的地址，而prototype这个对象自己里面又有一个属性constructor，而这个属性，又指向了函数自己,有点绕，你能够经过下面的代码作一下测试，看看效果

    alert(SuperType.prototype) //object

    alert(SuperType.prototype.constructor) //弹出函数自己function SuperType(){}

prototype和constructor是原型最基本的概念,如今看可能还有点晕，不要紧，我直接上之前的代码，看看区别,仍是以前的Cat构造函数，将它修改一下:

 1  function Cat(name,color){
 2 
 3         this.name = name;
 4 
 5         this.color = color;
 6 
 7     }
 8 
 9     Cat.prototype.type = "猫科动物";
10 
11     Cat.prototype.eat = function(){alert("吃老鼠")};  
12 
13 //生成实例:
14 
15 
16 
17     var cat1 = new Cat("大毛","黄色");
18 
19     var cat2 = new Cat("二毛","黑色");
20 
21     alert(cat1.type); // 猫科动物
22 
23     cat1.eat(); // 吃老鼠

这时全部实例的type属性和eat()方法，其实都是**同一个内存地址**，**指向prototype对象**，所以就提升了运行效率。

alert(cat1.eat == cat2.eat); //true

## Prototype模式的验证方法 ##

为了配合prototype属性，Javascript定义了一些辅助方法，帮助咱们使用它。

**isPrototypeOf()**

这个方法用来判断，某个proptotype对象和某个实例之间的关系。

    alert(Cat.prototype.isPrototypeOf(cat1)); //true

    alert(Cat.prototype.isPrototypeOf(cat2)); //true

**hasOwnProperty()**

每一个实例对象都有一个hasOwnProperty()方法，用来判断某一个属性究竟是本地属性，仍是继承自prototype对象的属性。

    alert(cat1.hasOwnProperty("name")); // true

    alert(cat1.hasOwnProperty("type")); // false

**in运算符**

in运算符能够用来判断，某个实例是否含有某个属性，无论是否是本地属性。

    alert("name" in cat1); // true

    alert("type" in cat1); // true

in运算符还能够用来遍历某个对象的全部属性。

  for(var prop in cat1) { 

        alert("cat1["+prop+"]="+cat1[prop]); 

    }

来看一下 **javascript高级程序设计** 书中对与原型的描述和说明

 1   function Person(){ }  //建立Person构造函数
 2 
 3     Person.prototype.name = "Nicholas";//建立共享属性name 
 4 
 5     Person.prototype.age = 29; //建立共享属性age 
 6 
 7     Person.prototype.job = "Software Engineer"; //建立共享属性job 
 8 
 9     Person.prototype.sayName = function(){     //建立共享函数sayName
10 
11         alert(this.name); 
12 
13     };  
14 
15     
16 
17     //分别建立了person1和person2,里面都有sayName函数，而且弹出的值都是同样
18 
19     var person1 = new Person(); 
20 
21     person1.sayName();   //"Nicholas"  
22 
23     var person2 = new Person();
24 
25     person2.sayName();   //"Nicholas"  
26 
27     alert(person1.sayName == person2.sayName);  //true

经过上面的图，能够看到，person1和person2，他们内部都有一个指向Person.prototype的指针，能够经过原型的isPrototype方法测试一下

 1  alert(Person.prototype.isPrototypeOf(person1));  //true
 2 
 3     alert(Person.prototype.isPrototypeOf(person2));  //true
 4 
 5     function User(){};
 6 
 7     var person3 = new User();
 8 
 9     alert(Person.prototype.isPrototypeOf(person3));  //false
10 
11     alert(User.prototype.isPrototypeOf(person3));  //true

## 对象的\__proto\__隐式原型 ##

上面咱们建立了两个对象,person1和person2,这两个对象，也都指向了Person构造函数的原型,这是由于每一个对象都有一个隐藏的属性——“\__proto\__”，这个属性引用了建立这个对象的函数的prototype。即：person1.\__proto\__ === Person.prototype

这个\__proto\__是一个隐藏的属性，javascript不但愿开发者用到这个属性值，有的低版本浏览器甚至不支持这个属性值。看下面的代码:

    console.log(Object.prototype);

    var obj = new Object();

    console.log(obj.__proto__);

你会发现打印了相同的内容:

obj这个对象本质上是被Object函数建立的，所以obj.\__proto\__=== Object.prototype。咱们能够用一个图来表示。

关于隐式原型，主要涉及到原型继承的主要原理，这里只是抛出这个概念稍做介绍

# javascript面向对象(四) #

## Prototype原型模式 ##

上一章罗列一直知识点，可是主要是为了说明prototype原型，如今主要来看看，经过原型来建立对象的几种方式

### 基本原型 ###

 1  function Person(){ }  
 2 
 3     Person.prototype.name = "Nicholas"; 
 4 
 5     Person.prototype.age = 29; 
 6 
 7     Person.prototype.job = "Software Engineer"; 
 8 
 9     Person.prototype.sayName = function(){     
10 
11         alert(this.name); 
12 
13     };

固然这种方式只是说明原型的道理，实际使用中不多把属性写在原型中

### 更简单的方式 ###

 1 function Person(){ } 
 2     Person.prototype = {     
 3 
 4         name : "Nicholas",     
 5 
 6         age : 29,     
 7 
 8         job: "Software Engineer",     
 9 
10         sayName : function () {         
11 
12             alert(this.name);     
13 
14         } 
15 
16     };

这种方式只是上面方式的简单写法，经过对象字面量直接写完全部属性。效果和上面的写法是同样的，只是写法不同。

可是直接所有把属性和方法所有写在原型中，这并不现实，看下面的列子:

 1 function Person(){ }
 2 
 3   
 4 
 5     Person.prototype = {     
 6 
 7         constructor: Person,     
 8 
 9         name : "Nicholas",     
10 
11         age : 29,     
12 
13         job : "Software Engineer",     
14 
15         friends : ["Shelby", "Court"],     
16 
17         sayName : function () {         
18 
19             alert(this.name);     
20 
21         } 
22 
23     }; 
24 
25  
26 
27     var person1 = new Person(); 
28 
29     var person2 = new Person();  
30 
31     person1.friends.push("Van");  
32 
33     alert(person1.friends);    //"Shelby,Court,Van" 
34 
35     alert(person2.friends);    //"Shelby,Court,Van" 
36 
37     alert(person1.friends === person2.friends);  //true

上面的列子很容易看出，讲属性写在原型中的问题,列子中的friends是个数组，引用数据类型在person1中修改了friends,添加了一个条数据以后，能够看到person1和person2对象的friends都发生了改变，这其实很好理解，由于prototype对象自己就是共享的，数组又是属于引用类型，改变了一个，其余的都会发生改变。

因此，在实际中使用的更多的方法是构造函数与原型结合的方式

### 构造函数与原型结合的方式 ###

 1  function Person(name, age, job){     
 2 
 3         this.name = name;     
 4 
 5         this.age = age;     
 6 
 7         this.job = job;     
 8 
 9         this.friends = ["Shelby", "Court"]; 
10 
11     }  
12 
13     Person.prototype = {     
14 
15         constructor : Person,     
16 
17         sayName : function(){         
18 
19             alert(this.name);     
20 
21         } 
22 
23     } 
24 
25 
26 
27     var person1 = new Person("Nicholas", 29, "Software Engineer"); 
28 
29     var person2 = new Person("Greg", 27, "Doctor");  
30 
31     person1.friends.push("Van"); 
32 
33     alert(person1.friends);    //"Shelby,Count,Van" 
34 
35     alert(person2.friends);    //"Shelby,Count" 
36 
37     alert(person1.friends === person2.friends);    //false 
38 
39     alert(person1.sayName === person2.sayName);    //true

这里就能够看到，friends的属性在两个对象中就算改变了其中一个，并不会对另一个产生影响。这种构造函数加原型的混成模式，是目前使用率，承认率最高的一种自定义类型的方式，因此，通常状况下，咱们定义自定义类型默认都使用这种模式

### 动态原型模式 ###

这种模式只是上面模式的变种，对于一些习惯书写面向对象语言的程序员来讲，一个类要分开两个部分来写，是很是不习惯的，因此，就有了动态原型模式，其实无非就是，把以前分开两部分写的内容，所有提到函数中，加上判断就好了

 1  function Person(name, age, job){  
 2 
 3 
 4 
 5         //属性  
 6 
 7         this.name = name;     
 8 
 9         this.age = age;     
10 
11         this.job = job; 
12 
13  
14 
15         //方法  
16 
17         if (typeof this.sayName != "function"){              
18 
19             Person.prototype.sayName = function(){             
20 
21                 alert(this.name);         
22 
23             };              
24 
25         } 
26 
27     }  
28 
29 
30 
31     var friend = new Person("Nicholas", 29, "Software Engineer"); 
32 
33     friend.sayName();

注意上面的判断，这种方式只有在sayName函数不存在的状况下，才会将它添加到原型中，若是sayName函数已经存在，那么这段代码就不会再运行，并且就算有不少方法的话，if语句也不用所有判断，只是须要判断一个就好了。这样的写法，对于java或者C#程序员相对来讲感官上比较容易接受，并且写法也没有任何缺陷。可是，有一点不算是缺陷的缺点，javascript是一门动态语言，也就是说，属性和方法是随时能够添加的，若是所有写在构造函数里面去，反而看起来不是那么的灵活。因此，通常状况下，使用构造函数与原型的混合模式的仍是比较多的