Domando el verificador de tipos en Java Generics

Question

Pensé que entendía genéricos bastante bien, pero al parecer no lo hice.

Aquí es el caso de la prueba del problema:

import java.util.ArrayList; 

class Job<J extends Job<J,R>, R extends Run<J,R>> {} 
class Run<J extends Job<J,R>, R extends Run<J,R>> {} 

class Job2 extends Job<Job2,Run2> {} 
class Run2 extends Run<Job2,Run2> {} 

class RunList<J extends Job<J,R>, R extends Run<J,R>> extends ArrayList<R> {} 

class Foo { 
    // #1 problem 
    public void test1(RunList<Job,Run> why) {} 
    // #2 this doesn't work either 
    public void test2(RunList<Job<Job,Run>,Run<Job,Run>> why) {} 
    // #3 this works 
    public void test3(RunList<Job2,Run2> why) {} 
} 

El compilador no permite el método test1 anterior, diciendo que "trabajo" no está dentro de sus límites tipo. De alguna manera lo entiendo --- Job como un tipo sin formato no se extiende Job<Job,Run>, de ahí el error. Por el contrario, test3 funciona.

Ahora, la pregunta es, ¿cómo hago que esto funcione? He intentado # 2, pero eso tampoco funciona. El problema que supongo que es realmente similar con # 1 --- Job<Job,Run> no está dentro de los límites porque su argumento de tipo Job es un tipo sin formato.

¿Alguien sabe cómo hacer feliz al verificador de tipos, además de recurrir al tipo sin procesar? ¿O simplemente no es alcanzable en el sistema de tipo Java?

Answer 1

Tal vez:

public <J extends Job<J, R>, R extends Run<J, R>> void test(RunList<J, R> why) {} 

Answer 2

Si cambia el parámetro de tipo ArrayList a continuación, puede agregar nueva Run();

Answer 3

¡Tienes razón, no estoy seguro de lo que estaba pensando allí! Tu comentario me inspiró a pensarlo un poco más y lo probé y la causa del problema tiene algo que ver con la definición recursiva de las variables de tipo Job<J extends Job<J..., pero no estoy del todo claro por qué. Una solución, elimine el 'uso' de J y R de sus definiciones. respuesta

más larga:

import java.util.ArrayList; 

class Job<J extends Job, R extends Run> {} 
class Run<J extends Job, R extends Run> {} 

class Job2 extends Job<Job2,Run2> {} 
class Run2 extends Run<Job2,Run2> {} 

class RunList<J extends Job, R extends Run> extends ArrayList<R> {} 

class Foo { 
    // #1 works now 
    public void test1(RunList<Job,Run> why) {} 
    // #2 works now too 
    public void test2(RunList<Job<Job,Run>,Run<Job,Run>> why) {} 
    // #3 still works 
    public void test3(RunList<Job2,Run2> why) {} 
    // #4 generic method 
    public <J extends Job, R extends Run> void test4(RunList<J,R> why) {} 

    public static void main(String[] args) { 
     // Calling them even works... 
     new Foo().test1(new RunList<Job,Run>()); 
     new Foo().test2(new RunList<Job<Job,Run>,Run<Job,Run>>()); 

     // Calling the generic method works too 
     new Foo().test4(new RunList<Job,Run>()); 
     new Foo().test4(new RunList<Job<Job,Run>,Run<Job,Run>>()); 
     new Foo().test4(new RunList<Job2,Run2>()); 

     // ...sort of 

     // This doesn't work 
     //new Foo().test1(new RunList<Job<Job,Run>,Run<Job,Run>>()); 

     // This doesn't work 
     //new Foo().test1(new RunList<Job2,Run2>()); 

    } 
}