对于自己博问的总结

/**
 * 1、"面向对象"有三个基本特性，即封装、继承和多态。一般来说，三个特性都完全满足的话，我们称为"面向对象语言"
 * 而称满足其中部分特性的语言为："基于对象语言"。
 * 
 * 2、"对象系统"的继承特性，有三种实现方案，包括基于类、基于原型、和基于元类。这三种对象模型各具特色，也各有应用。
 * 这其中，JavaScript中没有采用我们常见的类继承体系，而是使用原型继承来实现对象系统。因此JavaScript中没有
 * "类"，而采用一种名为"构造器"的机制来实现类的某些功能。
 * 
 * 3、空对象(null)和空的对象
 * 
 * 在JavaScript中，"空的对象"是整个原型继承体系的根基。
 * 
 * 3.1)、在JavaScript中，空对象（null）是作为一个保留字存在的。null代表这样一个对象：
 * 属于对象类型。
 * 对象是空值的。
 * 由于它并不是自Object()构造器，或其子类实例而来，因此instanceof运算会返回false。
 * 
 * 3.2)、空的对象
 * 就是一个标准的、通过Object()构造的对象实例。
 * 例如，我们使用：obj = new Object()来得到obj实例。
 * 此外，对象直接量也会隐式地调用Object()来构造实例，因此下面的代码也可以得到一个"空的对象"
 * obj = {}
 * 
 * 空的对象具有"对象"的一切特性。因此可以存取预定义属性和方法（toString、valueOf等），而instanceof
 * 运算也会返回true。
 * 
 * 有时候，我们会说空的对象是"干净的对象"。在默认情况下，空的对象只有预定义的属性和方法。而for...in语句不能
 * 列出这些属性和方法，所以空的对象在for...in中并不产生任何效果。
 * 
 * 
 */

/**
 * 下面代码说明了：Oject()构造器的原型 -> Objct.prototype 
 * Objct.prototype 
 * 1）、它是一个空的对象
 * 
 * 2）、它不是自Objct()构造器实例而来，因此instanceof运算会返回false 
 * 
 * 3）、它里面有预定义的属性和方法
 * 	Object.prototype.toString = function(){return "";};
 * 
 * 4）、obj = new Object()和 obj = {} 
 * 	这两种产生对象的方式，其实都是从Object.prototype上复制出一个"对象"的映像来，所以它们也是"空的对象"
 * 
 * 5）、它没有prototype和__proto__属性，说明它是顶级的。
 * 
 * 6）、new Object()是Object的实例，实例没有prototype属性，但它内部有一个__proto__
 */
console.log(Object.prototype); // [object Object]
console.log(typeof Object.prototype); // object
console.log(Object.prototype === null); // false
console.log(Object.prototype instanceof Object); // false
console.log(Object.prototype instanceof Function); // false
console.log(Object.prototype.prototype); 	// undefined
console.log(Object.prototype.__proro__);	//undefined

console.log(new Object().prototype);	//undefined,因为是实例，所以无prototype属性
console.log(new Object().__proto__);	//Object
console.log(new Object().__proto__.prototype);	//undefined,因为是实例，所以无prototype属性
console.log(new Object().__proto__.__proto__);	//null,为什么是null，
// 取原型对象
proto = Object.prototype;

// 列举对象成员并计数
var num = 0;
for ( var n in proto) {
	num++
}
// 显示计数：0
console.log(num);


/**
 * 下面的调用方式是错误的。请务必要注意
 */
function MyFuncA(){
	alert("AA");
}
MyFuncA.prototype = {
	show: function(){
		alert("show");
	}
}

//MyFuncA.show();  //是错误的，只有new的时候，才能这么写
//MyFuncA.prototype.show();	//show

/**
 * Test
 * 由下面的例子，我们可以得出结论：
 * 如果函数没有指明其原型prototype是什么，则默认为其自身。
 * 
 * 可能的逻辑是：
 * var __proto__ = null;
 * function get_prototype(){
 * 		if(!__proto__){
 * 			__proto__ = new MyFuncB();
 * 			__proto__.constructor = this;
 * 		}
 * 		retrun __proto__;
 * }
 */
function MyFuncB(){
	this.name = "ff"
	//alert("BB");
}
console.log(MyFuncB.prototype);	//MyFuncB
var obj = new MyFuncB();
console.log(obj.__proto);		//MyFuncB
console.log(obj.__proto__.__proto);		//Object
console.log(obj.__proto__.__proto__.__proto__);		//null