Apprivoiser le vérificateur de type dans Java Generics

Question

Je pensais avoir bien compris les génériques, mais apparemment je ne l'ai pas fait.

Voici le cas de test du problème:

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

Le compilateur ne permet pas la méthode de test1 ci-dessus, en disant que « Job » est pas dans ses limites de type. Je comprends un peu --- --- Job comme un type brut ne s'étend pas Job<Job,Run>, d'où l'erreur. En revanche, test3 fonctionne. Maintenant, la question est, comment puis-je faire ce travail? J'ai essayé # 2, mais cela ne fonctionne pas non plus. Le problème que je suppose est vraiment similaire aveC# 1 --- Job<Job,Run> n'est pas dans les limites parce que son argument de type Job est un type brut.

Est-ce que quelqu'un sait comment rendre le vérificateur de type heureux, autre que le recours au type brut? Ou est-ce simplement inaccessible dans le système de type Java?

Answer 1

Peut-être:

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

Answer 2

Si vous modifiez le paramètre de type à ArrayList vous pouvez ajouter de nouveaux Run();

Answer 3

Vous avez raison, je ne suis pas sûr de ce que je pensais là-bas! Votre commentaire m'a inspiré à réfléchir plus loin et je l'ai testé et la cause du problème a quelque chose à voir avec la définition récursive des variables de type Job<J extends Job<J..., mais je ne suis pas tout à fait clair pourquoi. Une solution, supprimez l'utilisation de J et R de vos définitions.

réponse plus longue:

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

    } 
}