Comment imposer une interface bidirectionnelle avec une interface Java?
Java n'autorise pas les méthodes privées ou protégées, alors comment s'assurer que les implémenteurs d'une interface bidirectionnelle appellent les méthodes nécessaires?
Disons que nous avons une interface IModelListener comme suit:
public interface IModelListener
{
public void handleChannelUpdate(int channel);
}
Ensuite, nous avons un client ViewControl comme suit:
public class ViewControl implements IModelListener
Les objets ViewControl vont fonctionner aussi longtemps que nous nous souvenons que ViewControl appelle ceci:
model.registerChannelListener(this);
Si Java autorisait les méthodes protégées ou privées dans une Interface, nous pourrions simplement modifier IModelListener à:
public interface IModelListener
{
public void handleChannelUpdate(int channel);
private void registerChannelListener( );
}
Comment cela peut-il être réalisé? Y a-t-il des annotations qui le feraient?
Java ne prend pas en charge l'héritage multiple, donc si les Clients/implémenteurs sont déjà une classe dérivée (typique), l'utilisation d'une classe abstraite n'est pas une option.
Merci d'avoir aidé, Jeff
6 answers
Vous manquez probablement le concept d'interfaces. Il ne peut pas contenir de méthodes privées ou protégées, car le rôle d'une interface est de fournir un ensemble de méthodes accessibles. Vous pourriez probablement, d'autre part, regarder des classes abstraites.
Ce dont vous avez besoin est probablement ceci:
public abstract class AbstractViewControler implements IModelListener {
protected abstract void registerChannelListener();
protected AbstractViewControler() {
this.registerChannelListener();
}
}
Puis:
public class MyViewControler extends AbstractViewControler {
protected void registerChanelListener() {
//- Do what you need here.
}
}
Et après cela juste:
IModelListener listner = new MyViewControler();
Une interface est un moyen de fournir un contrat public aux utilisateurs de la classe implémentant l'interface. La façon dont la classe est implémentée n'a pas d'importance, tant qu'ils adhèrent au contrat. Par conséquent, cela n'a pas de sens d'avoir des méthodes privées dans une interface.
Ce que vous voulez, c'est imposer un comportement par défaut sur votre classe - en Java, les classes abstraites sont l'endroit pour formuler le comportement par défaut hérité par toutes les classes d'extension (voir le modèle de conception de méthode de modèle pour une application de ceci). Les interfaces décrivent uniquement comment vos objets se comportent en externe et comment ils peuvent être utilisés par d'autres.
Interface en java destinée à fournir la signature de la fonctionnalité d'interface en moyen de signature que vous implémentez dans vos classes, elle ne devrait donc pas être privée.
Votre besoin: vous pouvez avoir une méthode abstraite avec certaines instructions par défaut que vous voulez.
Où vous pouvez spécifier tous les types d'accès.
En Java, vous ne pouvez pas le faire en utilisant une interface uniquement.
Si vous voulez réaliser une sorte d ' "autobinding" (c'est-à-dire appeler automatiquement model.registerChannelListener(this); sur tous les objets pertinents), alors vous devriez avoir ces objets implémenter une interface vide, récupérer la liste de toutes les instances de classes l'implémentant via introspection et itérer dessus.
Vous pouvez le faire périodiquement ou à un moment spécifique du programme. Vous pouvez également utiliser une annotation @ interface pour ajouter un peu syntaxe de sucre.
Vous pouvez également inverser le flux et créer des objets en utilisant l'injection de dépendances et/ou une usine, de sorte que vous ayez cette méthode appelée "automagiquement" juste après la création (comme avec @PostConstruct).
Les interfaces sont le mauvais endroit pour regarder.
La solution habituelle en Java pour des problèmes comme celui-ci est d'avoir une méthode dans l'un ou l'autre objet qui renvoie l'autre:
public class ViewControl {
public IModel getModel() {...}
}
La méthode peut alors s'assurer que le modèle et la vue sont correctement connectés. Maintenant, je suppose que vous ne voulez pas vraiment coupler la vue et le modèle. La solution consiste alors à définir un nouveau type ViewModel qui délègue simplement au modèle réel (la plupart desEs permettent de créer des types de délégués avec 3-5 souris clics):
public class ViewControl {
public ViewModel getViewModel( IModel model ) {...}
}
Vous devriez pouvoir déplacer ce code vers une classe de vue de base (abstract) dont toutes les vues héritent.