从typescript中的超类调用重写方法

Question

当我从超类构造函数调用重写方法时,我无法正确获取子类属性的值.

例

class A
{
    constructor()
    {
        this.MyvirtualMethod();
    }

    protected MyvirtualMethod(): void
    {

    }
}

class B extends A
{
    private testString: string = "Test String";

    public MyvirtualMethod(): void
    {
        alert(this.testString); // This becomes undefined
    }
}

我想知道如何正确覆盖typescript中的函数.

Answer 1

关键是使用super.methodName()调用父方法;

class A {
    // A protected method
    protected doStuff()
    {
        alert("Called from A");
    }

    // Expose the protected method as a public function
    public callDoStuff()
    {
        this.doStuff();
    }
}

class B extends A {

    // Override the protected method
    protected doStuff()
    {
        // If we want we can still explicitly call the initial method
        super.doStuff();
        alert("Called from B");
    }
}

var a = new A();
a.callDoStuff(); // Will only alert "Called from A"

var b = new B()
b.callDoStuff(); // Will alert "Called from A" then "Called from B"

在这里试试吧

Answer 2

执行顺序是:

1. A的构造函数
2. B的构造函数

在调用B构造函数之后,赋值发生在构造A函数中_super:

function B() {
    _super.apply(this, arguments);   // MyvirtualMethod called in here
    this.testString = "Test String"; // testString assigned here
}

所以发生以下情况:

var b = new B();     // undefined
b.MyvirtualMethod(); // "Test String"

您需要更改代码才能处理此问题.例如,通过调用this.MyvirtualMethod()中B的构造,通过创建一个工厂方法来创建对象,然后执行该功能,或通过将串入A的构造和工作了这一点莫名其妙......有很多的可能性.

Answer 3

如果您希望超类从子类调用函数,最简单的方法是定义抽象模式,以这种方式您明确知道该方法存在于某处并且必须由子类重写.

这是一个例子,通常你不会在构造函数中调用sub方法,因为子实例还没有被初始化...(你在问题的例子中有一个"未定义"的原因)

abstract class A {
    // The abstract method the subclass will have to call
    protected abstract doStuff():void;

    constructor(){
     alert("Super class A constructed, calling now 'doStuff'")
     this.doStuff();
    }
}

class B extends A{

    // Define here the abstract method
    protected doStuff()
    {
        alert("Submethod called");
    }
}

var b = new B();

在这里测试一下

如果像@Max一样,你真的想避免在任何地方实现抽象方法,只需摆脱它.我不推荐这种方法,因为你可能会忘记你重写方法.

abstract class A {
    constructor() {
        alert("Super class A constructed, calling now 'doStuff'")
        this.doStuff();
    }

    // The fallback method the subclass will call if not overridden
    protected doStuff(): void {
        alert("Default doStuff");
    };
}

class B extends A {
    // Override doStuff()
    protected doStuff() {
        alert("Submethod called");
    }
}

class C extends A {
    // No doStuff() overriding, fallback on A.doStuff()
}

var b = new B();
var c = new C();

在这里试试吧