Em Java, como chamo o método de uma classe base do método de substituição em uma classe derivada?

Eu tenho duas classes Java: B, que estende outra classe A, da seguinte maneira:

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

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

Gostaria de chamar a A.myMethod()partir B.myMethod(). Eu sou do mundo C ++ e não sei como fazer isso em Java.

A palavra-chave que você está procurando é super. Veja este guia , por exemplo.

Basta chamá-lo usando super.

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

A resposta é a seguinte:

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

super.MyMethod()deve ser chamado dentro MyMethod()do class B. Portanto, deve ser o seguinte

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

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

chame super.myMethod ();

Tenho certeza de que você pode fazer isso usando o mecanismo Java Reflection. Não é tão simples quanto usar super, mas oferece mais poder.

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

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

Use a super palavra - chave.

super.baseMethod(params);

chame os métodos base com super palavra - chave e passe os respectivos parâmetros.

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

Veja, aqui você está substituindo um dos métodos da classe base; portanto, se você quiser chamar o método da classe base da classe herdada, precisará usar a super palavra - chave no mesmo método da classe herdada.

Se você estiver usando esses métodos para inicialização, use construtores da classe A e passe uma super palavra-chave dentro do construtor da classe B.

Ou, se você quiser chamar um método de superclasse a partir do método da subclasse, precisará usar a super palavra-chave dentro do método da subclasse 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);
    }
}