clase base de la función anulada método de clase base

Question

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

Estoy en busca de que este código de salida:

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

Sin embargo, yo estoy consiguiendo:

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

entiendo que bajo la contexto de B "esto" en A.f1 (Cadena) es la instancia de B. ¿Tengo la opción de hacer la cadena nueva B1(). F1 (Cadena) -> (A) f1 (Cadena) -> (A) f1 (int, Cadena)?

Esta es una pregunta teórica, prácticamente la solución sería, obviamente, en A implementar una función privada que llamarían f1 (String) y f1 (int, String).

Gracias,
Maxim.

Answer 1

Desafortunadamente, ninguna

Como estoy seguro de que está consciente, pero lo declarar explícitamente que está completo: solo hay 2 palabras clave para controlar la invocación al método:

• este - - ve para el método a partir de la clase de la instancia invocando (tabla virtual "top" de la instancia - por defecto implícita)
• súper-super.method() - ve para el método a partir de la clase padre de la clase en la que el invocando el método está definido (la clase de invocación mesa virtual de padres - not strictly true, pero más simple de pensar de esta manera - gracias @maaartinus)

me puedo imaginar otra palabra clave (por ejemplo, ? Actual) hace lo que usted describe:

• actual - current.method() - ve para el método a partir de la clase en la que está definido el método de invocación

pero Java no tienen una palabra clave (¿todavía?).

Answer 2

Los métodos reemplazados en Java están vinculados dinámicamente. es decir, el tipo de instancia real del objeto dicta cómo se llamará. final métodos (que no pueden ser reemplazados) y private métodos (que no pueden ser heredados) están vinculados estáticamente.

En C++, por el contrario, tendría que hacer explícitamente las funciones virtual para obtener el mismo comportamiento.

Answer 3

me temo, es imposible, pero hay una solución simple:

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

Answer 4

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