JS中的多种继承方式

JS自己是基于面向对象开发的编程语言：因此咱们学习JS主要就是学习类，以及类的实例，在学习类的原型上提供的方法；

类：

• 封装、继承、多态

1、类的封装

• 类也是一个函数，把实现一个功能的代码进行封装，以此实现“低耦合高内聚”

2、多态：重载、重写

• 重写：子类重写父类上的方法（伴随着继承运行的）
• 重载：相同的方法，因为参数或者返回值不一样，具有了不一样的功能（JS中不具有严格意义上的重载，JS中的重载：同一个方法内，根据传参不一样实现不一样的功能）

一、在后台语言当中：

• 重载定义：
  • 指的是在方法名字相同，都叫fn，可是参数的类型或者参数的个数不一样，因此致使这两个方法不是一个方法，而变成了两个方法；（咱们认为这就是方法的重载）
• 重载的目的：（为了分担压力的）
  • 正常状况下，客户端向服务器发请求，一台服务器容许多个客户端同时发请求，因此服务器要有很强的抗压能力，
  • 若是说咱们把全部的功能（好比传两个参数干什么，传一个参数干什么）都放在一个方法中，那这个方法承载的压力就会比较大，
  • 因此咱们通常经过重载的方式来分发出这个方法承载的压力；

//=> 在后台语言中，
public void fn(int x,init y){

}
public void fn(int x){

}
fn(10,20);  执行第一个FN
fn(10);  执行第二个FN
fn('小芝麻');  报错  

复制代码

二、在JS语言中：这种方式并非重载

• 因为JS中的变量提高机制，因此只执行第二个
• 因此说JS中不具有严格意义上的重载，

function fn(x, y) {

}

function fn(x) {

}
fn(10, 20);  执行第二个FN
fn(10); 执行第二个FN 
复制代码

• JS中的重载：同一个方法内，根据传参不一样实现不一样的功能

function fn(x, y) {
    if(y===undefined){
        // ...
        return;
    }
    // ....
}
fn(10);
fn(10, 20); 
复制代码

3、继承：子类继承父类中的方法

这里想到了一个笑话：

A去医院检查，被查出是“类风湿性关节炎”
A：好郁闷，得了…
B：这个病注意点就行了啊
A：不行，由于咱们打算要孩子
B：你这个病和孩子有啥关系啊
….
10min  A的脑子中 "类风湿性关节炎” => 类是继承的 复制代码

在生物学上的继承相似于：

父亲：基因
   AAA  BBB  CCC

儿子：继承了父亲的基因（把父亲的部分基因，直接拷贝到自身上）
   AAA  BBB 
   儿子基因突变  AAB  BBA，可是对父亲是没有影响的
复制代码

正常的后台语言中的继承，就是这种拷贝式的继承，可是咱们JS中的继承并非这种继承；

一、继承的定义：

• 在JS语言中，它的继承和其它编程语言仍是不太同样的

二、继承的目的：

• 让子类的实例同时也具有父类中私有的属性和公共的方法

三、JS中继承方案

第一种：原型继承（让子类的原型等于父类的实例便可）

function Parent() {
	this.x = 100;
}
Parent.prototype.getX = function getX() {
	return this.x;
};

function Child() {
	this.y = 200;
}
//=> 让子类的原型等于父类的实例
Child.prototype = new Parent; //=>原型继承

Child.prototype.getY = function getY() {
	return this.y;
};

let c1 = new Child;
console.log(c1); 
复制代码

如今c1 能用的方法是：私有的 y 和公有的 getY方法，以及Object上的公有方法；

1.原理

• 子类的实例，可以用子类私有的和原型上公有的
• 父类的实例，可使用 父类私有和原型上公有的

因此咱们只要让子类的原型等于父类的实例便可

• Child.prototype = new Parent

2.特色

• 一、父类中私有和公有的属性方法，最后都变为子类实例公有的
• 二、和其余语言不一样的是
  • 原型继承并不会把父类的属性方法“拷贝”给子类，
  • 而是让子类实例基于__proto__原型链找到本身定义的属性和方法“指向/查找”方式的

3.优缺点

• c1.__proto__.xxx = xxx 修改子类原型（原有父类的一个实例）中的内容，内容被修改后，对子类的其余实例有影响，可是对父类的实例不会有影响

• c1.__proto__.__proto__.xxx = xxx直接修改的是父类原型，这样不只会影响其它父类的实例，也影响其余子类的实例

• JS中的重写影响很大

第二种：CALL继承（只能继承父类中私有的，不能继承父类中公共的）

function Parent() {
	this.x = 100;
}
Parent.prototype.getX = function getX() {
	return this.x;
};

function Child() {
	// 在子类构造函数中，把父类当作普通方法执行（没有父类实例，父类原型上的那些东西也就和它不要紧了）
	// this -> Child的实例c1
	Parent.call(this); // this.x=100 至关于强制给c1这个实例设置一个私有的属性x，属性值100，至关于让子类的实例继承了父类的私有的属性，而且也变为了子类私有的属性 “拷贝式”
	this.y = 200;
}
Child.prototype.getY = function getY() {
	return this.y;
};

let c1 = new Child;
console.log(c1); 
复制代码

1.原理

• 在子类构造函数中，把父类看成普通函数执行（没有父类实例，父类原型上的那些东西也就和他没有关系了）
  • 此时 parent(this) 这个 this 是 window
• 经过 call 强制改变 this 的指向为 Child 中的 this
  • Parent.call(this)
  • 此时 this 是当前 Child 中的 this

至关于强制给实例设置了一个私有的属性，至关于让子类的实例继承了父类的私有的属性，而且也变为了子类私有的属性“拷贝式”

2.特色

• 只能继承父类中私有的，公有的不行(而且是把父类私有的变成子类私有的)

咱们满意的继承方式应该是：父类私有变为子类私有 父类公有变为子类公有

第三种：寄生组合式继承（CALL继承 + 另类原型继承）

function Parent() {
	this.x = 100;
}
Parent.prototype.getX = function getX() {
	return this.x;
};

function Child() {
	Parent.call(this);
	this.y = 200;
}

Child.prototype = Object.create(Parent.prototype);
Child.prototype.constructor = Child;

Child.prototype.getY = function getY() {
	return this.y;
};

let c1 = new Child;
console.log(c1); 
复制代码

• 上面咱们说了 call 继承有个好处：能把父类私有的变成子类私有的；因此 call 继承咱们留下来

那如今咱们只要想办法让父类中公有的也能变成子类中公有的便可；

1.原理

咱们刚才的原型继承，大致的实现了这个功能；

• 原型继承是建立了父类的一个实例，从而达到子类继承父类的效果；它最终实现的核心点是：Child.prototype.__proto__ === Parent.prototype;
• 若是说咱们在原型继承时不想要父类私有的内容，咱们只须要：Child.prototype.__proto__ = Parent.prototype;

  

这样虽然能实现效果可是IE浏览器中不容许咱们操做__proto__,那咱们有什么能够替换它呢？

// Object.create();建立一个空对象，让其原型链指向obj
let obj = {
	xxx: 'xxx'
};
console.log(Object.create(obj));
复制代码

因此能够写成：Child.prototype = Object.create(Parent.prototype);便可

2.缺点：

• 因为新建立的原型没有constructor属性，因此咱们本身手动加一个默认的；

4、ES6中的类和继承

• class类

class Parent {
	constructor() {
		this.x = 100;
	}
	// Parent.prototype.getX=function...
	getX() {
		return this.x;
	}
}
复制代码

• 继承

// 继承: extends Parent（相似于寄生组合继承）
// 注意：继承后必定要在CONSTRUCTOR第一行加上SUPER
class Child extends Parent {
	constructor() {
		super(); //=>相似于咱们以前的CALL继承 super(100,200)：至关于把Parent中的constructor执行，传递了100和200
		this.y = 200;
	}
	getY() {
		return this.y;
	}
}
let c1 = new Child;
console.log(c1);

// Child(); //=>Uncaught TypeError: Class constructor Child cannot be invoked without 'new' ES6中建立的就是类，不能当作普通函数执行，只能new执行
复制代码

思惟导图