En Java, ¿cómo llamo al método de una clase base desde el método de anulación en una clase derivada?

Tengo dos clases de Java: B, que extiende otra clase A, como sigue:

class A {
    public void myMethod() { /* ... */ }
}

class B extends A {
    public void myMethod() { /* Another code */ }
}

Me gustaría llamar al A.myMethod()de B.myMethod(). Vengo del mundo de C ++ , y no sé cómo hacer esto en Java.

La palabra clave que estás buscando es super. Vea esta guía , por ejemplo.

Solo llámalo usando super.

public void myMethod()
{
    // B stuff
    super.myMethod();
    // B stuff
}

La respuesta es la siguiente:

super.Mymethod();
super();                // calls base class Superclass constructor.
super(parameter list);          // calls base class parameterized constructor.
super.method();         // calls base class method.

super.MyMethod()debe llamarse dentro MyMethod()de la class B. Entonces debería ser como sigue

class A {
    public void myMethod() { /* ... */ }
}

class B extends A {
    public void myMethod() { 
        super.MyMethod();
        /* Another code */ 
    }
}

llamar a super.myMethod ();

Estoy bastante seguro de que puede hacerlo utilizando el mecanismo de reflexión de Java. No es tan sencillo como usar super pero te da más poder.

class A
{
    public void myMethod()
    { /* ... */ }
}

class B extends A
{
    public void myMethod()
    {
        super.myMethod(); // calling parent method
    }
}

Usa la palabra clave super .

super.baseMethod(params);

llame a los métodos base con super palabra clave y pase los parámetros correspondientes.

class test
{
    void message()
    {
        System.out.println("super class");
    }
}

class demo extends test
{
    int z;
    demo(int y)
    {
        super.message();
        z=y;
        System.out.println("re:"+z);
    }
}
class free{
    public static void main(String ar[]){
        demo d=new demo(6);
    }
}

Vea, aquí está anulando uno de los métodos de la clase base, por lo tanto, si desea llamar al método de la clase base desde la clase heredada, entonces debe usar la palabra clave super en el mismo método de la clase heredada.

Si utiliza estos métodos para la inicialización, utilice los constructores de la clase A y pase la palabra clave super dentro del constructor de la clase B.

O si desea llamar a un método de superclase desde el método de subclase, entonces debe usar la palabra clave super dentro del método de subclase como: super.myMethod ();

// Using super keyword access parent class variable
class test {
    int is,xs;

    test(int i,int x) {
        is=i;
        xs=x;
        System.out.println("super class:");
    }
}

class demo extends test {
    int z;

    demo(int i,int x,int y) {
        super(i,x);
        z=y;
        System.out.println("re:"+is);
        System.out.println("re:"+xs);
        System.out.println("re:"+z);
    }
}

class free{
    public static void main(String ar[]){
        demo d=new demo(4,5,6);
    }
}