javascript面向对象

对象的创建以及常用操作

下面的都是创建对象比较简单直观，也是JavaScript种创建对象最基本的方法，如果要创建多个对象，就会出现很多相同的代码。

1：使用new运算符（不推荐）

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

　　　    　user.name = "Jack";  　　　　 //给对象添加属性

　　　　    user.age = 25;

　　　　    user.address = "四川成都";

　 2:对象字面量(JSON方式)

   　　         var user = {
                 　　     name:‘Jack‘,
           　　　　    age:25,
         　　　　      address:‘四川成都‘    
       　　　 };  

        3：简单方式(传统赋值方式)

  var user = {};

　　 　　　user.name = ‘Jack‘;        //给对象添加属性

　　　　    user.age = 25;
                  user.address = ‘四川成都‘;

　  4：属性的调用（对于对象属性的调用有两种方式）

（1）：alert(user.name + " " +user.age);

　　　   （2）：alert(user[‘name‘] + " " +user[‘age‘]);

　   　5：添加方法

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

　　工厂模式

　例： function create(name, age) {
    　　　　　　　　var obj = new Object(); 
    　　　　　　　　obj.name = name; 
    　　　　　　　　obj.age = age;
    　　　　　　　　obj.show = function () {
    　　　　　　　　　　return this.name +‘ ‘+ this.age;
    　　　　　　};
    　　　　　　　　　　return obj;
  　　　　  }
  　　　　  var obj1= create(‘jack‘, 30);    //第一个实例
  　　　　  var obj2= create(‘Tom‘, 20);    //第二个实例
  　　　　  alert(obj1.show());
  　　　　  alert(obj2.show());  　　

优点：解决了实例化时代码大量重复的问题

　　　　  缺点：识别问题，它们根本无法弄清楚他们到底是哪个对象的实例

　　　比如：

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

　　构造函数(构造方法)

　例： function User(name, age) {    //构造函数模式
    　 　　　　　　　this.name = name;
    　　　　　　　　this.age = age;
    　　　　　　　　this.show = function () {
    　　　　　　　　　　　return this.name  + ‘ ‘+this.age;
    　　　　　　};
  　　　　  }  

　　　  　 var user1 = new User(‘jack‘, 30);    //第一个实例
  　　　　  var user2 = new User(‘Tom‘, 20);    //第二个实例

优点：解决了重复实例化的问题，又解决了对象识别的问题

　　　　　 缺点：每个方法都要在实例上重新创建一次

Prototype原型模式

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

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

　例：

 　　　　　　    function Cat(name,color){
    　　　　　　 　　   this.name = name;
       　　　　　　　　 this.color = color;
  　　　　　　　　  }

那么现在再为这个函数添加一个不变的属性"type"（种类），再添加一个方法eat（吃老鼠）。那么，Cat就变成了下面这样:

　　   例：

　　　　 function Cat(name,color){
      　　　　  this.name = name;
      　　 　　 this.color = color;
       　　　　 this.type = "猫科动物";
       　　　　 this.eat = function(){alert("吃老鼠");};
  　　　　  }

　　　　　 var cat1 = new Cat("大毛","黄色");
    　　　　var cat2 = new Cat ("二毛","黑色");
  　　 　　 alert(cat1.type);　　　　　　　　　　 // 猫科动物
  　　　　  cat1.eat(); 　　　　　　　　　　　　// 吃老鼠  

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

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

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

原型：(prototype和constructor是原型最基本的概念)

原型对象实际上就是构造函数的一个实例对象，和普通的实例对象没有本质上的区别。可以包含特定类型的所有实例的共享属性或者方法。 这个prototype的属性值是一个对象（属性的集合），默认的只有一个叫做constructor的属性，指向这个函数本

比如我们简单定义一个SuperType名字的函数，里面什么属性也没有在函数内部也没有

例：

 function SuperType(){
   　　　　 }

从下图我们看到，函数里面虽然什么都没有，但是有一个默认的prototype属性,它是一个对象，它指向的是自己的地址，而prototype这个对象本身里面又有一个属性constructor，而这个属性，又指向了函数本身,有点绕

　　你可以通过下面的代码做一下测试，看看效果

　例:

 alert(SuperType.prototype) 　　　　　　　　//object
               alert(SuperType.prototype.constructor) 　　//弹出函数本身function SuperType(){} 

原文：http://www.cnblogs.com/zouxueling/p/4104379.html