java中对象的两个基本概念：
1.类：类是对象的模板，比如说Leader 这个是泛称领导，并不特指谁。
2：实例：实例是根据类创建的对象，根据类Leader可以创建出很多实例：liyi,yingjiangyong等。每个实例表示具体的领导，他们
都属于Leader类型。
ES6之前的版本中没有类和实例，是通过原型prototype完成面向对象编程。
区别：JS中没有类和对象，所有的对象都是实例，只是把一个对象的原型指向另一个对象。
//创建对象的第一种方法：.proto
var Unical={
name:'liyi',
age:31,
hello:function(){
alert('Hello, '+this.name+'!');
}
}
var qinbb={
name:'qinbb',
age:24
}
qinbb.proto=Unical;
qinbb.name;//'qinbb'
qinbb.age;//24
qinbb.hello();//Hello, qinbb!
//原型链：qinbb--->Unical.prototype--->Object.prototype--->null
//将qinbb的原型指向Unical，因此可以继承Unical里面的方法（.hello()）,先在qinbb里面找，找不到再去原型里面找。
var leader={
name:'lipei',
age:30,
run:function(){
alert('My leader is '+this.name);
}
}
qinbb.proto=leader;
qinbb.name;//'qinbb'
qinbb.age;//24
qinbb.run();//My leader is qinbb
qinbb.hello();
//原型链：qinbb--->leader.prototype--->Object.prototype--->null
//报错：qinbb.hello()不是一个方法，因为将原型指向了leader，之前的Unical将不再继承
/*创建对象的第二种方法：Objece.create()
最好不要用.ptoto指向原型的对象，低版本的浏览器会不支持（IE浏览器就没有），
ES6版本以下的用Objece.create()来传入原型对象,是创建原型继承的一种方法。
*/
//创建对象的第二种方法Objece.create()
var Leader={
name:'lipei',
age:30,
run:function(){
alert('My leader is '+this.name);
}
}
//可以传多个参数，但是顺序要对应上。
function CreateLeader(name,age){
// 基于leader原型创建一个新对象:
var s = Object.create(Leader);
// 初始化新对象:
s.name = name;
s.age = age;
return s;
}
var qinbb=CreateLeader('qinbb',24);
var qinbb=CreateLeader(24,'qinbb');//若是这样姓名和年龄就对应不上
//qinbb.proto===leader;//true qinbb的原型就是leader 通过构造函数CreateLeader中的Objece.create()创建了qinbb
/
构造函数创建对象
/
//创建对象的第三种方法：构造函数（先定义一个构造函数，一定用关键字new来调用这个函数，并返回一个对象）
function Leader(name){
this.name=name;
this.hello=function(){
alert(this.name+' is a leader !');
}
}
var liyi= new Leader('liyi');
var qinbb = new Leader('qinbb');
liyi.hello===qinbb.hello;//输出：false 虽然调用同一个函数，但是并不相同 这个在方法四中讲解
Object.getPrototypeOf(liyi);//输出 Object {}
liyi.constructor===Leader.prototype.constructor;//true
liyi.proto===Leader.prototype;//true
Leader.prototype.constructor;
/输出如下
function Leader(name){
this.name=name;
this.hello=function(){
alert(this.name+' is a leader !');
}
}/
Leader.prototype.constructor===Leader//输出：true
/liyi的原型链:liyi-->Leader.prototype-->Object.prototype-->null
qinbb的原型链：qinbb-->Leader.prototype-->Object.prototype-->null
/
//创建对象的第四种方法：在方法三种进行优化，不用new来调用函数。
function extendLeader(props){
this.name=props.name || '匿名';
this.grade=props.grade || '普通员工';
}
/run 实际上只需要共享同一个函数就可以了，这样可以节省很多内存，
只要把run函数移动到liyi、qinbb这些对象共同的原型上/
extendLeader.prototype.run=function(){
alert(this.name+' 的级别是： '+this.grade);
}
function CreateLeader(props){
return new extendLeader(props);
}
var liyi=CreateLeader({name:'liyi',grade:'经理'});
var qinbb=CreateLeader({name:'qinbb'});
liyi.run===qinbb.run;//输出true
/
*原型继承，java 里面就是extends就可以继承class类，JS中要继承，ES6版本以前的比较复杂。
*需要构造中间函数，并且将中间函数的原型指向需要继承的对象，再将继承的对象的原型指向中间函数。
*/
//构造函数创建对象
function Leader(props){
this.name=props.name;
this.grade=props.grade || '普通员工';
}
function extendLeader(props){
Leader.call(this,props);
this.skill=props.skill || '暂无';
//return new extendLeader(props); 新建对象的时候 不用new
}
function F(){}//构造中间函数
F.prototype=Leader.prototype;//将中间函数F的原型指向Leader的原型
//再将extendLeader的原型指向中间函数F的原型，也就是Leader的原型，此时extendLeader的构造函数是Leader
extendLeader.prototype=new F();
//将extendLeader的构造函数修复为extendLeader，这样的话extendLeader原型是Leader的原型，构造函数是自己本身
extendLeader.prototype.constructor=extendLeader;
var liyi=new extendLeader({name:'liyi',skill:'互联网技术都精通'});
liyi.name;//输出‘liyi’
liyi.grade;//输出：‘普通员工’
liyi.skill;//输出：‘互联网技术都精通’
