23 Modes de conception 20: modèle intermédiaire Java
Définition: encapsuler une série d'interactions d'objets avec un objet médiateur. Le médiateur fait que chaque objet interagit sans affichage, desservant ainsi le couplage et changeant indépendamment de l'interaction entre eux.
Type: modèle de comportement
Diagramme de classe:
La structure du modèle intermédiaire
Le mode intermédiaire est également appelé mode médiateur. Du diagramme de classe, il est divisé en 3 parties:
Résumé Médiateur: définissez l'interface entre les objets de classe de collègues et les objets médiateurs, et est utilisé pour la communication entre chaque classe de collègues. Généralement, il comprend une ou plusieurs méthodes d'événements abstraites et est implémentée par des sous-classes.
Classe de mise en œuvre intermédiaire: Hérité des médiateurs abstraits et met en œuvre des méthodes d'événements définies dans les médiateurs abstraits. Recevez des messages d'une classe de collègues, puis influentez d'autres classes simultanées via le message.
Classe de collègues: Si un objet affecte d'autres objets et est également affecté par d'autres objets, ces deux objets sont appelés classes de collègues. Dans le diagramme des classes, il n'y a qu'une seule classe de collègues, qui est en fait une omission de réalité. Dans les applications pratiques, la classe de collègues est généralement composée de multiples, et ils influencent et dépendent les uns des autres. Plus il y a de collègues, plus les relations sont compliquées. De plus, la classe de collègues peut également être représentée comme un ensemble d'implémentations héritant de la même classe abstraite. Dans le modèle intermédiaire, le message doit être transmis par des intermédiaires entre collègues.
Pourquoi utiliser le modèle intermédiaire
D'une manière générale, la relation entre les classes de collègues est relativement complexe. Lorsque plusieurs classes de collègues sont corrélées, leur relation apparaîtra comme une structure de maillage complexe. Il s'agit d'une architecture trop couplée, c'est-à-dire qu'elle n'est pas propice à la réutilisation de classe et n'est pas stable. Par exemple, dans la figure ci-dessous, il y a six objets de type collègue. Si l'objet 1 change, 4 objets seront affectés. Si l'objet 2 change, alors 5 objets seront affectés. En d'autres termes, la conception de la corrélation directe entre ses collègues n'est pas bonne.
Si le modèle intermédiaire est introduit, la relation entre les classes de collègues deviendra une structure star. D'après la figure, nous pouvons voir que les changements dans n'importe quelle classe ne affecteront que la classe elle-même et l'intermédiaire, ce qui réduira le couplage du système. Une bonne conception ne résumera certainement pas à toutes les logiques de traitement de l'objet-relation dans cette classe, mais utilisera une classe spéciale pour gérer les comportements qui ne vous appartiennent pas.
Utilisons un exemple pour illustrer ce qu'est une classe de collègues: il existe deux classes A et B, chacune ayant un nombre, et nous devons nous assurer que les nombres de la classe B sont toujours 100 fois les nombres de la classe A., c'est-à-dire, lors de la modification du nombre de classe B, en multipliant le nombre par 100 et en l'attribuant à la classe B, et lors de la modification de la classe B, divisez le nombre de 100 et attribuez-le à la classe A. Classe A et B Affect de chaque autre, donc ils sont appelés Collises et l'attribuent à la classe A. Classe A et B Le code est le suivant:
Résumé classe Abstractcolleague {Numéro INT protégé; public int getNumber () {Numéro de retour; } public void setNumber (int } // Méthode abstraite, modifiez l'objet associé en même temps lors de la modification des nombres publics abstract void setNumber (int, Abstractcolleague Coll); } class Colleaguea étend Abstractcolleague {public void setNumber (int number, abstractcolleague coll) {this.number = nombre; coll.setNumber (nombre * 100); }} classe CollègueB étend Abstractcolleague {public void setNumber (int n °, abstractcolleague coll) {this.number = nombre; coll.setNumber (nombre / 100); }} Client de classe publique {public static void main (String [] args) {Abstractcolleague colla = new Colleaguea (); Abstractcolleague CollB = New ColleagueB (); System.out.println ("========================================================= ============================================================================. ============================================================================. ===============================================================================. ============================================================================. ============================================================================. ============================================================================. ===============================================================================. System.out.println ("CollB's Number Value:" + CollB.getNumber ()); Dans le code ci-dessus, les classes A et B sont liées par association directe. Si nous voulons utiliser le modèle intermédiaire, les classes A et B ne peuvent pas être directement liées. Ils doivent utiliser un intermédiaire pour atteindre l'objectif d'association.
Résumé classe Abstractcolleague {Numéro INT protégé; public int getNumber () {Numéro de retour; } public void setNumber (int } // Notez que les paramètres ici ne sont plus des collègues, mais un SetNumber intermédiaire abstrait public public (numéro int, AbstractMediator AM); } classe Collègue étend Abstractcolleague {public void setNumber (int number, abstractmediator am) {this.number = nombre; am.aAffctB (); }} classe CollègueB étend Abstractcolleague {@Override public void setNumber (int numéro, AbstractMediator AM) {this.number = nombre; am.baffcta (); }} classe abstraite AbstractMediator {abstractcolleague protégé a; Abstractcolleague protégé B; Public AbstractMediator (Abstractcolleague A, Abstractcolleague b) {a = a; B = b; } public abstract void aAffecteb (); abstrait vide baffcta (); } class Mediator étend AbstractMediator {Médiateur public (Abstractcolleague A, Abstractcolleague b) {super (a, b); } // Gérer l'impact d'un sur B public void aAffctB () {int number = a.getNumber (); B.SetNumber (nombre * 100); } // gérer l'impact de B sur un vide public baffcta () {int A.SetNumber (nombre / 100); }} Client de classe publique {public static void main (String [] args) {Abstractcolleague colla = new Colleaguea (); Abstractcolleague CollB = New ColleagueB (); AbstractMediator AM = nouveau médiateur (colla, collb); System.out.println ("======================== Effet en définissant ======================================================================================================================. ======================================================================================================================. ======================================================================================================================. System.out.println ("La valeur du nombre de Colla est:" + colla.getNumber ()); B======================================================================================== ==================================================================================================================. =================================================================================================================. ==================================================================================================================. System.out.println ("La valeur du nombre de Coll est:" + collb.getNumber ());Bien que le code soit relativement long, il est toujours relativement facile à comprendre. En fait, il s'agit de reconditionner le code qui gère à l'origine les relations d'objets dans une classe de médiation et de gérer la relation entre les objets à travers cette classe de médiation.
Avantages du modèle intermédiaire
1. L'utilisation appropriée du modèle intermédiaire peut éviter un couplage excessif entre les classes de collègues, afin que chaque classe de collègues puisse être utilisée relativement indépendamment.
2. L'utilisation du modèle de médiateur peut transformer des relations un à plusieurs entre les objets en relations individuelles, ce qui rend les relations entre les objets faciles à comprendre et à maintenir.
3. L'utilisation du modèle intermédiaire peut abstraction du comportement et de la collaboration des objets, et peut gérer les interactions entre les objets de manière plus flexible.
Scénarios applicables
Dans la programmation orientée objet, une classe dépendra inévitablement d'autres classes, et les classes complètement indépendantes sont dénuées de sens. Il est également assez courant pour une classe de compter sur plusieurs classes en même temps. Puisqu'une telle situation existe, cela signifie que la dépendance un à plusieurs a sa rationalité. L'utilisation appropriée du modèle de médiateur peut rendre la relation d'objet initialement désordonnée claire, mais si elle est maltraitée, elle peut apporter des effets négatifs. D'une manière générale, le modèle de médiateur est considéré uniquement pour la relation entre les classes de collègues où il existe une structure de maillage. La structure du maillage peut être transformée en une structure étoilée pour rendre la relation entre ses collègues plus claire.
Le modèle intermédiaire est un modèle relativement courant et un modèle abusé relativement facile à être. Dans la plupart des cas, la relation entre les classes de collègues ne sera pas compliquée à une structure de maillage chaotique. Par conséquent, dans la plupart des cas, il est acceptable d'encapsuler les dépendances entre les objets au sein de la classe de collègues, et il n'est pas nécessaire d'introduire le modèle intermédiaire. L'abus du modèle intermédiaire ne fera que compliquer les choses.
Ce qui précède est tout le contenu de cet article. J'espère que cela sera utile à l'apprentissage de tous et j'espère que tout le monde soutiendra davantage Wulin.com.