ex1.
	var abc = 'sss';
	alert(abc);//"sss"
	alert(this.abc);//"sss"
	function fun1(){
		alert(this.abc);
	}
	fun1();//"sss"
	this.alert(123);
	alert(this.parseInt('234s4'));

ex2.
	var O1 = function(){
		function O(){
			this.abc = 123;
			function f2(){
				alert(this.abc);
			}
			f2();//直接调用f2方法，this指代window
			f2.call(this);//通过call调用f2方法，this指代O1
		}
		function pf(){
			alert(this.abc);
		}
		O.prototype = {
			f1 : function(){
				pf();//直接调用pf方法，this指代window
				pf.call(this);//通过call调用pf方法，this指代O1
			}
		};
		return O;
	}();
	var o = new O1();
	o.f1();

ex3.
	document.getElementById('xxxx').onclick = function(){
		alert(this.id);
	};
	//使用jquery注册事件时，结果是一样的
	$('#xxxx').click(function(){
		alert(this.id);
		$(this).xxx()...//以this创建jquery对象
	});

ex4：
	var abc = 'window';
	//O1
	var O1 = function(){
		function O(){
			this.abc = 'O1';
		}
		O.prototype = {
			f1 : function(){
				alert(this.abc);
			}
		};
		return O;
	}();
	//O2
	var O2 = function(){
		function O(){
			this.abc = 'O2';
		}
		O.prototype.callbackFun = function(fun){
			fun();
		}
		return O;
	}();
	//实例化O1和O2
	var o1 = new O1();
	var o2 = new O2();
	//猜猜看这里会alert什么.....window
	o2.callbackFun(o1.f1);//“window”
	//所以，在使用需要类环境的回调方法时，需要套一层function
	o2.callbackFun(function(){
		o1.f1();//“O1”
	});
	//当然，也可以通过call让this指向O2
	o2.callbackFun(function(){
		o1.f1.call(o2);//“O2”
		o1.f1.call(this);//“window”
	});

ex1. 
	//O1 父类
	function O1(){
		this.a1 = 123;
	}
	//O2 子类
	function O2(){
		O1.call(this);
	}
	var o = new O2();
	alert(o.a1);//123

ex2. 
	//O1
	function O1(){
		this.a1 = 123;
	}
	O1.prototype = {
		f1 : function(){
			alert(this.a1);
		},
		constructor : O1
	};
	//O2
	function O2(){
		//…
	}
	//将O1的所有属性和方法赋到O2.prototype
	O2.prototype = new O1();
	O2.prototype.f2 = function(){...};
	O2.prototype.constructor = O2;
	var o = new O2();
	alert(o.a1);//123

ex3：
	//O1
	function O1(a){
		this.a1 = a;
	}
	O1.prototype = {
		f1 : function(){
			alert(this.a1);
		},
		constructor : O1
	};
	//O2
	function O2(a){
		O1.call(this);
	}
	//将O1的所有属性和方法赋到O2.prototype
	O2.prototype = new O1();
	O2.prototype.f2 = function(){...};
	O2.prototype.constructor = O2;

ex4：
	//原型式继承 
	//将对象o的塑像和方法交给类F的prototype，然后返回实例化F，使返回对象具有o的属性和方法
	function object_(o){
		function F(){}
		F.prototype = o;
		return new F();
	}
	//寄生式继承
	//利用原型式继承的object_方法，将给定对象的属性和方法交给clone，然后为clone添加方法f1
	function createAnother(original){
		var clone = object_(original);
		//在通过原型继承以后，在给clone添加方法，这种方式导致代码复用率很低
		clone.f1() = function(){…};
		return clone;
	}
	//寄生组合式继承 使用寄生式继承父类的prototype对象到子类的prototype
	function inheritPrototype(superType, subType){
		var prototype = object_(superType.prototype);
		prototype.construction = subType;
		subType.prototype = prototype;
	}
	//寄生组合式继承仍然只继承prototype，如果要实现完整的继承，仍然需要结合call方法
	//下面是寄生组合式继承的示例
	//O1
	function O1(a){
		this.a1 = a;
	}
	O1.prototype = {
		f1 : function(){
			alert(this.a1);
		},
		constructor : O1
	};
	//O2
	function O2(a){
		O1.call(this);
	}
	//将O2的所有属性和方法赋到O2.prototype
	inheritPrototype(O1, O2);
	O2.prototype.f2 = function(){...};//为子类添加额外的属性/方法