1. Use objetos de función para definir subclases:
function Niyy() {
this.name = "Niyy";
}
Niyy.prototype.sayHello = function () {
console.log("Hello, I am " + this.name);
};
function ES() {
Niyy.call(this); // 调用父类构造函数
this.language = "JavaScript";
}
ES.prototype = Object.create(Niyy.prototype); // 设置原型链
ES.prototype.constructor = ES; // 修复构造函数指向
ES.prototype.sayLanguage = function () {
console.log("I code in " + this.language);
};
function TS() {
Niyy.call(this); // 调用父类构造函数
this.language = "TypeScript";
}
TS.prototype = Object.create(Niyy.prototype); // 设置原型链
TS.prototype.constructor = TS; // 修复构造函数指向
TS.prototype.sayLanguage = function () {
console.log("I code in " + this.language);
};
// 测试 ES 子类
const esInstance = new ES();
esInstance.sayHello(); // 输出 "Hello, I am Niyy"
esInstance.sayLanguage(); // 输出 "I code in JavaScript"
// 测试 TS 子类
const tsInstance = new TS();
tsInstance.sayHello(); // 输出 "Hello, I am Niyy"
tsInstance.sayLanguage(); // 输出 "I code in TypeScript"
2. Use una clase para definir una subclase:
class Niyy {
protected name: string;
constructor() {
this.name = "Niyy";
}
sayHello(): void {
console.log(`Hello, I am ${
this.name}`);
}
}
class ES extends Niyy {
private language: string;
constructor() {
super();
this.language = "JavaScript";
}
sayLanguage(): void {
console.log(`I code in ${
this.language}`);
}
}
class TS extends Niyy {
private language: string;
constructor() {
super();
this.language = "TypeScript";
}
sayLanguage(): void {
console.log(`I code in ${
this.language}`);
}
}
// 测试 ES 子类
const esInstance = new ES();
esInstance.sayHello(); // 输出 "Hello, I am Niyy"
esInstance.sayLanguage(); // 输出 "I code in JavaScript"
// 测试 TS 子类
const tsInstance = new TS();
tsInstance.sayHello(); // 输出 "Hello, I am Niyy"
tsInstance.sayLanguage(); // 输出 "I code in TypeScript"
Ya sea que use un objeto de función o una clase para definir una subclase, puede heredar las propiedades de la clase principal llamando al constructor ( o ) Niyy.call(this)de super()la clase principal, y heredar los métodos de la clase principal configurando la cadena prototipo y arreglando el puntero del constructor. Las subclases pueden agregar sus propias propiedades y métodos, y anular los métodos de la clase principal. En el ejemplo, tanto ESlas subclases como TSlas subclases se heredan de Niyyla clase principal y agregan sus respectivas propiedades y métodos de lenguaje.