Création de références génériques circulaires

Question

J'écris une application pour effectuer des calculs distribués dans un réseau pair-à-pair. En définissant le réseau, j'ai deux classes P2PNetwork et P2PClient. Je veux que ces génériques et ont donc les définitions de:

P2PNetwork<T extends P2PClient<? extends P2PNetwork<T>>> 

P2PClient<T extends P2PNetwork<? extends T>> 

avec P2PClient définir une méthode de setnetwork (réseau T). Ce que je suis l'espoir de décrire avec ce code est:

1. A P2PNetwork est constitué de clients d'un certain type
2. Un P2PClient ne peut appartenir à un réseau dont les clients se composent du même type que cette client (la circulaire de référence )

Cela semble correct pour moi, mais si je tente de créer une version non générique tel que

MyP2PClient<MyP2PNetwork<? extends MyP2PClient>> myClient; 

et d'autres variantes Je reçois de nombreuses erreurs du compilateur. Donc, mes questions sont les suivantes:

1. est une référence circulaire générique même possible (je ne l'ai jamais rien vu interdire explicitement)?
2. La définition générique ci-dessus est-elle la définition correcte d'une telle relation circulaire ?
3. Si elle est valide, est le « correct » façon de décrire une telle relation (à savoir est-il une autre valide définition, qui est stylistiquement préféré)?
4. Comment définir correctement une instance non générique d'un client et Server donné la bonne définition générique ?

Answer 1

Des références génériques circulaires sont en effet possibles. Java Generics and Collections inclut plusieurs exemples.Pour votre cas, un tel spécimen ressemblerait à ceci:

public interface P2PNetwork<N extends P2PNetwork<N, C>, 
          C extends P2PClient<N, C>> { 
    void addClient(C client); 
} 

public interface P2PClient<N extends P2PNetwork<N, C>, 
          C extends P2PClient<N, C>> { 
    void setNetwork(N network); 
} 

class TorrentNetwork implements P2PNetwork<TorrentNetwork, TorrentClient> { 
    @Override 
    public void addClient(TorrentClient client) { 
    ... 
    } 
} 

class TorrentClient implements P2PClient<TorrentNetwork, TorrentClient> { 
    @Override 
    public void setNetwork(TorrentNetwork network) { 
    ... 
    } 
} 

... 

TorrentNetwork network = new TorrentNetwork(); 
TorrentClient client = new TorrentClient(); 

network.addClient(client); 

Answer 2

Il nous est peut-être utile de vous répondre si vous avez défini ce que signifie "un certain type", c'est-à-dire quelles sont les différences entre différents "types" de réseaux P2P.

Mais au lieu d'exprimer la relation de dépendance/circulaire en termes de l'autre, il pourrait être plus facile d'exprimer en introduisant une troisième classe, le P2PType:

public class P2PNetwork<T extends P2PType> { 
    ... 
} 
public class P2PClient<T extends P2PType> { 
    ... 
    public void setNetwork(P2PNetwork<T> network) { ... } 
} 

je pourrais être sur quelque chose, mais je pense que ce permettrait au compilateur de faire en sorte que P2Plients fasse partie de P2PNetworks du même type générique. Cette approche peut cependant s'effondrer si le "type" n'est pas quelque chose qui peut s'exprimer comme un objet lui-même, ie si le P2PType n'est pas quelque chose qui aurait des méthodes, un comportement polymorphique, etc.