云技术本篇内容主要讲解“es6实现继承的关键字是什么”，感兴趣的朋友不妨来看看。本文介绍的方法操作简单快捷，实用性强。下面就让小编来带大家学习“es6实现继承的关键字是什么”吧! es6中用class和extends关键字来实现继承。ES6中引入了class关键字来声明类， 而class（类）可通过extends关键字实现继承，让子类继承父类的属性和方法，语法“class 父类名{…} class 子类名 extends 父类名{…};”。1.简介Class可以通过extends关键字实现继承，让子类继承父类的属性和方法。这比 ES5 的通过修改原型链实现继承，要清晰和方便很多。
//父类
classPoint{
...
}
//子类
classColorPointextendsPoint{
constructor(x,y,color){
super(x,y);
this.color=color;
}
toString(){
returnthis.color+''+super.toString();//调用父类的toString方法
}
}
上面代码中，constructor方法和toString方法内部，都出现了super关键字，super在这里表示父类的构造函数，用来新建一个父类的实例对象。ES6规定，子类必须在constructor方法中调用super()，否则会报错，这是因为子类自己的this对象，必须先通过父类的构造函数完成塑造，得到与父类同样的实例属性和方法，然后在添加子类自己的实例属性和方法。这是因为在ES5的继承机制中，是先创造一个独立的子类的实例对象，然后再将父类的方法添加到这个对象上，即“实例在前，继承在后”；ES6的继承机制，则是先将父类的属性和方法，加到一个空的对象上面，然后再将该对象作为子类的实例，即“继承在前，实例在后”。这意味着，每次新建子类实例时，父类的构造函数必定会先运行一次
classFoo{
constructor(){
console.log(1);
}
}
classBarextendsFoo{
constructor(){
super();
console.log(2);
}
}
constbar=newBar();//12
上面的代码中，子类Bar新建实例时，会输出1和2，这就是因子类构造函数调用super（）时，会执行一次父类构造函数。只有在子类的构造函数中调用super之后，才可以使用this关键字，否则会报错。这是因为子类实例的构建，必须先完成父类的继承，只有super方法才能让子类实例继承父类。
classPoint{
constructor(x,y){
this.x=x;
this.y=y;
}
}
classColorPointextendsPoint{
constructor(x,y,color){
this.color=color;
super(x,y);
this.color=color;
}
}"
如果子类没有定义constructor方法，这个方法会默认添加，并且里面会调用super，也就是说，不管有没有显示定义，任何一个子类都有constructor方法.
classPoint{
constructor(x,y){
this.x=x;
this.y=y;
}
}
classColorPointextendsPoint{
}
letcp=newColorPoint(25,8);
console.log(cp);//{x:25,y:8}
classColorPointextendsPoint{
constructor(...args){
super(...args);
}
}
letcp=newColorPoint(25,8);
console.log(cp);//{x:25,y:8}
2.私有属性和私有方法的继承父类所有的属性和方法，都会被子类继承，除了私有的属性和方法。子类无法继承父类的私有属性，或者说私有属性只能在定义它的class里面使用。
classFoo{
#p=1;
#m(){
console.log('hello');
}
}
classBarextendsFoo{
constructor(){
super();
console.log(this.#p);//报错
this.#m();//报错
}
}
上面示例中，子类 Bar 调用父类 Foo 的私有属性或私有方法，都会报错。如果父类定义了私有属性的读写方法，子类就可以通过这些方法，读写私有属性。
classFoo{
#p=1;
getP(){
returnthis.#p;
}
}
classBarextendsFoo{
constructor(){
super();
console.log(this.getP());//1
}
}
3.静态属性和方法的继承父类的静态属性和静态方法，也会被子类继承。
classA{
statichello(){
console.log('helloworld');
}
}
classBextendsA{
}
B.hello()//helloworld
上面代码中，hello()是A类的静态方法，B继承A，也继承了A的静态方法。注意，静态属性是通过浅拷贝实现继承的，如果继承的属性是原始数据类型，子类中操作继承的静态属性不会影响到父类，但如果继承的属性是一个对象，那么子类修改这个属性会印象到父类
classC{
staticfoo=100;
}
classDextendsC{
constructor(){
super();
D.foo--;
}
}
constd=newD();
C.foo;//100
D.foo;//99
classA{
staticfoo={n:100};
}
classBextendsA{
constructor(){
super();
B.foo.n--;
}
}
constb=newB();
B.foo.n//99
A.foo.n//99
4.Object.getPrototypeOf()Object.getPrototypeOf()方法可以用来从子类上获取父类。
classPoint{/*...*/}
classColorPointextendsPoint{/*...*/}
Object.getPrototypeOf(ColorPoint)===Point
//true
因此，可以使用这个方法判断，一个类是否继承了另一个类。5.super关键字super关键字既可以当做函数使用，也可以当做对象使用第一种情况，super作为函数调用时，代表父类的构造函数。调用super的作用是形成子类的this对象，把父类的实例属性和方法都放到这个this对象上面。
classA{
constructor(){
console.log(new.target.name);
}
}
classBextendsA{
constructor(){
super();
}
}
newA();//A
newB();//B
第二种情况，super作为对象时，在普通方法中，指向父类的原型对象；在静态方法中，指向父类。
classA{
p(){
return2;
}
}
classBextendsA{
constructor(){
super();
console.log(super.p());//2
}
}
letb=newB();
上面代码中，子类B中的super.p()，将super当做一个对象使用，这时super在普通对象中，指向的是A.prototype，super.p()相当于A.prototype.p()。由于super指向父类的原型对象，所以定义在父类实例上的方法或属性，是无法通过super调用的。如下所示：
classA{
constructor(){
this.p=2;
}
}
classBextendsA{
getm(){
returnspuer.p;
}
}
letb=newB();
b.m//undefined
为了解决这种问题，可以将属性定义在父类的原型对象上
classA{};
A.prototype.x=2;
classBextendsA{
constructor(){
super();
console.log(super.x);
}
}
letb=newB();
ES6规定，在子类普通方法中通过super调用父类的方法时，方法内部的this指向当前的子类实例
classA{
constructor(){
this.x=1;
}
print(){
console.log(this.x);
}
}
classBextendsA{
constructor(){
super();
this.x=2;
}
m(){
super.print();
}
}
免费云主机、域名
letb=newB();
b.m();//2
上面代码中，super.print()调用的是A.prototype.print()，但是此时方法内部的this指向是子类B的实例，所以输出2。由于this指向的是子类实例，所有如果通过super对某个属性赋值，这时super就是this，赋值的属性会变成子类实例的属性
classA{
constructor(){
this.x=1;
}
}
classBextendsA{
constructor(){
super();
this.x=2;
super.x=3;
console.log(super.x);//undefind
console.log(this.x);//3
}
}
上面代码中，super.x赋值为3，这时等同于对this.x赋值为3。而当读取super.x 的时候，读的是A.prototype.x，所以返回undefined。如果super作为对象，用在静态方法之中，这时super将指向父类，而不是父类的原型对象。
classParent{
staticmyMethod(msg){
console.log('static',msg);
}
myMethod(msg){
console.log('instance',msg);
}
}
classChildrenextendsParent{
staticmyMethod(msg){
super.myMthod(msg);
}
myMethod(msg){
super.myMethod(msg);
}
}
Child.myMethod(1);//static1
varchild=newChild();
child.myMethod(2);//instance2
上面代码中，super在静态方法之中指向父类，在普通方法之中指向父类的原型对象。另外，在子类的静态方法中通过super调用父类的方法时，方法内部的this指向当前的子类，而不是子类的实例
classA{
constructor(){
this.x=1;
}
staticprint(){
console.log(this.x);
}
}
classBextendsA{
constructor(){
super();
this.x=2;
}
staticm(){
super.print();
}
}
B.x=3;
B.m()//3
在静态方法m中，super.print指向父类的静态方法，到那时this指向的是类B，而不是B的实例。到此，相信大家对“es6实现继承的关键字是什么”有了更深的了解，不妨来实际操作一番吧！这里是云技术网站，更多相关内容可以进入相关频道进行查询，关注我们，继续学习！
这篇文章主要介绍了jquery如何替换标签属性值的相关知识，内容详细易懂，操作简单快捷，具有一定借鉴价值，相信大家阅读完这篇jquery如何替换标签属性值文章都会有所收获，下面我们一起来看看吧。 替换标签属性值的两种方法：1、使用attr()替换属性值，语法“…
主机管理平台有哪些？
企业网站主机，选云服务器还是虚拟主机？
域名注册申请，必须要实名吗？