javascript object oriented programming (一)

/*
  * 1. 生成对象的原始模式
  * 这就是最简单的封装了。但是，这样的写法有两个缺点
  *		1.一是如果多生成几个实例，写起来就非常麻烦
  *		2.二是实例与原型对象之间，没有任何办法，可以看出有什么联系
  */

	var Cat = {
		name : '',
		color : ''
	}
　　var cat1 = {}; // 创建一个空对象

　　　　cat1.name = "大毛"; // 按照原型对象的属性赋值

　　　　cat1.color = "黄色";

　　var cat2 = {};

　　　　cat2.name = "二毛";

　　　　cat2.color = "黑色";

	/*
	* 2. 原始模式的改进,我们可以写一个函数，解决代码重复的问题。
	* 这种方法的问题依然是，cat1和cat2之间没有内在的联系，不能反映出它们是同一个原型对象的实例。
	*/
	
	function Cat(name,color){
		return {
			name:name,
			color:color
		}
	}
	var cat1 = Cat('cat1','red');
	var cat2 = Cat('cat2','blue');
	console.log(cat1);
	console.log(cat2);

	/*
	* 3. 构造函数模式
	*	所谓"构造函数"，其实就是一个普通函数，但是内部使用了this变量。
	*	对构造函数使用new运算符，就能生成实例，并且this变量会绑定在实例对象上
	*
	*/

	 function Cat(name,color){
		this.name =  name;
		this.color = color;
	 }
	 //生成实例对象
	 var cat1 = new Cat('大黄','yellow');
	 var cat2 = new Cat('大黑','black');
	 console.log(cat1);
	 console.log(cat2);
	 //cat1和cat2会自动含有一个constructor属性，指向它们的构造函数
	 console.log(cat1.constructor === Cat);   //true
	 console.log(cat2.constructor === Cat);   //true

	 //Javascript还提供了一个instanceof运算符，验证原型对象与实例对象之间的关系。
	 console.log(cat1 instanceof Cat)	 //true
	 console.log(cat2 instanceof Cat)	 //truev


	/*
	* 4. 构造函数模式的问题
	*	每一个实例对象，type属性和eat()方法都是一模一样的内容，
	*	每一次生成一个实例，都必须为重复的内容，多占用一些内存。这样既不环保，也缺乏效率。
	*	所以有了prototype，可以把共享的方法放到prototype里。每个实例对象特有的方法放在构造函数里
	*/

　　function Cat(name,color){

　　　　this.name = name;

　　　　this.color = color;

　　　　this.type = "猫科动物";

　　　　this.eat = function(){alert("吃老鼠");};

　　}
		var cat1 = new Cat("大毛","黄色");

	　　var cat2 = new Cat ("二毛","黑色");

	　　console.log(cat1.type); // 猫科动物

	　　cat1.eat(); // 吃老鼠 

	//可以让type属性和eat()方法在内存中只生成一次，然后所有实例都指向那个内存地址呢？回答是可以的。
		console.log(cat1.eat == cat2.eat); //false

	/*
	* 5. Prototype模式 
	*	Javascript规定，每一个构造函数都有一个prototype属性，指向另一个对象(其实就是prototype对象，)。
	*	这个对象的所有属性和方法，都会被构造函数的实例继承。
	*	我们只需要把想让实例对象共享的对象和方法放到prototype对象里就可以了。
	*/
	function Cat(name,color){
		this.name = name;
		this.color = color;
	}
	Cat.prototype.type = '猫科动物';					//可以理解为属性
	Cat.prototype.eat = function(){alert('吃老鼠')};      //可以理解为方法

	var cat1 = new Cat('大黄','yellow');
	var cat2 = new Cat('大蓝','blue');
	console.log(cat1.type);
	cat1.eat();

	//所有实例的type属性和eat()方法，其实都是同一个内存地址，指向prototype对象，因此就提高了运行效率。

	console.log(cat1.eat === cat2.eat);   //true  cat1和cat2的eat方法的引用是同一个内存地址。
	/* 6. Prototype模式的验证方法  */

	//6.1 isPrototypeOf()这个方法用来判断，某个proptotype对象和某个实例之间的关系。
	console.log(Cat.prototype.isPrototypeOf(cat1));     //实例对象cat1是否与prototype对象有关系，true
	console.log(Cat.prototype.isPrototypeOf(cat2));

	//6.2 hasOwnProperty()
	//每个实例对象都有一个hasOwnProperty()方法，用来判断某一个属性到底是本地属性，还是继承自prototype对象的属性。
	//如果是prototype对象上的属性 返回false.
	console.log(cat1.hasOwnProperty('name'));      //是本地属性，构造函数内的，不是继承prototype上的属性。返回true
	console.log(cat1.hasOwnProperty('type'));	   //继承prototype对象的属性，返回false
	console.log(cat1.hasOwnProperty('eat'));	   //同type属性一样是 继承自prototype对象的属性

	//6.3 in运算符
	//in运算符可以用来判断，某个实例是否含有某个属性，无论本地属性,还是prototype对象的属性，只要含有就返回true
	console.log('name' in cat1);        //true 
	console.log('type' in cat2);		//true
	console.log('eat' in cat1);			//true

	//in运算符还可以用来遍历某个对象的所有属性。
	for(var prop in cat1) { alert("cat1["+prop+"]="+cat1[prop]); } 
	for(var prop in cat1){
		console.log("cat1["+prop+"]="+cat1[prop]);
	}
	//cat1[name]=大黄
	//cat1[color]=yellow
	//cat1[type]=猫科动物

以上只是学习笔记，记录下。

原文地址：http://www.ruanyifeng.com/blog/2010/05/object-oriented_javascript_encapsulation.html