Inheritance 在TypeScript中继承初始化方法

有时我想在类被实例化并调用所有构造函数之后运行一些代码。为此，我在

构造函数

方法的最后一行调用

初始化

方法

这在使用继承时不起作用，因为将在调用最后一个

构造函数之前调用
initialize
方法。只需在所有继承的类中调用initialize函数，我们将得到多个调用

例子
结果

可能的解决办法
如果被调用的类等于传递给
构造的
方法的类，我找到了一种调用初始值设定项的方法。这样做的一个缺点是，为了调用initialize方法，必须始终调用构造的方法

class A {

    public get static() {
        return Object.getPrototypeOf(this).constructor;
    }
    
    constructor() {
        console.log('constructor A');
        this.constructed(A);
    }
    
    public constructed(type:any) {
        if (type === this.static) {
            this.initialize();
        }
    }
    
    public initialize() {
        console.log('initialize A');
    }
}

class B extends A {

    constructor() {
        super();
        console.log('constructor B');
        this.constructed(B);
    }
    
    public initialize() {
        console.log('initialize B');
    }
}

console.info('instantiate A');
var a = new A();

console.info('instantiate B');
var b = new B();

结果

问题:
在完成所有构造之后，有没有比上面的示例更好的方法来运行代码

我还想过：

var a = new A();
a.initialize();

但是我发现在很多情况下你根本不想这么做。
你可以使用create方法（）

如果initialize（）需要在B的构造函数之后运行，则A可能在某种程度上依赖于B的构造函数中发生的情况，因此继承可能已经“中断”。因此，在继承之外处理这个问题应该是恰当的

以下是一个例子：

class A {

    constructor() {
        console.log('constructor A');
    }

    public initialize() {
        console.log('initialize A');
    }

    static create<T>():T{
        var o =  <any>new this;
        o.initialize();
        return o;
    }
}

class B extends A {

    constructor() {
        super();
        console.log('constructor B');
    }

    public saySomething(){
        console.log('Woof!');
    }
}

var b:B = B.create<B>(); 
// "constructor A"
// "constructor B"
// "initialize A"
console.log( b instanceof A ); // true
b.saySomething(); // Woof!

A类{
构造函数（）{
log（'console.log'）；
}
公共初始化（）{
log（'initializea'）；
}
静态创建（）：T{
var o=新的本；
o、 初始化（）；
返回o；
}
}
B类扩展了A类{
构造函数（）{
超级（）；
console.log（'constructor B'）；
}
公共语言{
控制台日志（'Woof！'）；
}
}
变量b:b=b.create（）；
//“构造函数A”
//“构造函数B”
//“初始化文件”
console.log（b instanceof A）；//真的
b、 说点什么（）；//汪汪

class A {

    constructor() {
        console.log('constructor A');
    }

    public initialize() {
        console.log('initialize A');
    }

    static create<T>():T{
        var o =  <any>new this;
        o.initialize();
        return o;
    }
}

class B extends A {

    constructor() {
        super();
        console.log('constructor B');
    }

    public saySomething(){
        console.log('Woof!');
    }
}

var b:B = B.create<B>(); 
// "constructor A"
// "constructor B"
// "initialize A"
console.log( b instanceof A ); // true
b.saySomething(); // Woof!