js 高级指导

[size=x-large]创建对象的方法
一：临时对象创建
var object = new Object();
object.name = "zhangsan";
object.age = "123";
var object1 = object;
var object2 = object;
alert(object1.name);
缺点：一次只能创建一个对象，每次创建对象都要对属性赋值一次。
二：工厂方法创建
function createObject()
{
var object = new Object();
object.name = "zhangsan";
object.age = "123";
object.info = function()
{
alert(object.name+":"+object.age);
}
return object;
}
var object1=createObject();
var object2=createObject();
object1.info();
object2.info();
缺点：可以不停地创建对象，但是这样每次创建对象的时候属性和方法都创建一次，而我们希望属性不同，而方法共享。
三：构造函数创建
Function xxx(name,age)
{
This.name=name;
This.age=age;
This.info=function()
{
alert(object.name+":"+object.age);
}
}
Var object1=new xxx(“zhangsan”,23);
缺点:同三
四：原型（prototype）创建
Function xxx()
{

}
xxx.prototype.name=”zhangsan”;
xxx.prototype.age=”23”;
如果使用了原型方式对象，那么生成的所有对象会共享原型中的属性，这样一个对象改变了该属性也会反应到其他对象当中。Propotype是一个原型对象，就相当于父类对象。所以
xxx.protype.info=function(){…}相当于父类的一个方法，子类xxx都继承这个方法，所以子类xxx在创建对象的时候不会重复创建这个方法，但都可以共享(继承)这个方法;
缺点：单纯使用原型方式定义对象无法在构造函数中为属性赋初值，只能在对象生成后改变属性值，而且多个对象共享属性值是不能容忍的。
五：原型+构造函数创建
Function xxx(name,age)
{
This.name=name;
This.age=age;
}

xxx.prototype.info=function()
{
alert(object.name+":"+object.age);
}
Var object1=new xxx(“zhangsan”,23);
能够实现属性根据不同的对象不同，且能共享同样的方法。这种方式可用。
六：动态原型+构造函数创建
function xxx(name,age)
{
this.name=name;
this.age=age;
if(!this.info)
{
alert("xxxx");//只输出一次，说明虽然创建多个对象，但是函数只创建一次。
xxx.prototype.info = function()
{
alert(this.name+":"+this.age);
}
}
}
var object1=new xxx("zhangsan",23);
var object2=new xxx("lisi",24);
object1.info();//输出"zhangsan",23
object2.info();//输出"lisi",24
9对象继承
一：对象冒充法
function Person(name)
{
this.name=name;
this.info=function()
{
alert(this.name);
}
}

function Child(name,age)
{
this.method = Person;
/*相当于把this.method指向Person的引用，等价于
this.method= function Person(name)
{
this.name=name;
this.info=function()
{
alert(this.name);
}
}*/

this.method(name);
delete this.method;
this.age=age;
this.sayAge = function()
{
alert(this.age);
}
}
var a = new Person("zhangsan");
var b = new Child("zhangsan",23);
a.info();//输出zhangsan
b.info();//输出zhangsan
b.sayAge();//输出23
二：call（）继承法
function Person(name)
{
this.name=name;
this.info=function()
{
alert(this.name);
}
}

function Child(name,age)
{
Person.call(this,name);//第一个参数是传给Person的this对象，第二个参数传给Person的参数。这里是将Child对象传递给Person的this对象
this.age=age;
this.sayAge = function()
{
alert(this.age);
}
}
var a = new Person("zhangsan");
var b = new Child("zhangsan",23);
a.info();
b.info();
b.sayAge();
三：apply（）继承法
function Person(name)
{
this.name=name;
this.info=function()
{
alert(this.name);
}
}

function Child(name,age)
{
Person.apply(this,new Array(name));//和cell区别不大，只是第2个参数传递的是一个参数数组。
this.age=age;
this.sayAge = function()
{
alert(this.age);
}
}
var a = new Person("zhangsan");
var b = new Child("zhangsan",23);
a.info();
b.info();
b.sayAge();
四：prototype继承
function Person()
{
}
Person.prototype.name="zhangsan";
Person.prototype.info=function()
{
alert(this.name);
}
function Child()
{
}
Child.prototype = new Person();//将Child类的父类对象赋值为Person对象，即相当于继承父类。
var a = new Person();
var b = new Child();
a.info();
b.info();
五：混合继承（推荐）
function Person(name)
{
this.name=name;
}
Person.prototype.info=function()
{
alert(this.name);
}
function Child(name,age)
{
Person.call(this,name);//通过cell来继承属性
this.age=age;
}

Child.prototype = new Person();//通过原型对象来继承方法，这里因为只继承方法，所以Person()不需要传参数
Child.prototype.sayAge = function()
{
alert(this.age)
}
var a = new Person("zhangsan");
var b = new Child("lisi",23);
a.info();
b.info();
b.sayAge();[/size]