javascript面向对象与原型

//一.工厂模式
  function createBox(user,age){
      var obj=new Object();
      obj.user=user;
      obj.age=age;
      obj.run=function(){
          return this.user+this.age+"原型在哪里！";
      };
      return obj;
  }
  var obj1=createBox("mly",20);
  alert(obj1.run());
  var obj2=createBox("zs",21);
  alert(obj2.run());
  alert(obj1 instanceof Object);//true
  alert(obj2 instanceof Object);//true
  //工厂模式缺点:不能解决对象识别问题，因为根本无法搞清楚他们到底是哪个对象的实例。

 //二.构造函数模式
  function Box(user,age){
    this.user=user;
    this.age=age;
    this.run=function(){
        return this.user+this.age+"原型在哪里！";
    };
  }
  var box1=new Box("mly",12);
  alert(box1.run());
  var box2=new Box("mly",12);
  alert(box1.run() == box2.run()); //true，方法的值相等，因为传参一致
  alert(box1.run == box2.run); //false，方法其实也是一种引用地址
  //缺点：他们引用地址不同

 1  //三.原型模式
  //在原型模式声明中，多了两个属性，这两个属性都是创建对象时自动生成的。__proto__
  //属性是实例指向原型对象的一个指针，它的作用就是指向构造函数的原型属性constructor
  //通过这两个属性，就可以访问到原型里的属性和方法了。

 5   //模式1
  function Box(){
      this.age=10;
  }
  Box.prototype.user="mly";
  Box.prototype.age=12;
  Box.prototype.family=["哥哥","弟弟","妹妹"];
  Box.prototype.run=function(){
    return this.user+this.age+"原型在哪里！";
  };
  var box1=new Box();
  alert(box1.run());
  alert(Box.prototype.isPrototypeOf(box1));//true 证明每个实例化后对象都有原型
  alert(box1.hasOwnProperty("user"));//false 判断user属性是否在实例对象中，false表示不再
  alert("user" in box1)//true 只要存在实例或者原型中就返回true
  //如何判断只在原型中呢？
  function IsPrototype(box,para){
    return (!box.hasOwnProperty(para))&&(para in box);
  }
  alert(IsPrototype(box1,"user"));//只在原型中
  alert(box1.age);//12 证明如果实例中有，会覆盖原型
  alert(box1.family);//打印出：哥哥,弟弟,妹妹
  box1.family.push("姐姐");
  alert(box1.family);//打印出：哥哥,弟弟,妹妹,姐姐
  var box2=new Box();
  alert(box2.family);//打印出：哥哥,弟弟,妹妹,姐姐
  //给String自定义一个方法psString
  String.prototype.psString=function(){
    return this+"刚刚加的方法！";
  };
  alert("mly".psString());//打印出   mly刚刚加的方法！
  //缺点：数据共享的缘故，当然这也是原型的优点
  //模式2:字面量方式
  function Desk(){}
  Desk.prototype={     //重写原型
      constructor:Desk,//直接强制指向Desk实例
      user:"mly",
      age:12,
      run:function(){
        return this.user+this.age+"原型在哪里！";
      }
  };
  var desk1=new Desk();
  alert(desk1.age);
  //如果重写原型
  Desk.prototype={
    age:1212
  }
  var desk2=new Desk();
  alert(desk1.run());//不报错，证明该对象已到内存中
  alert(desk2.run());//报错  找不到run()方法，证明该原型切断了与之前的链接被重写了

 //四.构造函数+原型模式
 function Box(user,age){
    this.user=user;
    this.age=age;
 }
 Box.prototype={
    constructor:Box,
    run:function(){
        return this.user+this.age+"原型在这里！";
    }
 };
 var box1 =new Box("mly",123);
 alert(box1.run());//mly123原型在这里！
 //这种混合模式很好的解决了传参和引用共享的大难题。是创建对象比较好的方法。但是你不觉得有点奇怪吗？为什么不写到一起呢？

 //五.动态原型模式
  function Box(user,age){
    this.user=user;
    this.age=age;
    if(typeof this.run!="function"){//原型是共享的实例化调用一次就好了，以后实例化不用调用
        Box.prototype.run=function(){
            return this.user+this.age+"动态原型模式!";
        };
    }
  }
  var box1=new Box("mly",123);
  alert(box1.run());//mly123动态原型模式!
  var box2=new Box("zs",444);
  alert(box2.run());//zs444动态原型模式!
  //使用动态原型模式，要注意一点，不可以再使用字面量的方式重写原型，因为会切断实例和新原型之间的联系。

以上就是有关原型的几种模式了，各位可以根据自己的实际情况选相应的模式。