oop - sirve - Llamar a un método reemplazado de super clase en mecanografiado

polimorfismo java

Question

Cuando invoco un método reemplazado del constructor de la clase superior, no puedo obtener correctamente el valor de una propiedad de clase secundaria.

ejemplo

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
    }
}

Me gustaría saber cómo sobrescribir correctamente las funciones en mecanografiado.

Answer 1

Si desea que una superclase invoque una función de una subclase, la forma más limpia es definir un patrón abstracto, de esta manera usted sabe explícitamente que el método existe en alguna parte y debe ser anulado por una subclase.

Esto es como un ejemplo, normalmente no se llama a un submétodo dentro del constructor ya que la instancia secundaria aún no se ha inicializado ... (por lo que tiene un "no definido" en el ejemplo de su pregunta)

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();

Pruébelo aquí

Y si, como @Max, realmente quieres evitar implementar el método abstracto en todas partes, solo deshazte de él. No recomiendo este enfoque porque es posible que olvide que está anulando el método.

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();

Pruébalo aquí

Answer 2

El orden de ejecución es:

1. A constructor de A
2. Constructor de B

La asignación se produce en el constructor de B después de que se haya llamado al constructor _super :

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

Entonces sucede lo siguiente:

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

Tendrá que cambiar su código para tratar con esto. Por ejemplo, llamando a this.MyvirtualMethod() en el constructor de B , creando un método de fábrica para crear el objeto y luego ejecutar la función, o pasando la cadena al constructor de A y resolviendo eso de alguna manera ... hay muchas posibilidades

Answer 3

La clave está llamando al método principal utilizando 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 explicitely call the initial method
        super.doStuff();
        alert("Called from B");
    }
}

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

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

Pruébalo aquí