首頁  >  文章  >  web前端  >  es6中用什麼實作繼承

es6中用什麼實作繼承

青灯夜游
青灯夜游原創
2023-02-14 13:56:572423瀏覽

es6中用class和extends關鍵字來實現繼承。 ES6中引入了class關鍵字來聲明類,而class(類)可透過extends關鍵字實現繼承,讓子類繼承父類的屬性和方法,語法「class 父類名{...} class 子類名extends 父類別名稱{...};」。

es6中用什麼實作繼承

本教學操作環境:windows7系統、ECMAScript 6版、Dell G3電腦。

es6中可利用class關鍵字配合extends關鍵字來實現繼承。

ES6 Class 的繼承

#1.簡介

Class可以透過extends關鍵字實作繼承,讓子類別繼承父類別的屬性和方法。這比 ES5 的透過修改原型鏈實現繼承,要清晰和方便很多。

//父类
class Point {
 ...
}
//子类
class ColorPoint extends Point {
	constructor(x, y, color) {
		super(x, y);
		this.color = color;
	}
	toString() {
		return this.color + '' + super.toString(); // 调用父类的toString方法
	}
}

上面程式碼中,constructor方法和toString方法內部,都出現了super關鍵字,super在這裡表示父類別的建構函數,用來新建一個父類別的實例物件。

ES6規定,子類別必須在constructor方法中呼叫super(),否則會報錯,這是因為子類別自己的this對象,必須先透過父類別的建構子完成塑造,得到與父類同樣的實例屬性和方法,然後在加入子類別自己的實例屬性和方法。

為什麼子類別的建構函數,一定要呼叫super()?

這是因為在ES5的繼承機制中,是先創造一個獨立的子類別的實例對象,然後再將父類別的方法加入到這個物件上,也就是「實例在前,繼承在後」;ES6的繼承機制,則是先將父類別的屬性和方法,加到一個空的物件上面,然後再將該物件作為子類別的實例,即“繼承在前,實例在後” 。

這意味著,每次新建子類別實例時,父類別的建構子必定會先執行一次

class Foo {
	constructor() {
		console.log(1);
	}
}

class Bar extends Foo {
	constructor() {
		super();
		console.log(2);
	}
}

const bar = new Bar(); // 1 2

上面的程式碼中,子類別Bar新建實例時,就會輸出1和2,這就是因子類別建構子呼叫super()時,會執行一次父類別建構子。只有在子類別的建構子中呼叫super之後,才可以使用this關鍵字,否則會報錯。這是因為子類別實例的構建,必須先完成父類別的繼承,只有super方法才能讓子類別實例繼承父類別。

class Point {
	constructor(x, y) {
		this.x = x;
		this.y = y;
	}
}

class ColorPoint extends Point {
	constructor(x, y, color) {
		this.color = color;
		super(x, y);
		this.color = color;
	}
}"

如果子類別沒有定義constructor方法,這個方法會預設添加,並且裡面會呼叫super,也就是說,不管有沒有顯示定義,任何一個子類別都有constructor方法.

class Point {
  constructor(x, y) {
    this.x = x;
    this.y = y;
  }
}
class ColorPoint extends Point {
}

let cp = new ColorPoint(25, 8);
console.log(cp); //{x: 25, y: 8}

class ColorPoint extends Point {
  constructor(...args) {
    super(...args);
  }
}

let cp = new ColorPoint(25, 8);
console.log(cp); //{x: 25, y: 8}

2.私有屬性和私有方法的繼承

父類別所有的屬性和方法,都會被子類別繼承,除了私有的屬性和方法。子類別無法繼承父類別的私有屬性,或者說私有屬性只能在定義它的class裡面使用。

class Foo {
  #p = 1;
  #m() {
    console.log('hello');
  }
}

class Bar extends Foo {
  constructor() {
    super();
    console.log(this.#p); // 报错
    this.#m(); // 报错
  }
}

上面範例中,子類別 Bar 呼叫父類別 Foo 的私有屬性或私有方法,都會報錯。

如果父類別定義了私有屬性的讀寫方法,子類別就可以透過這些方法,讀寫私有屬性。

class Foo {
  #p = 1;
  getP() {
    return this.#p;
  }
}

class Bar extends Foo {
  constructor() {
    super();
    console.log(this.getP()); // 1
  }
}

3.靜態屬性和方法的繼承

#父類別的靜態屬性和靜態方法,也會被子類別繼承。

class A {
  static hello() {
    console.log('hello world');
  }
}

class B extends A {
}

B.hello()  // hello world

上面程式碼中,hello()A類別的靜態方法,B繼承A,也繼承了A的靜態方法。

注意,靜態屬性是透過淺拷貝實作繼承的,如果繼承的屬性是原始資料類型,子類別中操作繼承的靜態屬性不會影響到父類,但如果繼承的屬性是物件,那麼子類別修改這個屬性會印像到父類別

class C {
	static foo = 100;
}

class D extends C {
	constructor() {
		super();
		D.foo--;
	}
}

const d = new D();
C.foo; // 100
D.foo;  // 99

class A {
	static foo = { n: 100 };
}

class B extends A {
	constructor() {
		super();
		B.foo.n--;
	}
}

const b = new B();
B.foo.n // 99
A.foo.n  // 99

4.Object.getPrototypeOf()

Object.getPrototypeOf ()方法可以用來從子類別上取得父類別。

class Point { /*...*/ }

class ColorPoint extends Point { /*...*/ }

Object.getPrototypeOf(ColorPoint) === Point
// true

因此,可以使用這個方法來判斷,一個類別是否繼承了另一個類別。

5.super關鍵字

#super關鍵字既可以當做函數使用,也可以當做物件使用

第一種情況,super當函數呼叫時,代表父類別的建構子。呼叫super的作用是形成子類別的this對象,把父類別的實例屬性和方法都放到這個this物件上面。

class A {
	constructor() {
    console.log(new.target.name);
  }
}

class B extends A {
	constructor() {
		super();
	}
}

new A(); // A
new B(); // B

第二種情況,super作為物件時,在普通方法中,指向父類別的原型物件;在靜態方法中,指向父類別。

class A {
	p() {
    return 2;
  }
}

class B extends A {
  constructor() {
    super();
    console.log(super.p()); // 2
  }
}

let b = new B();

上面程式碼中,子類別B中的super.p(),將super當做一個物件使用,這時super在普通物件中,指向的是A.prototype,super.p()相當於A.prototype.p()。

由於super指向父類別的原型對象,所以定義在父類別實例上的方法或屬性,是無法透過super呼叫的。如下所示:

class A {
	constructor() {
		this.p = 2;
	}
}

class B extends A {
	get m() {
		return spuer.p;
	}
}

let b = new B();
b.m // undefined

為了解決這種問題,可以將屬性定義在父類別的原型物件上

class A {};
A.prototype.x = 2;

class B extends A {
	constructor() {
		super();
		console.log(super.x);
	}
}

let b = new B();

ES6規定,在子類別普通方法中透過super呼叫父類別的方法時,方法內部的this指向目前的子類別實例

class A {
	constructor() {
		this.x = 1;
	}
	print() {
		console.log(this.x);
	}
}

class B extends A {
	constructor() {
		super();
		this.x = 2;
	}
	m() {
		super.print();
	}
}

let b = new B();
b.m(); // 2

上面代码中,super.print()调用的是A.prototype.print(),但是此时方法内部的this指向是子类B的实例,所以输出2。

由于this指向的是子类实例,所有如果通过super对某个属性赋值,这时super就是this,赋值的属性会变成子类实例的属性

class A {
	constructor() {
		this.x = 1;
	}
}

class B extends A {
	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将指向父类,而不是父类的原型对象。

class Parent {
	static myMethod(msg) {
		console.log('static', msg);
	}

	myMethod(msg) {
		console.log('instance', msg);
	}
}

class Children extends Parent {
	static myMethod(msg) {
		super.myMthod(msg);
	}

	myMethod(msg) {
    super.myMethod(msg);
  }
}

Child.myMethod(1); // static 1

var child = new Child();
child.myMethod(2); // instance 2

上面代码中,super在静态方法之中指向父类,在普通方法之中指向父类的原型对象。

另外,在子类的静态方法中通过super调用父类的方法时,方法内部的this指向当前的子类,而不是子类的实例

class A {
	constructor() {
    this.x = 1;
  }
  static print() {
    console.log(this.x);
  }
}

class B extends A {
  constructor() {
    super();
    this.x = 2;
  }
  static m() {
    super.print();
  }
}

B.x = 3;
B.m() // 3

在静态方法m中,super.print指向父类的静态方法,到那时this指向的是类B,而不是B的实例。

【推荐学习:javascript高级教程

以上是es6中用什麼實作繼承的詳細內容。更多資訊請關注PHP中文網其他相關文章!

陳述:
本文內容由網友自願投稿,版權歸原作者所有。本站不承擔相應的法律責任。如發現涉嫌抄襲或侵權的內容,請聯絡admin@php.cn