In Java, come posso chiamare il metodo di una classe base dal metodo prioritario in una classe derivata?

Ho due classi Java: B, che estende un'altra classe A, come segue:

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

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

Vorrei chiamare il A.myMethod()da B.myMethod(). Vengo dal mondo C ++ e non so come fare questa cosa di base in Java.

La parola chiave che stai cercando è super. Vedi questa guida , per esempio.

Basta chiamarlo usando super.

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

La risposta è la seguente:

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

super.MyMethod()dovrebbe essere chiamato all'interno MyMethod()del class B. Quindi dovrebbe essere il seguente

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

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

chiama super.myMethod ();

Sono abbastanza sicuro che puoi farlo usando il meccanismo Java Reflection. Non è così semplice come usare super ma ti dà più potenza.

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

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

Usa la parola chiave super .

super.baseMethod(params);

chiama i metodi di base con la parola chiave super e passa i rispettivi parametri.

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

Vedi, qui stai sovrascrivendo uno dei metodi della classe base, quindi se ti piace chiamare il metodo della classe base dalla classe ereditata, allora devi usare la super parola chiave nello stesso metodo della classe ereditata.

Se stai usando questi metodi per l'inizializzazione, usa i costruttori di classe A e passa la parola chiave super all'interno del costruttore di classe B.

Oppure, se si desidera chiamare un metodo di superclasse dal metodo della sottoclasse, è necessario utilizzare la parola chiave super all'interno del metodo della sottoclasse come: 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);
    }
}