javascript学习四

让一个函数对象被多个对象所共享，而不是每一个对象拥有一个函数对象。

<script type="text/javascript">
	function get(){
		alert(this.username+" , "+this.password);
	}
	function createObject(username,password){
		var obj=new Object();
		obj.username=username;
		obj.password=password;
		obj.get=get;
		
		return obj;
	}
	
	var obj1=createObject("hello","123");
	obj1.get();
	var obj2=createObject("word","456");
	obj2.get();
</script>

 构造函数方式：

不带参数的

<script type="text/javascript">
	function person(){
		//在执行第一行代码之前，js引擎会生成一个对象
		this.username="hello";
		this.password="123";
		this.getInfo=function(){
			alert(this.username+" , "+this.password);
		}
		//此处有一个隐藏的return语句，用于将之前的对象返回
	}
	
	var per=new person();
	per.getInfo();
</script>

 带参数的

<script type="text/javascript">
	function person(username,password){
		this.username=username;
		this.password=password;
		this.getInfo=function(){
			alert(this.username+" , "+this.password);
		}
	}
	
	var per=new person("hello","123");
	per.getInfo();
</script>

 原型（“prototype”）方式:

<script type="text/javascript">
	//使用原型 （prototype）定义对象
	function person(){}
	person.prototype.username="hello";
	person.prototype.password="123";
	person.prototype.getInfo=function(){
		alert(this.username+" , "+this.password);
	}
	
	var per=new person();
	per.getInfo();
	per.username="word";
	per.getInfo();
</script>

 单纯使用原型方式定义类无法在构造函数中为属性赋初值，只能在对象生成后再去改变属性值。

<script type="text/javascript">
	//使用原型 （prototype）定义对象
	function person(){}
	person.prototype.username=new Array();
	person.prototype.password="123";
	person.prototype.getInfo=function(){
		alert(this.username+" , "+this.password);
	}
	
	var per=new person();
	per.username.push("hello");
	per.username.push("word");
	per.password="456";
	per.getInfo();
	
	var per2=new person();
	per2.getInfo();
</script>

 如果使用原型方式对象，那么生成的所有对象共享原型中的属性，这样一个对象改变了该属性，也会反映到其他对象当中。

使用原型和构造函数的方式定义对象，对象之间的属性互不干扰，各个对象间共享一个方法。

<script type="text/javascript">
	//使用原型和构造方法创建对象
	function person(){
		this.username=new Array();
		this.password="123";
	}
	person.prototype.getInfo=function(){
		alert(this.username+" , "+this.password);
	}
	
	var p=new person();
	var p2=new person();
	p.username.push("hello");
	p2.username.push("word");
	p.getInfo();
	p2.getInfo();
</script>

 动态原型方式：在构造函数中通过标志量让所有对象共用一个方法，而每个对象都有自己的属性。（这样的话就和java所产生的对象就是一样的了。）

<script type="text/javascript">
	function person(){
		this.username="hello";
		this.password="123";
		if(typeof person.flag=="undefined"){
			alert("invoke");
			person.prototype.getInfo=function(){
				alert(this.username+" , "+this.password);
			}
			person.flag=true;
		}
	}
	var p=new person();
	var p2=new person();
	
	p.getInfo();
	p2.getInfo();
</script>

 javascript中的继承：

对象冒充

<script type="text/javascript">
	//继承方式：第一种 对象冒充
	function parent(username){
		this.username=username;
		this.sayHello=function(){
			alert(username);
		}
	}
	function child(username,password){
		//最关键的三行代码
		this.method=parent;
		this.method(username);
		delete this.method;
		
		this.password=password;
		this.sayWord=function(){
			alert(password);
		}
	}
	
	var p=new parent("hello");
	var c=new child("word","123");
	p.sayHello();
	c.sayHello();
	c.sayWord();
</script>

 call方法方式：

call方法是Function对象中的方法，因此我们定义的每一个函数都拥有该方法。可以通过函数名来调用call方法，call方法的第一个参数传递给函数中的this，从第二个参数开始，逐一赋值给函数中的参数。

<script type="text/javascript">
	//继承的第二种实现方式：call方法方式,Function对象中的方法。
	function test(str,str1){
		alert(this.name+" , "+str+" , "+str1);
	}
	var obj=new Object();
	obj.name="hello";
	//test.call相当于调用了test()方法
	test.call(obj, "word","!");//将obj赋给了this
</script>