Java: la substitution d'une sous-classe/sous-type d'un paramètre lors de l'overiding une méthode?

J'ai donc demandé à cette question avant, mais j'ai eu une erreur dans le code que la plupart des personnes ont ramassé sur, plutôt que le problème lui-même.

De toute façon, je suis en train de remplacer une méthode d'interface dans une classe. Cependant, je veux que le type du paramètre dans la méthode de remplacement d'une sous-classe du type du paramètre tel que défini dans la méthode surchargée.

L'interface est:

public interface Observer {
 public void update(ComponentUpdateEvent updateEvent) throws Exception;
}

Alors que la classe qui remplace cette méthode est:

public class ConsoleDrawer extends Drawer {

//...

 @Override
 public void update(ConsoleUpdateEvent updateEvent) throws Exception {
  if (this.componentType != updateEvent.getComponentType()) {
   throw new Exception("ComponentType Mismatch.");
  }
  else {
   messages = updateEvent.getComponentState(); 
  }
 }

//...

}

ConsoleUpdateEvent est une sous-classe de ComponentUpdateEvent.

Maintenant, je pourrais juste avoir la méthode update() dans ConsoleDrawer prendre un ComponentUpdateEvent en tant que paramètre et ensuite la convertir en une ConsoleUpdateEvent mais je suis à la recherche d'un peu plus élégant solution si possible. Anyhelp serait appréciée. Merci.

Je ne crois pas que ce soit possible car il va à l'encontre du principe d'une interface (c'est à dire les Classes qui implémentent une interface correspondent exactement à celles de toutes les signatures de méthode spécifiée par l'interface). Cependant, je vais regarder cette question, car je suis très curieux de voir si quelqu'un d'autre va me prouver le contraire.

OriginalL'auteur carnun | 2010-12-11

8

Vous ne pouvez pas. Ce n'est pas Eiffel. Le problème étant que vous pouvez utiliser l'interface d'appeler la méthode de mise en œuvre avec un type incompatible. De manière covariante paramètres ne sont pas autorisés. Contravariant les paramètres ne sont pas autorisées, soit, mais il est plus facile de fournir une surcharge. Covariante type de retour est autorisé (depuis 1.5).

Vous pourriez paramétrer l'interface:
```
public interface Observer<T extends ComponentEvent> {
    void update(T event) throws Exception;
}
```
Vous pouvez également utiliser un plus significatif de l'interface:
```
public interface ConsoleObserver {
    void update(ConsoleEvent event) throws Exception;
}
```
Trouvé réponse détaillée ici stackoverflow.com/a/9421315/1276636

OriginalL'auteur Tom Hawtin - tackline
2

Vous pouvez essayer la. Le @Deprecated produit un message d'avertissement si le compilateur sait, vous serez en appelant la méthode première plutôt que la seconde.
```
@Override @Deprecated
public void update(ComponentUpdateEvent updateEvent) {
    //throws a ClassCastException if its not the right type.
    update((ConsoleUpdateEvent) updateEvent); 
}

public void update(ConsoleUpdateEvent updateEvent) {
    messages = updateEvent.getComponentState(); 
}
```
BTW: Vous ne devriez pas simplement le lieu throws Exception sur tout. Son certainement pas la meilleure pratique.

EDIT: j'ai mis en place une autre solution à ce problème, qui fonctionne bien, avec OSGi, mais peut travailler n'importe où.

Un Observateur enregistre avec le Courtier s'attend à trouver des méthodes avec une annotation comme ObserverCallback.

par exemple
```
public class ConsoleDrawer extends Drawer {
 @ObserverCallback
 public void onConsoleUpdateEvent(ConsoleUpdateEvent updateEvent) {
   messages = updateEvent.getComponentState(); 
 }
}

public class DeviceDrawer extends Drawer {
 @ObserverCallback
 public void onDeviceUpdateEvent(DeviceUpdateEvent updateEvent) {
   //do something.
 }
}
```
Dans le premier cas, le courtier constate une méthode avec le @ObserverCallback qui prend un argument. C'est le seul type que le Courtier se chargera de le transmettre. La seconde classe s'attend à un type différent. Les observateurs peuvent avoir plusieurs méthode/types leur permettant de manipuler des messages différents dans les différentes méthodes adaptées à ce type. Vous savez aussi que vous ne recevrez jamais un type de données que vous ne vous attendez pas.

Personnellement, je (et beaucoup d'autres à qui j'ai parlé) l'aversion à l'aide de la balise Obsolète pour autre chose que l'intention originale: méthodes de marquage qui a utilisé pour être valide, mais sont désormais obsolète. De l'utiliser pour autre chose comme cela se sent hacker-ish.
La méthode utilisée pour être valide (pour les parents), mais n'est plus valide pour cette classe. 😉 Je prends votre point de si. Idéalement, il y aurait une balise qui a produit une erreur du compilateur. Encore mieux serait de la conception de la méthode update() de sorte que la mise en œuvre honoré le contrat.
Merci pour la suggestion. À l'aide de la première solution; j'ai renommé la deuxième méthode de mise à jour de private void addEventMessages(ConsoleUpdateEvent) {//...} et qui semble fonctionner raisonnablement bien.

OriginalL'auteur Peter Lawrey
2

En passant par la programmation orientée objet principes, une sous-classe doit être utilisable exactement de la même manière que la classe parent.
par exemple,
```
Observer ob = new ConsoleDrawer();
ob.update(new ComponentUpdateEvent()); //This needs to work always.
```
Toutefois, si Java ont été pour vous permettre d'utiliser un sous-type du paramètre lors du remplacement d'une méthode, alors il serait exposer votre code pour les cas où la méthode de remplacement (dans la sous-classe) de se faire rejeter le paramètre d'entrée (ComponentUpdateEvent dans le cas ci-dessus). Ainsi, vous ne serait jamais sûr de savoir si son coffre-fort pour appeler update() ou pas sur un Observateur de référence.

Par conséquent, la seule solution logique est d'accepter la classe parent paramètre, tapez-le vérifier et ensuite le jeter à la sous-type.

OriginalL'auteur user90766

Vous devez vous connecter pour publier un commentaire.