《JavaScript入门学习》之继承

定义父类

function Animal(name) {
    this.name = name || 'animal';
    this.sleep = function () {
        console.log(this.name + '睡觉');
    }
}

Animal.prototype.eat = function(f) {
    console.log(this.name + '吃' + f);
}

原型指向父类实现继承

function Cat() {}
Cat.prototype = new Animal();
Cat.prototype.name = 'cat';

var c = new Cat();
// console.log(c.hasOwnProperty('name')); //false  name不属于Cat本身属性，属于原型链属性

console.log(c instanceof Cat); // true
console.log(c instanceof Animal); // true

console.log(c.name);
c.eat('fish');
c.sleep();

console.log(c instanceof Cat);
console.log(c instanceof Animal);

好处:
1.实现了基本意义上的继承，实例对象c是Cat类的实例，也是父类Animal的实例
2.父类原型方法/原型属性，子类都能访问到（JS查找属性的机制是先本身里查找，然后原型里查找，因这里把Cat.prototype指向了Animal new的实例，因而能够找到）

坏处：
1.新增原型属性和方法，必须放在new Animal()之后
2.无法向父类构造函数传参
3.来自原型对象的引用属性是所有实例共享的

this指向父类继承

function Cat(name) {
    // Animal.call(this);   // 将this指向父类
    // if (name) {this.name = name};
    Animal.apply(this, [name]);  // 也可以使用apply给父类传参name(推荐)
    this.age = 1;
}

var c = new Cat('tom');
console.log(c.name);
c.sleep();
//c.eat('fish'); //报错，eat是undefined，因为通过call只是把Cat内部的this指向改变了，没有把Cat的prototype指向改变

console.log(c instanceof Cat); // true
console.log(c instanceof Animal); // false  c不是Animal的子类

好处:
1.创建子类实例时，可以向父类传递参数
2.可以实现多继承（call多个父类对象）
坏处：
1.实现了基本语义上的继承，c是Cat类的实例，但这里确不是父类Animal的实例
2.只能继承父类内部定义的属性方法，不能继承父类原型里添加的属性/方法 （只是把Cat内部的this指向改变了）
3.每个子类都有父类实例方法的copy，浪费内存（每一次new Cat，都因为Animal.apply而new一份新的父类）

this指向父类 + 原型指向父类

前两种方案的结合体：

function Cat(name) {
    Animal.apply(this, [name]);
    this.age = 1;
}
Cat.prototype = new Animal(); //prototype赋值为父类Animal实例，能够继承父类的prototype里属性方法
Cat.prototype.constructor = Cat;  // 修改constructor

let c = new Cat('tom');
console.log(c.name, c.age);
c.sleep();
c.eat('yu');

console.log(c instanceof Cat); // true
console.log(c instanceof Animal); // true

好处:
1.弥补前两种方案不足，能继承父类内部以及其原型里的属性方法，实现完整意义的继承
坏处：
1.继承实现过程中创建出两份父类Animal对象，很浪费内存。

原型链继承

思想就是仿照js底层的原型链查找属性机制：

              __proto__                      __proto__                       __proto__
 new Cat() --------------> Cat.prototype --------------> Animal.prototype --------------> Object.prototype

function Cat(name) {
    Animal.apply(this, [name]);
}

function F() { }
F.prototype = Animal.prototype;   //将一个空构造函数prototype指向父类Animal.prototype

Cat.prototype = new F();  // Cat.prototype.__proto__= Animal.prototype
Cat.prototype.constructor = Cat; 

let c = new Cat('tom');
console.log(c.name, c.age);
c.sleep();
c.eat('yu');

console.log(c instanceof Cat); // true
console.log(c instanceof Animal); // true