La mise en œuvre de Génériques de l'Interface en Java

J'ai un Java génériques question j'espérais que quelqu'un pourrait répondre. Considérons le code suivant:

public interface Event{}
public class AddressChanged implements Event{}
public class AddressDiscarded implements Event{}

public interface Handles<T extends Event>{
    public void handle(T event);
}

Je veux mettre en œuvre cette Poignées interface comme ceci:

public class AddressHandler implements Handles<AddressChanged>, Handles<AddressDiscarded>{
    public void handle(AddressChanged e){}
    public void handle(AddressDiscarded e){}
}

Mais java n'autorise pas la mise en œuvre de Poignées à deux reprises avec le Générique. J'ai été en mesure d'accomplir ceci avec C#, mais n'arrivent pas à trouver une solution de contournement en java sans l'aide de la Réflexion ou instanceof et le moulage.

Est-il un moyen en java pour mettre en œuvre les Poignées de l'interface en utilisant à la fois des interfaces génériques? Ou peut-être une autre façon d'écrire les Poignées de l'interface de sorte que le résultat final peut être accompli?

InformationsquelleAutor whistlenuts | 2010-12-01

10

Vous ne pouvez pas le faire en Java. Vous ne pouvez mettre en œuvre une réalisation concrète de la même interface générique. Je voudrais faire ceci à la place:
```
public class AddressHandler implements Handles<Event>{
    public void handle(Event e){
      if(e instanceof AddressDiscarded){
         handleDiscarded(e);
      } else if(e instanceof AddressChanged){
         handleChanged(e);
      }
    }
    public void handleDiscarded(AddressDiscarded e){}
    public void handleChanged(AddressChanged e){}
}
```
- C'est discutable... Cette "instanceof cascade", est une procédure paragidm. Bien sûr qu'il fonctionne, mais à mon humble avis il n'est pas très bon style. Mais donc avoir différents noms de méthode ne peut pas être parfait non plus, c'est probablement une question de goût.
- C'est ce que je ferais. Vous ne devez pas 🙂
- -1: Vous pouvez implémenter plusieurs interfaces en Java.
- Pas plusieurs instances de la même interface générique si. C'est ce que nous parlons. 😛
- Avec cette précision, je rétracte mon downvote.
InformationsquelleAutor Amir Raminfar

Aller après @Amir Raminfar, vous pouvez utiliser visiteur modèle

interface Event{
 void accept(Visitor v);
}
interface Visitor {
 void visitAddressChanged(AddressChanged a);
 void visitAddressDiscarded(AddressDiscarded a);
}

class AddressChanged implements Event{
 @Override
 public void accept(Visitor v) {
  v.visitAddressChanged(this);
 } 
}

class AddressDiscarded implements Event{
 @Override
 public void accept(Visitor v) {
  v.visitAddressDiscarded(this);
 } 
}

class AddressHandler implements Visitor {
    void handle(Event e){
       e.accept(this);
     }
    public void visitAddressChanged(AddressChanged e){}
    public void visitAddressDiscarded(AddressDiscarded e){}
}

+1, mais dans le modèle, l'événement "accepter" le visiteur, et les visiteurs de la "visite" de l'événement 🙂
M, Merci. Fixe.
L'évènement e n'a pas de visiter()
J'ai oublié de le renommer dans cette ligne. Merci. Fixe.

InformationsquelleAutor Stan Kurilin

2

Non, parce que les différents "en béton" types génériques en Java compiler le même type. L'interface réelle de votre objet sera mise en œuvre:
```
public interface Handles {
    public void handle(Event event);
}
```
Et, évidemment, vous ne pouvez pas avoir deux différentes méthodes de même signature...
- En fait, l'effacement sera public void handle(Event event);
- Oh pinaise! Fixe.
- Qu'ai-je dans ma réponse 🙂
InformationsquelleAutor cdhowie
1

Autant que je sache, vous ne pouvez pas le faire, parce que lors de la compilation du code source en Java, ces deux bouillir jusqu'à handle(Event), ce qui rend la méthode ambigu.

Le générique de l'information n'est pas disponible lors de l'exécution de Java, contrairement à C#. C'est pourquoi il fonctionne comme vous le décrivez.

Vous aurez à changer les noms de méthode pour les rendre uniques, comme handleAddressChanged et handleAddressDiscarded.

C'est en effet l'un des points faibles de Java génériques.
- C'est vraiment un moment de la compilation question. Vous n'avez pas besoin de connaître les propriétés d'exécution des objets (l'argument pourrait même être null!) pour distinguer les méthodes.
InformationsquelleAutor Daniel Schneller
0

Malheureusement pas. La solution habituelle (gras, laid, rapide) est de créer un Handles de l'interface (c'est à dire HandlesAddressChange, HandlesAddressDiscarded) et de donner à chacun d'eux une méthode différente (handleAddressChange(...), handleAddressDiscarded()).

De cette façon, le Java runtime peut les distinguer.

Ou vous pouvez utiliser des classes anonymes.

InformationsquelleAutor Aaron Digulla

Il n'est pas autorisé parce que Java efface les signatures génériques lors de la compilation. La méthode de l'interface ont en fait la signature

public void handle(Object event);

Donc, vous avez deux choix. Soit mettre en œuvre des Gestionnaires distinct pour les différents événements:

public class AddressChangedHandler implements Handles<AddressChanged>{ /* ... */ }
public class AddressDiscardedHandler implements Handles<AddressDiscarded>{ /* ... */ }

ou de mettre en œuvre un traiteur pour tous, mais de vérifier le type de l'événement entrant:

public void handle(Event e){
  if (e instanceof AddressChanged) {
     handleAdressChanged(e);
  }
  else if (e instanceof AddressDiscareded) {
     handleAdressDiscarded(e);
  }
}

InformationsquelleAutor Andreas_D

0

Une mise en œuvre comme cela ne fonctionne pas en raison des contraintes de la spécification de java.
Mais si vous n'avez pas peur d'utiliser des AOP ou d'une sorte de CIO-Conteneur, vous pouvez utiliser les annotations pour que. Que vos Aspects ou le contenant pourrait gérer l'infrastructure de messagerie et d'appeler les méthodes que vous annoter.

Vous devez d'abord créer les annotations.
```
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
public @interface EventConsumer {}

@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface Handles{}
```
La vous pouvez annoter votre classe comme ça:
```
@EventConsumer
public class AddressHandler{
    @Handles
    public void handle(AddressChanged e){}
    @Handles
    public void handle(AddressDiscarded e){}
}
```
InformationsquelleAutor Olivier Heidemann

Vous devez vous connecter pour publier un commentaire.