Question

有这样的类层次结构：

class A {
  constructor (obj) {
    this.obj = obj
  }
}

class B extends A {

  static createObj () { 
    return {from: 'B'};
  }

  constructor () {
    const obj = B.createObj();
    super(obj);
  }
}

我想这样扩展：

class C extends B {
  static createObj () {
    return { from: 'C' };
  }
}

//such that:
console.log(new C().obj.from) // 'C'

但，因此我需要将const obj = B.createObj()更改为类似的内容：const obj = Object.getPrototypeOf(this).constructor.createObj();，引发此错误：

 ReferenceError: Must call super constructor in derived class before accessing 'this' or returning from derived constructor

因此，基本上，我想重写一个方法，该方法创建在super()调用中使用的对象。由于在此之前无法使用this，因此我选择使用静态方法。有什么方法可以引用静态方法，而无需使用此方法，也不必覆盖构造函数？

Answer 1

如果出于某种原因，您真的希望仅在A类中仅完成{strong> {strong} ，那么我会这样做：

this.obj=obj

输出：

class A {
    constructor(obj) {
        this.obj = obj
    }
}

class B extends A {
    static createObj() {
        return { from: 'B' };
    }
    constructor(obj) {
        if (!obj) obj = B.createObj();
        super(obj);
    }
}

class C extends B {
    static createObj() {
        return { from: 'C' };
    }
    constructor(obj) {
        if (!obj) obj = C.createObj();
        super(obj);
    }
}

console.log(new C().obj.from)

但是我认为最好的OOP方法是：

"C"

输出：

class A {
    constructor(obj) {
        this.obj = obj
    }
}

class B extends A {
    static createObj() {
        return { from: 'B' };
    }
    constructor(obj) {
        super(obj);
        this.obj = B.createObj();
    }
}

class C extends B {
    static createObj() {
        return { from: 'C' };
    }
    constructor(obj) {
        super(obj);
        this.obj = C.createObj();
    }
}
console.log(new C().obj.from)

第二种方法允许满足可以防止错误的“在执行任何其他操作之前先调用超级”模式。

由您决定哪个更适合您的需求，但是两个都打印“ C”而不需要"C"

在使用»super«之前，请先访问静态方法

1 个答案: