首页 > 代码库 > javascript面向对象
javascript面向对象
# javascript面向对象（一）
对象其实就是一种引用类型。而对象的值就是引用类型的实例。在JavaScript 中引用类型是一种数据结构，将数据和功能组织在一起。它也常被称做为类，但JavaScript 中却没有类的概念。虽然JavaScript 是一门面向对象的语言，却不具备传统面向对象语言所支持的类和接口等基本结构。
## 对象的创建以及常用操作 ##
1. **使用new运算符**
var user = new Object(); //使用new运算符创建一个对象 user.name = ‘tina; //给对象添加属性 user.age = 22; user.address = ‘四川成都‘;
2. **对象字面量(JSON方式)**
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。
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(){ //创建共享函数sayName10 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)); //false10 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是一门动态语言，也就是说，属性和方法是随时可以添加的，如果全部写在构造函数里面去，反而看起来不是那么的灵活。所以，一般情况下，使用构造函数与原型的混合模式的还是比较多的
javascript面向对象