面向对象与原型-ps：这一章简直是天书

/*面向对象原型
var box=new Object();
box.name1='lee';
box.age='100';
box.run=function(){


return this.age+this.name1+'运行中';//this表示当前作用域下的对象，也就是new Object（）实例化出来的那个对象，this要放在一个作用域下，比如box。run（）{}，这个box的作用域下的方法，方可用this来表示box
};
alert(box.run());


var name1='kkk';
alert(this.name1);//这里的this代表的是window会打印出kkk








var box=new Object();
box.name1='lee';
box.age='100';
box.run=function(){


return this.age+this.name1+'运行中';
};
alert(box.run());


var name1='kkk';
alert(this.name1);


//工厂模式
function createObject(name,age){
var obj=new Object();//创建对象
obj.name=name;//添加属性
obj.age=age;
obj.run=function(){//添加方法
return 'zhuzi'+this.name+this.age;
};
return obj;//返回对象
}
var box1=createObject('hehe',100);//创建第一个box1对象
var box2=createObject('nima',200);//创建第二个box2对象
var box3=createObject3('222',900);
//alert(box1.run());//打印第一个对象的run方法
//alert(box2.run());


function createObject2(name,age){
var obj=new Object();//创建对象
obj.name=name;//添加属性
obj.age=age;
obj.run=function(){//添加方法
return 'zhuzi'+this.name+this.age;
};
return obj;//返回对象
}


//不管怎么样就是不能区分实例化的对象到底是谁的因为它们都是Object类型
//构造函数：它解决了重复实例化，以及不能区分实例化的对象到底是谁的
function Box(name,age){//创建一个对象,所有构造函数的对象其实就是Object；
this.name=name;//添加属性
this.age=age;
this.run=function(){//添加方法
return this.name+this.age+'运行中';
};
}
/*
1.构造函数根本就没有new object（），但是它后台会自动调用var obj=new Object（）
2.this就相当于obj
3.构造函数不需要返回引用，它是后台自动返回的


规范
1.构造函数也是函数，但函数名的第一个字要大写
2.必须new构造函数名，new Box（）而这个box的第一个字母要大写
3.必须使用new 运算符。


var box1=new Box('xiao',100);//实例化一个对象
var box2=new Box('zhu',299);//再实例化一个对象
alert(box1.run());//调用对象的run方法并把它打印出来
alert(box2.run());
alert(box1 instanceof Object);//查看它的类型是否是Object






function Box(name,age){//创建一个对象,所有构造函数的对象其实就是Object；
this.name=name;//添加属性
this.age=age;
this.run=function(){//添加方法
return this.name+this.age+'运行中';
};
}
var box1=new Object();
Box.call(box1,'lee',100);//对象冒充，只有这样box1对象才具有了Box构造函数里面的属性和方法
alert(box1.run());




function Box(name,age){//创建一个对象,所有构造函数的对象其实就是Object；
this.name=name;//添加属性
this.age=age;
this.run=function(){//添加方法
return this.name+this.age+'运行中';//它是引用类型
};
}
var box1=new Box('lee',100);//实例化后地址为一


var box2=new Box('lee',100);//实例化后地址为二
alert(box1.age==box2.age);
alert(box1.name==box2.name);
alert(box1.run()==box2.run());//构造函数内的方法的值是相当的
alert(box1.run==box2.run);//他们比较的是引用地址，是不相等的




function Box(name,age){//创建一个对象,所有构造函数的对象其实就是Object；
this.name=name;//添加属性
this.age=age;
this.run=run;


}
function run(){//把构造函数的方法通过全局来实现引用一致
return this.name+this.age+'运行中';
}
var box1=new Box('lee',100);//实例化后地址为一


var box2=new Box('lee',100);//实例化后地址为二


alert(box1.age==box2.age);
alert(box1.name==box2.name);
alert(box1.run()==box2.run());//构造函数内的方法的值是相当的
alert(box1.run==box2.run);//他们比较的是引用地址是相等的




//注意这种方法是不可取的，容易被外部程序调用，我们应该把它的方法尽可能的封装起来
function Box(name,age){//创建一个对象,所有构造函数的对象其实就是Object；
this.name=name;//添加属性
this.age=age;
this.run=run;


}
function run(){//把构造函数的方法通过全局来实现引用一致
return this.name+this.age+'运行中';
}
var box1=new Box('lee',100);//实例化后地址为一


var box2=new Box('lee',100);//实例化后地址为二


alert(box1.age==box2.age);
alert(box1.name==box2.name);
alert(box1.run()==box2.run());//构造函数内的方法的值是相当的
alert(box1.run==box2.run);//他们比较的是引用地址是相等的




//构造函数
function Box(name,age){//创建一个对象,所有构造函数的对象其实就是Object；
this.name=name;//实例属性
this.age=age;
this.run=function(){//实例方法
return this.age+this.name+'运行中';
};
}


function Box(){}//如果构造函数里面有叫做实例属性实例方法，如果没有就叫做原型属性和原型方法
Box.prototype.name='lee';//原型属性
Box.prototype.age=200;
Box.prototype.run=function(){//原型方法
return this.name+this.age+'运行中';
};
var box1=new Box();
var box2=new Box();
alert(box1.run());


//如果是实例方法，不同的实例化，他们的方法地址是不一样的，是唯一的
//如果是原型方法，那么他们的地址是共享的，大家都是一样
alert(box1.run==box2.run);


alert(box1.prototype);//这是个对象是不能直接访问的。
alert(box1._proto_);//这个属性是一个指针它是指向原型对象的




aelrt(box1.constructor);//构造属性，可以获取构造属性本身；作用是被原型指针定位，然后得到构造函数本身，其实就是对象实例对应对象原型的作用






//判读一个对象是否指向了原型对象，基本上一旦实例化就自动指向了
alert(Box.prototype.isPrototypeOf(box1));
var box3=new Object();
alert(Object.prototype.isProto


box1.name='hehe';//实例属性
alert(box1.name);//它会打印出’hehe‘这个叫做就近原则






alert(box1.name);//它会打印出’hehe‘这个叫做就近原则
//ps:原型的执行流程是先查找构造函数的实例属性，如果没有找到，就查找原型对象里面原型属性


var box2=new Box();
alert(box2.name);//实例属性不会共享，所以box2访问不到实例属性，就只能访问原型属性。
delete box1.name;//删除box1中的实例属性。
alert(box1.name);//打印出box1的原型属性。
delete Box.prototype.name;//删除原型属性
Box.prototype.name='kkk';//覆盖原型中的属


box1.name='hehe';
alert(box1.hasOwnProperty('name'));//判断实例中是否存在指定属性


//alert('name'in box1);//不论是在原型中还是实例中只要有就会打印出true






//判断只要原型中有的属性
function isProperty(object,property){
return !object.hasOwnProperty(property)&&(property in object);
}


alert(box1.prototype);//使用对象实例无法访问到prototype属性
alert(box1._proto_);//使用对象实例来访问prototype的指针
alert(Box.prototype);//使用函数名（对象名）来访问prototype




function Box(){}
//使用字面量的方式来创建原型对象，这里的{}就相当于new Object（）；也就是相当于一个对象
Box.prototype={
name:'hehe',
age:100,
run:function(){
return this.name+this.age+'iiiiii';
}
};
var box1=new Box();
alert(box1.run());




function Box(){}
//使用字面量的方式来创建原型对象，这里的{}就相当于new Object（）；也就是相当于一个对象
Box.prototype={
//constructor：Box，//constructor：Box强制指向实例
name:'hehe',
age:100,
run:function(){
return this.name+this.age+'iiiiii';
}
};
var box1=new Box();
alert(box1.run());
//ps：在这里会出现一个问题就是它的constructor的属性不会指向实例，而指向的是object，而构造函数的方式则相反，如果一定要它
//指向实例的话只有通过constructor：Box强制指向实例






function Box(){}
//使用字面量的方式来创建原型对象，这里的{}就相当于new Object（）；也就是相当于一个对象
Box.prototype={
//constructor：Box，//constructor：Box强制指向实例
name:'hehe',
age:100,
run:function(){
return this.name+this.age+'iiiiii';
}
};
//重写原型对象，会导致以前的原型对象的实例和方法消失
Box.prototype={
age:200//这里不会保留之前的原型的任何信息了，把原来的原型对象和构造函数对象实例之前的关系切断了
};


var box1=new Box();
alert(box1.age);




//数组排序
var box=[1,12,23,4,45,6,6,7];
alert(box.sort());
alert(Array.prototype.sort);//查看内置的方法
//内置引用的功能扩展,但是不推荐，可能产生重命名的情况，使得代码维护更加困难
String.prototype.addString=function(){
return this+'ni shi bitch';
}
var str='lele';
alert(str.addString());
*/
//普通函数function box(){}普通函数，构造函数必须使用new运算符调用，普通模式无效
//原型的缺点
/*function Box(){}
Box.prototype={
constructor:Box,
name:'ping',
age:200,
family:['geg','jj','mm'],
run:function(){
return this.name+this.age+'yunxingzhong'
}
};
var box1=new Box();
alert(box1.family);
box1.family.push('didi');//在第一个实例类型修改后引用类型保持了共享
alert(box1.family);


var box2=new Box();
alert(box2.family);//共享了box1添加引用类型的原型




构造函数+原型模式
function Box(name,age){//保持独立的用构造函数
this.name=name;
this.age=age;
this.family=['geg','jj','mm'];
}
Box.prototype={//保持共享的用原型
constructor:Box,
run:function(){
return this.name+this.age+'yunxingzhong'
}
};
var box1=new Box('lele',100);
box1.family.push('dd');
var box2=new Box('jack',100);
alert(box1.run());
alert(box2.run());
alert(box1.family);
alert(box2.family);//引用类型没有使用原型，所以没有共享
*/
//动态原型模式:可以将原型封装到里面
/*function Box(name,age){//保持独立的用构造函数
this.name=name;
this.age=age;
this.family=['geg','jj','mm'];
if(typeof this.run !='function'){//判断this。run是否存在
Box.prototype.run=function(){
return this.name+this.age+'yunxingzhong'
};
}
}
//原型初始化只需要一次就行了，没必要每次构造函数实例化的时候都要初始化


var box1=new Box('lele',100);
box1.family.push('dd');
var box2=new Box('jack',100);
alert(box1.run());
alert(box2.run());
alert(box1.family);
alert(box2.family);//引用类型没有使用原型，所以没有共享*/
//寄生构造函数=工厂模式+构造函数模式
/*function Box(name,age){
var obj=new Object();
obj.name='lele';
obj.age=2000;
obj.run=function(){
return this.name+this.age+'yunxiangzhong'
};
return obj;


}


var box1=new Box('lele',100);
var box2=new Box('jack',100);
alert(box1.run());
alert(box2.run());*/
//还有一种安全模式就是在构造函数内部不能用this，在实例化的时候不能用new运算符


//继承，通过原型链条来实现
/*function Box(){//被继承的函数称为超类型（父类，基类）
this.name='hehe';
}
function Desk(){//继承的函数叫子类型（子类，派生类）
this.age=100;
}
function Table(){
this.level='aa';
}
//通过原型链继承，超类型实例化后的对象实例赋值给子类型的原型属性
//new Box()会将Box构造函数里的信息和原型里的信息全部交给Desk
//Desk的原型得到的是Box的构造+原型里的信息
var box=new Box();
var desk=new Desk();


Desk.prototype=new Box();
Table.prototype=new Desk();
var table=new Table();


alert(table.age);


*/
/*function Box(){//被继承的函数称为超类型（父类，基类）
this.name='hehe';
}
Box.prototype.name='heww';
function Desk(){//继承的函数叫子类型（子类，派生类）
this.age=100;
}
Desk.prototype=new Box();//通过原型链来继承
var desk=new Desk();
alert(desk.name);//就近原则，实例里就是实例里面的，如果没有就找原型里面的
//子类型从属于自己或者它的超类型
alert(desk instanceof Object);
alert(desk instanceof Desk);
alert(desk instanceof Box);
*/
//使用对象冒充继承
/*function Box(name,age){
this.name=name;
this.age=age;
this.family=['gege','jiejie','meiemi'];//引用类型放到构造函数里面就不会共享
}
Box.prototype.family='jjj';
function Desk(name,age){
Box.call(this,name,age);//对象冒充
}
var desk=new Desk('2b',100);
alert(desk.name);
alert(desk.family);//undefined,可以看出对象冒充是不能从原型里面继承过来的，只能继承构造里的信息
desk.family.push('ddi');//添加一个didid进入数组
alert(desk.family);
*/
//组合继承=对象冒充+原型链
/*function Box(name,age){
this.name=name;
this.age=age;
this.family=['gege','jiejie','meiemi'];


}
Box.prototype.run=function(){
return this.age+this.name+'sb';
};
//构造函数里面的方法，放在构造函数，每次实例化都会分配一个内存地址，造成浪费，所以方法最好放在原型里，保证每次都是一个地址
function Desk(name,age){
Box.call(this,name,age);//对象冒充，来继承构造函数里面的解决了传参，而它却不能继承原型（第二次调用Box）
}


Desk.prototype=new Box();//通过原型链来继承原型里面的（第一次调用Box）
var desk1=new Desk('2b',100);
alert(desk1.run());
var desk=new Desk('2b',100);
*/
/*//原型式继承
//临时中转函数
function obj(o){//o表示将要传递进入一个对象
function F(){}//F构造函数是一个临时新建的对象，用来存储传递过来的对象
F.prototype=o;//将o对象赋值给F构造的原型对象
return new F();//返回这个得到传递过来对象的对象实例
}
//F。prototype=o就相当于Desk。prototype=new Box（）；
//这是字面的声明方式，相当于var box=new Box（）；
var box={
name:'ll',
age:100,
family:['gege','jiejie','meiemi']
};


var box1=obj(box);
alert(box1.name);
alert(box1.family);
box1.family.push('didi');
alert(box1.family);
var box2=obj(box);
alert(box2.family);//引用类型的属性共享


*/
/*//寄生式继承=原型式+工厂模式
function obj(o){//o表示将要传递进入一个对象
function F(){}//F构造函数是一个临时新建的对象，用来存储传递过来的对象
F.prototype=o;//将o对象赋值给F构造的原型对象
return new F();//返回这个得到传递过来对象的对象实例
}
//寄生函数
function create(o){
var f=obj(o);
f.run=function(){
return this.name+this.age+'运行中'
};
return f;
}
var box={
name:'ll',
age:100,
family:['gege','jiejie','meiemi']
};


var box1=create(box);
alert(box1.name);
alert(box1.run());*/
//寄生组合继承:解决了Box构造函数的多次调用
/*function obj(o){//o表示将要传递进入一个对象
function F(){}//F构造函数是一个临时新建的对象，用来存储传递过来的对象
F.prototype=o;//将o对象赋值给F构造的原型对象
return new F();//返回这个得到传递过来对象的对象实例
}
//寄生函数
function create(box,desk){
var f=obj(box.prototype);
f.constructor=desk;//调整原型构造指针使它重新指向desk
desk.prototype=f;
}


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


Box.call(this,name,age);//对象冒充
}
//通过寄生组合继承来实现继承
create(Box,Desk);//这句话就相当于替代Desk。prototype=new Box（）
var desk=new Desk('lee',100);
alert(desk.run());
alert(desk.constructor);*/