Métodos sobrecargados prioridad

Question

Tengo una clase base llamada Element. Algunas otras clases (como Etiqueta e Imagen) extienden esta clase.

ahora tengo una clase de despacho que tiene los siguientes métodos:

public class Dispatcher { 
    public static AbstractPropertyEditor<Label> createEditor(Label e) { 
    ... 
    } 

    public static AbstractPropertyEditor<Element> createEditor(Element e) { 
    ... 
    } 
} 

Si ahora tengo una instancia de etiqueta (que se extiende Element) y quiero pasarlo a createEditor(), ¿por qué es el método más genérico (el segundo) llamado? ¿No sería normal que se llame al método más específico (createEditor(Label e))?

que tienen una necesidad imperiosa el método con el Elemento-param el fin de "atrapar" todas aquellas clases que a) poner en práctica elemento, pero no tienen su propio método específico en esta clase de despacho ..

estoy usando Java 6, ¿cómo "arreglar" esto?

Edit: De acuerdo, tengo que admitir que no es para nada genérico. Pero ahí es donde lo encontré la primera vez.

gracias y saludos

Answer 1

¿Por qué no:

• hacen Element clase abstracta que proporciona un defecto createEditor() aplicación
• maquillaje Label anular el createEditor().

Por lo tanto, no necesitará las utilidades estáticas y logrará su objetivo.

Si necesita Element a ser una interfaz, entonces:

• definen createEditor() como métodos de Element
• definir una interfaz EditorFactory
• proporcionan DefaultEditorFactory y ListEditorFactory

• utilizar las fábricas apropiadas en los implementadores de Element:

  public Editor createEditor() { 
      editorFactory.createEditor(this); 
  } 
  

donde el hormigón se crea una instancia EditorFactory bien durante la inicialización o por medio de algún tipo de dependecy-inyección.

---

Según su pregunta concreta, depende del tipo que haya compilado allí. Si llama createEditor(obj) que dependerá si se trata de Element obj = .. o Label obj = ..

Answer 2

Dado que es probable que esté haciendo:

Element element = new Label(); 

se determina por el compilador.

Answer 3

Esto realmente tiene poco que ver con los genéricos y todo lo relacionado con la sobrecarga de métodos. En Java, la firma de método llamada se determina en tiempo de compilación, no en tiempo de ejecución, por lo que debe verificar y emitir en tiempo de ejecución.

Así sustituir este:

Element label = getLabel(); 
AbstractPropertyEditor<?> editor = createEditor(label); 

Con esta:

Element label = getLabel(); 
AbtractPropertyEditor<?> editor; 
if(label instanceof Label) { 
     editor = createEditor((Label) label); 
} else { 
     editor = createEditor(label); 
} 

La forma en sí (más estándar/mejor) para solucionar este problema es tener la createEditor método (Elemento) comprobar el tipo y llamar con un molde el método sobrecargado correcto para subtipos. Sin embargo, tendrá un problema con los parámetros de retorno si lo hace en los métodos declarados.

Answer 4

Desde el Java Language Specification:

Cuando se invoca un método (§15.12), el número de argumentos reales (y cualquier argumentos de tipo explícitas) y los tipos de tiempo de compilación de los argumentos se usan, en el tiempo de compilación, a determinan la firma del método que se invocará (§15.12.2). Si el método que ha de ser invocado es un método ejemplo, el método real para ser invocada será determinado durante la ejecución tiempo, utilizando el método dinámico de búsqueda (§15.12.4).

Answer 5

Este es un ejemplo de métodos sobrecargados. Aunque el objeto real en tiempo de ejecución es una etiqueta y no un elemento, la opción de sobrecargar el método para llamar (en otras palabras, la firma del método ) NO se decide dinámicamente en el tiempo de ejecución. El tipo de referencia (no el tipo de objeto) determina qué método sobrecargado se invoca.

Ejemplo

public class Car {  
} 

public class Toyota extends Car {  
} 

public class MyCar { 

    public void run(Car c) { 
     System.out.println("Run any Car"); 
    } 

    public void run(Toyota t) { 
     System.out.println("Run Toyota Car"); 
    } 

    public static void main(String[] args) { 
     MyCar myCar = new MyCar(); 

     Car c1 = new Car(); 
     myCar.run(c1); // Output: Run any Car 

     Toyota c2 = new Toyota(); 
     myCar.run(c2); // Output: Run Toyota Car 

     Car c3 = new Toyota(); 
     myCar.run(c3); // Output: Run any Car  
    } 
} 

Así, en su caso

Element obj1 = new Label(); 
Dispatcher.createEditor(obj); // Method with Element argument is called 
           // as you are passing Element 

Label obj2 = new Label(); 
Dispatcher.createEditor(obj); // Method with Label argument is called 
           // as you are passing Label 

En otra nota, reemplazado invocación de métodos que sucede en tiempo de ejecución y que depende del tipo de objeto (en otras palabras, el tipo de instancia real en el montón)