Wie rufe ich in Java die Methode einer Basisklasse von der überschreibenden Methode in einer abgeleiteten Klasse auf?

Ich habe zwei Java-Klassen: B, die eine andere Klasse A wie folgt erweitert:

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

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

Ich möchte das A.myMethod()von anrufen B.myMethod(). Ich komme aus der C ++ - Welt und weiß nicht, wie ich diese grundlegende Sache in Java machen soll.

Das gesuchte Schlüsselwort ist super. Siehe zum Beispiel diese Anleitung .

Nennen Sie es einfach mit super.

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

Die Antwort lautet wie folgt:

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

super.MyMethod()sollte innerhalb MyMethod()der genannt werden class B. So sollte es sein

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

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

call super.myMethod ();

Ich bin mir ziemlich sicher, dass Sie dies mit dem Java Reflection-Mechanismus tun können. Es ist nicht so einfach wie die Verwendung von Super, aber es gibt Ihnen mehr Leistung.

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

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

Verwenden Sie das Super- Schlüsselwort.

super.baseMethod(params);

Rufen Sie die Basismethoden mit dem Schlüsselwort super auf und übergeben Sie die entsprechenden Parameter.

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

Sehen Sie, hier überschreiben Sie eine der Methoden der Basisklasse. Wenn Sie also die Basisklassenmethode von der geerbten Klasse aufrufen möchten, müssen Sie das Schlüsselwort super in derselben Methode der geerbten Klasse verwenden.

Wenn Sie diese Methoden zur Initialisierung verwenden, verwenden Sie Konstruktoren der Klasse A und übergeben Sie das Super-Schlüsselwort im Konstruktor der Klasse B.

Oder wenn Sie eine Methode der Superklasse aus der Unterklassenmethode aufrufen möchten, müssen Sie das Schlüsselwort super in der Unterklassenmethode verwenden, wie: 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);
    }
}