Chiamare la funzione sovrascritta dalla class base dal metodo della class base

public class A { public void f1(String str) { System.out.println("A.f1(String)"); this.f1(1, str); } public void f1(int i, String str) { System.out.println("A.f1(int, String)"); } } public class B extends A { @Override public void f1(String str) { System.out.println("B.f1(String)"); super.f1(str); } @Override public void f1(int i, String str) { System.out.println("B.f1(int, String)"); super.f1(i, str); } } public class Main { public static void main(String[] args) { B b = new B(); b.f1("Hello"); } } 

Sto cercando che questo codice emetterebbe:

 B.f1(String) A.f1(String) A.f1(int, String) 

Eppure sto ricevendo:

 B.f1(String) A.f1(String) B.f1(int, String) A.f1(int, String) 

Capisco che nel contesto di B “questo” in A.f1 (String) è l’istanza di B. Ho la possibilità di fare la nuova catena B1 (). F1 (String) -> (A’s) f1 (String) -> (A’s) f1 (int, String)?

Questa è una domanda teorica, praticamente la soluzione sarebbe ovviamente in A per implementare una funzione privata che chiamerebbe f1 (String) e f1 (int, String).

Grazie,
Massima.

    Sfortunatamente no

    Sono sicuro che ne sei a conoscenza, ma ti indicherò esplicitamente per completezza – ci sono solo le 2 parole chiave per controllare il richiamo del metodo:

    • thisthis.method() – cerca il metodo a partire dalla class dell’istanza di this.method() la tabella virtuale “top” dell’istanza – default implicito)
    • supersuper.method() – cerca il metodo a partire dalla class genitrice della class in cui è definito il metodo di super.method() la tabella virtuale del genitore della class invocante – non strettamente vero , ma più semplice da pensare in questo modo – grazie @maaartinus )

    Posso immaginare un’altra parola chiave (es. Corrente?) Fare ciò che descrivi:

    • currentcurrent.method() – cerca il metodo a partire dalla class in cui è definito il metodo di richiamo

    ma Java non ha una tale parola chiave (ancora?).

    Ho paura, è imansible, ma c’è una soluzione semplice:

     public class A { public void f1(String str) { System.out.println("A.f1(String)"); privateF1(1, str); } private void privateF1(int i, String str) { System.out.println("A.f1(int, String)"); } public void f1(int i, String str) { privateF1(i, str); } } 

    I metodi sottoposti a override in Java sono vincolati dynamicmente. cioè il tipo dell’istanza reale dell’object determina ciò che verrà chiamato. metodi final (che non possono essere sovrascritti) e metodi private (che non possono essere ereditati) sono vincolati staticamente.

    In C ++, per contrasto, dovresti rendere esplicitamente le funzioni virtual per ottenere lo stesso comportamento.

     package main; public class A { public void f1(String str) { System.out.println("A.f1(String)"); if (this instanceof B) new A().f1(1, str); else this.f1(1, str); } public void f1(int i, String str) { System.out.println("A.f1(int, String)"); } } class B extends A { @Override public void f1(String str) { System.out.println("B.f1(String)"); super.f1(str); } @Override public void f1(int i, String str) { System.out.println("B.f1(int, String)"); super.f1(i, str); } public static void main(String[] args) { A a = new B(); a.f1("Hello"); } }