举例子描述TypeScript中的方法重写 ?

八股文_TypeScript面试题 0 76

参考回答

在 TypeScript 中，方法重写是指在子类中重新定义继承自父类的方法，从而改变该方法的实现。重写方法时，子类的方法签名必须与父类中被重写的方法签名保持一致。方法重写允许我们根据子类的需求修改父类的行为。

下面是一个 TypeScript 中方法重写的例子：

class Animal {
  speak(): void {
    console.log("Animal speaks");
  }
}

class Dog extends Animal {
  // 重写父类的 speak 方法
  speak(): void {
    console.log("Dog barks");
  }
}

const dog = new Dog();
dog.speak();  // 输出: Dog barks

在这个例子中，Dog 类继承自 Animal 类，并重写了 speak 方法，使得 Dog 类中的 speak 方法的行为与 Animal 类中的 speak 方法不同。

详细讲解与拓展

方法重写的基础

继承与方法重写：方法重写通常发生在子类中，子类继承父类的属性和方法，并可以根据需要重写某些方法以实现不同的功能。方法的签名（即方法的名称、参数类型、返回类型等）需要与父类中定义的方法保持一致。
类型兼容：在 TypeScript 中，重写方法时，子类的方法必须与父类中的方法签名保持一致，包括参数类型和返回类型。如果子类的方法签名与父类不一致，TypeScript 会报错。

方法重写的例子

假设我们有一个基类 Shape，它有一个 area 方法用来计算形状的面积，我们希望在不同的子类中重写这个方法。

class Shape {
 area(): number {
   return 0;
 }
}

class Circle extends Shape {
 radius: number;

 constructor(radius: number) {
   super();
   this.radius = radius;
 }

 // 重写 area 方法
 area(): number {
   return Math.PI * this.radius * this.radius;
 }
}

class Rectangle extends Shape {
 width: number;
 height: number;

 constructor(width: number, height: number) {
   super();
   this.width = width;
   this.height = height;
 }

 // 重写 area 方法
 area(): number {
   return this.width * this.height;
 }
}

const circle = new Circle(5);
console.log(circle.area()); // 输出: 78.53981633974483

const rectangle = new Rectangle(4, 6);
console.log(rectangle.area()); // 输出: 24

在这个例子中，Circle 和 Rectangle 类都重写了从 Shape 类继承来的 area 方法。每个子类根据自己的需求实现了不同的面积计算方式。

方法重写的规则

签名一致：子类重写的方法签名必须与父类中被重写的方法签名一致。包括方法的名称、参数类型、返回类型等。
访问修饰符：父类和子类中重写的方法可以使用不同的访问修饰符（如 public、protected、private）。通常，子类重写的方法的访问修饰符需要与父类的方法保持一致，或者范围更宽松。例如，父类的 private 方法不能被子类重写，而 protected 或 public 方法可以。

方法重写与 super 关键字

在子类中重写父类的方法时，如果需要在子类方法中调用父类的原始方法，可以使用 super 关键字来访问父类的方法。
```
class Animal {
 speak(): void {
   console.log("Animal speaks");
 }
}

class Dog extends Animal {
 speak(): void {
   super.speak();  // 调用父类的 speak 方法
   console.log("Dog barks");
 }
}

const dog = new Dog();
dog.speak();  // 输出: Animal speaks
             //         Dog barks
```
在这个例子中，Dog 类重写了 speak 方法，但首先调用了 super.speak() 来执行父类的 speak 方法，然后再执行自己定义的逻辑。
抽象类与方法重写

在 TypeScript 中，如果父类是一个抽象类，且定义了抽象方法，那么子类必须重写这些抽象方法。抽象类和抽象方法的使用强制要求子类提供具体的实现。
```
abstract class Animal {
 abstract speak(): void;  // 抽象方法，没有实现
}

class Dog extends Animal {
 speak(): void {
   console.log("Dog barks");
 }
}

const dog = new Dog();
dog.speak();  // 输出: Dog barks
```
在上面的例子中，Animal 是一个抽象类，定义了一个抽象方法 speak。Dog 类继承了 Animal 并重写了 speak 方法，提供了具体的实现。

总结

方法重写是面向对象编程中的一种重要特性，它允许子类改变或扩展父类方法的实现。通过方法重写，子类能够根据自己的需求提供不同的行为实现。在 TypeScript 中，重写方法时需要确保方法签名一致，并可以通过 super 关键字调用父类的方法。对于抽象类，子类必须实现抽象方法。方法重写是实现多态性的重要机制，能够让不同的子类在继承父类的基础上提供独特的功能。

参考回答

详细讲解与拓展

总结

发表评论 取消回复

发表评论取消回复