JavaScript（三）（对象/原型/继承）

封装：将属性和方法封装进对象

构造函数：函数中有this指向对象

function Cat(name,color) {
this.name = name;
this.color = color;
}

从构造函数生成实例：

var cat1 = new Cat("老大","yellow");//this 绑定在实例对象上
var cat2 = new Cat("老二","red");//this 绑定在实例对象上

生成实例的时候，为每个实例开辟一个内区域。

cat1.name;//"老大"
cat2.color;//"red"

实例对象有个constructor属性，默认指向构造函数：

cat1.constructor === Cat;//true
cat2.constructor === Cat;//true

每个实例对象有一个内存区域，当实例对象之间有共同的属性时，就会造成内存的浪费：

function Cat(name,color) {
this.name = name;
this.color = color;
this.type = "cat";
this.eat = function() { console.log("eat"); };
}
var cat1 = new Cat("老大","yellow");//每个cat实例都有一个相同属性值的属性和方法，浪费内存
var cat2 = new Cat("老二","red");

解决方法：prototype：
构造函数的prototype属性是一个对象，这个对象的属性和方法都会被实例所继承；
因此，可以将属性值相同的属性或者方法给这个对象，则实例对象因为继承，自然就拥有了这些属性和方法：

function Cat(name,color) {
this.name = name;
this.color = color;
}
Cat.prototype.type = "cat";
Cat.prototype.eat = function() { console.log("eat"); };
var cat1 = new Cat("老大","yellow");
cat1.type;//"cat"
cat1.eat();//"eat"

这些属性和方法存放在prototype对象中，实例只是继承这些属性和方法，无需占用新的内存，节约了内存空间。
所有实例的type属性和eat()方法，其实都是同一个内存地址，指向prototype对象，因此就提高了运行效率。
isPrototypeOf 判断某个prototype对象和某个实例的关系：

Cat.isPrototypeOf(cat1);//true

hasOwnProperty(); 判读某个属性是不是自身的属性而不是继承的属性

cat1.hasOwnProperty("name");//true
cat1.hasOwnProperty("type");//false

in 判断某个对象有没有这个属性（包括继承来的）：

"name" in cat1;//true
"type" in cat1;//true

构造函数的继承（五种方法）：
法一：apply方法

function Animal() {
this.type = "animal";
}
funciton Cat(name,color) {
Animal.apply(this,arguments);//将Animal中的this指向这个Cat构造函数，则Cat自然可以使用Animal中的属性和方法
this.name = name;
this.color = color;
}
var cat1 = new Cat("老大","yellow");
cat1.type;//"animal"

法二：prototype指向一个实例对象

function Animal() {
this.type = "animal";
}
funciton Cat(name,color) {
this.name = name;
this.color = color;
}
Cat.prototype = new Animal();//Cat 的prototype对象指向要继承的构造函数的实例，则这个实例拥有的属性和方法，Cat.prototype也拥有了，然后Cat的实例cat1继承Cat.prototype的所有属性和方法，自然就继承了Animal的属性和方法
Cat.prototype.constructor === Animal;//true，改变了constructor属性应有的值
Cat.prototype.constructor = Cat;//将prototype 的 constructor属性重新赋值为Cat
Cat.prototype.constructor === Cat;//true
var cat1 = new Cat("老大","yellow");
cat1.type;//"animal"
cat1.constructor === Cat;//true;

存在问题：要先生成一个Animal实例，占用一定的内存空间；
解决方法：法三：直接继承prototype

function Animal() {};
Animal.prototype.type = "animal";
funciton Cat(name,color) {
this.name = name;
this.color = color;
}
Cat.prototype = Animal.prototype;
var cat1 = new Cat("老大","yellow");
cat1.type;//"animal"
Cat.prototype.constructor === Animal;//true 因为Cat.prototype指向Animal.prototype了
cat1.constructor ===Animal;//true 实例的constructor也被修改了
Cat.prototype.constructor = Cat;//需要重新将constructor属性指向原来的构造函数
Cat.prototype.constructor === Cat;//true;
cat1.constructor === Cat;//true;
Animal.prototype.constructor === Cat;//true 但是Cat的constructor对了，Animal的constructor却被改变了，因为Cat.prototype直接指向Animal.prototype，修改Cat.prototype的constructor属性也会修改Animal.prototype的constructor属性

解决方法：法四：利用空对象作为中介：

function Animal() {};
Animal.prototype.type = "animal";
function Cat(name,color) {
this.name = name;
this.color = color;
}
var F = function() {};
F.prototype = Animal.prototype;
Cat.prototype = new F();
Cat.prototype.constructor === Animal;//true Cat.prototype指向F的实例，所以Cat.prototype的构造函数就是F实例的构造函数，F实例的构造函数默认指向F.prototype的构造函数，因为F.prototype指向Animal.prototype，所以F.prototype的构造函数就是Animal.prototype的构造函数，所以Cat.prototype的构造函数就是Animal
Cat.prototype.constructor = Cat;//重新正确指向原来的构造函数，因为Cat.prototype只是指向F的一个实例，所以只修改了F实例的构造函数，而不修改F.prototype和Animal.prototype的构造函数
Cat.prototype.constructor === Cat;//true
Animal.prototype.constructor === Animal;//true
var cat1 = new Cat("老大","yellow");
cat1.type;//"animal"

法五：拷贝继承
把父对象的所有属性和方法拷贝进子对象

function Animal(){}
Animal.prototype.species = "动物";
function extend2(Child, Parent) {
　　　　var p = Parent.prototype;
　　　　var c = Child.prototype;
　　　　for (var i in p) {
　　　　　　c[i] = p[i];
　　　　　　}
　　　　c.uber = p;
　}
function Cat(name,color) {
this.name = name;
this.color = color;
}
extend2(Cat, Animal);
var cat1 = new Cat("大毛","黄色");
alert(cat1.species);//"动物"

Cat不继承Animal的构造函数中属性和方法，只继承Animal.prototype的属性和方法