原型字面量写发(字面量是将代码封装感觉)
function Box(){}

Box.prototype={
  constructor:Box,  //强制指向Box
  name:'lee';
  age:100,
  run:function(){
    return this.name+this.age+'运行中...';
  }
}


Box.prototype={   //重写原型之前的属性就没有了
   age:100,
}


var box = new Box();
alert(box.constructor);  


JS中许多内置方法都使用了原型对象。
JS内置方法是否使用了原型使用
alert(Array.prototype.sort);

扩展JS内置方法
1，首先判断方法名字是否有重复
2，代码

String.prototype.addstring=function(){
  return this+',被添加!';
}

var box ='lee';
alert(box.addstring());



原型需要共享的地方才共享，需要独立的地方才独立
(数组，函数，对象默认是引用赋值)
例如：
function Box(){}    //实例

Box.prototype={     //原型
   constructor:Box,
   name:'lee',
   age:100,
   family:['哥哥','姐姐','妹妹'],
   run:function(){
     return this.name+this.age+'运行中';
   }
}


var box1 =new Box();
box1.family.push('弟弟');  //这里在数组添加了'妹妹'

var box2 =new Box();
alert(box2.family);  //弹出的数组有弟弟，这里实现了共享


为了保证该独立的地方需要独立，该共享的地方共享，只需要将
数组，函数，对象存放在实例代码中，即可。




继承

function Box(){     //爷爷
   this.name='lee';
}


function Desk(){   //儿子
   this.age=100;
}


function Table(){   //孙子
   this.le='aaaa';
}

继承方法
Desk.prototype=new Box();    //儿子用原型继承了爷爷
Table.prototype=new Desk();  //孙子又继承了儿子

现在孙子的原型继承了儿子，爷爷构造函数和原型。





对象冒充
function Box(age){  
   this.name=['lee',100];
   this.age=age;
}

Box.prototype.run=function(){
   return this.name+this.age+'运行中';
}

function Desk(age){  //Desk构造函数冒充Box构造函数,对象冒充可以传参数
   Box.call(this,age)
}


在对象冒充中冒充构造函数只能使用构造函数的代码，而不能使用原型代码
这里需要冒充原型代码

Desk.prototype=new Box();  //这里就可以使用Box.prototype.run里面的代码了实现了共享原型代码