构造函数：function Name（）{}
原型对象：Name.prototype的各种属性和方法
实例：var a = new Name;
1.每创建一个构造函数(Name首字母大写，区分一般定义函数)都会默认创建了该函数的原型对象，原型对象中的默认属性constructor指向该构造函数Name。当Name.prototype以字面量对象形式表示时，constructor不再指向构造函数Name，而是Object。
2.当创建一个实例后，实例中存在指向现有原型对象的指针（不指向构造函数），如果现有原型对象被修改，则修改之前的实例指针仅能指向之前的原型对象，而在原型对象修改之后定义的实例则能获取所有的原型对象的属性和方法（最初原型+修改后的原型）。

<pre name="code" class="javascript">function Person(){}
var friend = new Person;
Person.prototype = {
constructor: Person,
name: "Todd";
age: 10;
getName = function() {
return this.name
}
}
var family = new Person;
alert (friend.name);   //errer
alert (family.name);  //Todd



定义friend实例时，原型对象为空，所以浏览器没弹出警告框。

定义family实例时，原型对象中已经有属性了,所以可以读取属性和方法。

                    
类可以理解为一种类型，对象是类中的一种实例。用类创建对象的过程叫做实例化。所以实例和类基本就是同一个概念。

最常见的举例是：
 
类Class：鸟
类的方法（函数）：（鸟）会飞
类的属性（变量）：爪子，翅膀
 
实例：
对象：麻雀，是（类Class）鸟 的一种
对象方法（函数）：麻雀会飞
对象的变量：麻雀有2个爪子，一对翅膀









      本文转自Tenderrain 51CTO博客，原文链接：http://blog.51cto.com/tenderrain/1588475，如需转载请自行联系原作者




        
        
                
    

JavaScript 规定，每一个构造函数都有一个 prototype 属性，指向另一个对象。这个对象的所有属性和方法，都会被构造函数的所拥有。

这也就意味着，我们可以把所有对象实例需要共享的属性和方法直接定义在 prototype 对象上。

function Person (name, age) {
  this.name = name;
  this.age = age;
}
​
console.log(Person.prototype);

Person.prototype.type = 'human';
​
Person.prototype.sayName = function () {
  console.log(this.name);
}
​
var p1 = new Person(...);
var p2 = new Person(...);
​
console.log(p1.sayName === p2.sayName); // => true

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

构造函数、实例、原型三者之间的关系



任何函数都具有一个 prototype 属性，该属性是一个对象。

function F () {}
console.log(F.prototype) // => object


构造函数的 prototype 对象默认都有一个 constructor 属性，指向 prototype 对象所在函数。

console.log(F.prototype.constructor === F) // => true

通过构造函数得到的实例对象内部会包含一个指向构造函数的 prototype 对象的指针 __proto__。

var instance = new F()
console.log(instance.__proto__ === F.prototype) // => true

ps:__proto__ 是非标准属性。

实例对象可以直接访问原型对象成员。

instance.sayHi() // => hi!

总结：


	
任何函数都具有一个 prototype 属性，该属性是一个对象
	
	

	
构造函数的 prototype 对象默认都有一个 constructor 属性，指向 prototype 对象所在函数
	
	

	
通过构造函数得到的实例对象内部会包含一个指向构造函数的 prototype 对象的指针 __proto__
	
	

	
所有实例都直接或间接继承了原型对象的成员
	

在《Thinking in Java》一书里提到：“每个对象都是某个类（class）的一个实例，这里类就是类型的意思”。

通俗地说，实例表示的是对象和类的关系

比如：

Person b=new Person();     

new Person()新建了一个Person对象，而b则是一个指向Person对象的引用，这个Person对象就是Person类的一个实例。

此时，可以认为实例和对象是一样的概念。

 

Person b=new Person("a");  

new Person(）;是一个对象，放在堆（heap）空间。

a属于new  Person()里面的是一个实例（放在常量池中）。

b属于一个引用，放在栈（stack）空间，要操作对象必须通过引用间接操作。    

这个地址是指向new  Person()这个对象的。    

 

栈：存放基本类型的数据和对象的引用，但对象本身不存放在栈中，而是存放在堆中   

堆：存放用new 产生的数据   

 

如果是出现多态的话，

//Child extends Person
Person person = new Child();

可以看出new Child()这个实例化过程显然并没有将Child类的所有函数实例化，因为person是无法调用Child类独有的方法的。

所以只是部分实例化，这也表现了实例和对象之间的区别。