Java: tipo de retorno polimórfico en un método abstracto?

Question

Tengo el siguiente código en una clase abstracta java:

protected abstract <E extends HasText & IsWidget> E createNewDisplayWidget(); 

que compila bien. Sin embargo, si la llamo en cualquier lugar, el compilador se queja:

Bound mismatch: The generic method createNewDisplayWidget() of type DemoClass is not applicable for the arguments(). The inferred type HasText is not a valid substitute for the bounded parameter <E extends HasText & IsWidget> 

¿Hay una manera de exigir un método abstracto para devolver algo que se debe implementar múltiples interfaces?

Nota: No, no puedo crear una interfaz especial que implemente las dos que me gustan. GWT tiene widgets como Label que ya implementan dichas interfaces y me gustaría usar dicho widget.

Editar: me ocurrió la idea de hacer esto de aquí (página 22):

http://java.sun.com/j2se/1.5/pdf/generics-tutorial.pdf

Answer 1

El problema estaba en Eclipse. Actualicé de 3.7 a 3.7.2 y el error del compilador desapareció.

No sé los detalles del efecto que esto tenía. Si alguien tiene una pista, no dude en actualizar mi respuesta.

Answer 2

me han dado una oportunidad sobre la base de su pregunta y yo era capaz de conseguir a través sin un error . Por favor revisa las clases que he creado.

TestClass

public abstract class TestClass { 

    protected abstract <E extends HasText & IsWidget > E createNewDisplayWidget(); 

} 

clase HasText

public class HasText { 

} 

IsWidget

public interface IsWidget { 

} 

DemoClass

public class DemoClass extends HasText implements IsWidget{ 

    } 

TestClass1

public class TestClass1 extends TestClass{ 

    @Override 
    protected DemoClass createNewDisplayWidget() { 
     // TODO Auto-generated method stub 
     DemoClass type = new DemoClass(); 
     return type; 
    } 

    public void checkOut(){ 
     if(createNewDisplayWidget() instanceof HasText || createNewDisplayWidget() instanceof IsWidget){ 
      System.out.println("Yes it works"); 
     } 
     else{ 
      System.out.println("It doesnt"); 
     } 
    } 

    public static void main(String[] args){ 
     TestClass1 check = new TestClass1(); 
     check.checkOut(); 

    } 

} 

cuando corro mi programa principal que siempre sale "Sí funciona". Por favor, avíseme si me falta algo.

Answer 3

Lo que se quiere hacer es sólo posible si Java soporta tipo de interceptación directa, entonces puede simplemente

HasText&IsWidget createNewDisplayWidget(); 

cualquier aplicación debe devolver un objeto que es un subtipo del tipo HasText&IsWidget; en otras palabras, el tipo devuelto debe ser un subtipo de HasText y IsWidget

Desafortunadamente, Java no es compatible con eso.

El problema de su intento de solución se puede entender a partir de dos ángulos:

1) limitaciones de una variable de tipo son limitaciones de la persona que llama; el que llama proporciona el argumento de tipo real y debe cumplir las restricciones. Lo que realmente quieres es restricciones para el destinatario.

2) si una variable de tipo solo aparece en el tipo de devolución, pero no en los tipos de parámetros del método, es generalmente un signo de problema.En Java, debido al mal tipo borrado, el cuerpo del método no puede conocer el argumento de tipo en tiempo de ejecución, por lo tanto, no puede devolver un valor del tipo apropiado deseado por la persona que llama, a excepción de algunos valores triviales como null; otro ejemplo clásico del valor de retorno es trivial

java.util.Collections 
    <T> Set<T> emptySet() 

Answer 4

Así que he intentado hacer el código completo para generar el error, pero por alguna razón no dio un error. Se verá en ella un poco:

import java.util.LinkedList; 

public abstract class DemoClass { 

    public static void main(String[] args) { 
     DemoClass dc = new DemoClassImpl(); 
     dc.createNewLivingAndDying().live(); 
     dc.killAll(); 
    } 

    LinkedList<Dies> dying = new LinkedList<Dies>(); 

    public Lives createNewLivingAndDying() { 
     Lives ab = newLivingAndDying(); // This is where I expected an error 
     dying.add((Dies) ab); 
     return ab; 
    } 

    public void killAll() { 
     for (Dies dead : dying) 
      dead.die(); 
    } 

    protected abstract <E extends Lives & Dies> E newLivingAndDying(); 

} 

class DemoClassImpl extends DemoClass { 

    @SuppressWarnings("unchecked") 
    @Override 
    protected <E extends Lives & Dies> E newLivingAndDying() { 
     return (E) new SomePrivateClass(); // This is what I don't understand 
    } 

} 

interface Lives { 
    public void live(); 
}; 

interface Dies { 
    public void die(); 
}; 

class SomePrivateClass implements Lives, Dies { 

    @Override 
    public void die() { 
     System.out.println("Object Dies"); 
    } 

    @Override 
    public void live() { 
     System.out.println("Object Lives"); 
    } 
} 

Este código se compila y funciona muy bien en mi ordenador personal, pero dador el error en mi equipo de trabajo.

Bound mismatch: The generic method newLivingAndDying() of type DemoClass is not applicable for the arguments(). The inferred type Lives is not a valid substitute for the bounded parameter <E extends Lives & Dies> 

En este momento, creo que es un problema de configuración del proyecto, pero no sé lo que es. JRE 1.6 ambos.