es6的继承方式
// es6 继承比较方便
class Animal {
constructor(name) {
this.name = name|| '动物们';
this.sleep = function () {
console.log(this.name+'正在睡觉')
}
}
eat(foot) {
console.log(this.name+'正在是'+foot);
}
}
class Arr extends Animal{
constructor(name) {
super(name)
}
}
var a = new Arr('小猪');
a.eat('食物')
a.sleep();
console.log(a)
原型链继承方式
*好处*
// 非常纯粹的继承关系，实例是子类的实例，也是父类的实例
// 父类新增原型方法/原型属性，子类都能访问到
// 简单，易于实现
// 缺点
// 如果要新增原型属性和方法，则必须放在new Animal()这样的语句之后执行。可以在Cat构造函数中，为Cat构造函数属性
// 来自原型对象的所有属性被所有实例共享。
// 无法实现多继承
// 创建子类实例时，无法向父类构造函数传参
// 原型链继承
function Animal (name) {
// 属性
this.name = name || 'Animal';
// 实例方法
this.sleep = function(){
console.log(this.name + '正在睡觉！');
}
}
// 原型方法
Animal.prototype.eat = function(food) {
console.log(this.name + '正在吃：' + food);
};
function Cat() {
}
Cat.prototype = new Animal('狗');
var a = new Cat();
a.sleep()
实例继承
此类继承方式比较简单直接 把 new的 对象直接付给新的变量就是可以了
子类没法传入自己的参数 只是复用父类
方法只能调用 父类原型里的方法
缺点
实例是父类的实例，不是子类的实例
不支持多继承
优点
不限制调用方式，不管是new 子类()还是子类(),返回的对象具有相同的效果
function Animal (name) {
// 属性
this.name = name || 'Animal';
// 实例方法
this.sleep = function(){
console.log(this.name + '正在睡觉！');
}
}
// 原型方法
Animal.prototype.eat = function(food) {
console.log(this.name + '正在吃：' + food);
};
var a = new Animal('小猫');
a.sleep();
a.eat('');
寄生组合式继承
// 优点
// 该方法的好处在于只调用了一次SuperType构造函数，并且SubType.prototype上没有多余的属性。
// 该方法是引用类型最理想的继承方式。
// 缺点
// 写起来麻烦
// 寄生组合继承
function Animal (name) {
// 属性
this.name = name || 'Animal';
// 实例方法
this.sleep = function(){
console.log(this.name + '正在睡觉！');
}
}
// 原型方法
Animal.prototype.eat = function(food) {
console.log(this.name + '正在吃：' + food);
};
function Cat(name) {
Animal.call(this,name);
}
function redirect(a,b) {
var S = function () {} // 一个纯净的构造函数
S.prototype = b.prototype;
a.prototype = new S();
a.prototype.constructor = a;
}
redirect(Cat,Animal);
var b = new Cat('s');
b.eat('虱')
b.sleep()
拷贝继承
// 优点
// 支持多继承
// 缺点
// 效率较低，内存占用高（因为要拷贝父类的属性）
// 无法获取父类不可枚举的方法（不可枚举方法，不能使用for in 访问到）
function Animal (name) {
// 属性
this.name = name || 'Animal';
// 实例方法
this.sleep = function(){
console.log(this.name + '正在睡觉！');
}
}
// 原型方法
Animal.prototype.eat = function(food) {
console.log(this.name + '正在吃：' + food);
};
function Dog(name) {
Animal.call(this,name);
}
for (var i in Animal.prototype) {
Dog.prototype[i] = Animal.prototype[i];
}
Dog.prototype.constructor = Dog;
var a = new Dog('哈哈');
console.log(a);
a.eat('11');
a.sleep()
构造函数继承
// 优点
// 创建子类实例时，可以向父类传递参数
// 可以实现多继承（call多个父类对象）
// 缺点
// 实例并不是父类的实例，只是子类的实例
// 只能继承父类的实例属性和方法，不能继承原型属性/方法
// 无法实现函数复用，每个子类都有父类实例函数的副本，影响性能
function Arr(a,b) {
this.a = a;
this.b = b
this.fn = function () {
console.log(this.a)
}
}
Arr.prototype.console= function () {
console.log(this.b)
};
function F() {
Arr.call(this); // 构造函数继承
this.a = '我是贺岁';
this.b = 'dddd';
}
var a = new F(); // 只是子类的实例
console.log(a)
a.fn()
组合继承
// 缺点
// 效率较低，内存占用高（因为要拷贝父类的属性）
// 无法获取父类不可枚举的方法（不可枚举方法，不能使用for in 访问到）
// 相当于调用两次Animal，造成极大的浪费
// 组合继承
function Animal (name) {
// 属性
this.name = name || 'Animal';
// 实例方法
this.sleep = function(){
console.log(this.name + '正在睡觉！');
}
}
// 原型方法
Animal.prototype.eat = function(food) {
console.log(this.name + '正在吃：' + food);
};
function Arr(name) {
Animal.call(this,name) //
}
Arr.prototype= new Animal(); // 多复用了一次对象 耗性能 对象的引用关系不能打破
Arr.prototype.constructor = Arr; // 需要重新指向构造函数 无法重定向constructor
var a = new Arr('鸡');
console.log(a)
a.eat('种子')
github: https://github.com/wangqiang1122/wang-touch/tree/master/%E7%BB%A7%E6%89%BF