Présentation des 23 modèles de conception Java et des 6 principes majeurs des modèles de conception

Analyse de 23 modèles de conception en Java

1 Aperçu des modèles de conception

En général, les modèles de conception sont divisés en trois catégories. :

Il existe cinq modèles créatifs : le modèle de méthode d'usine, le modèle d'usine abstrait, le modèle singleton, le modèle de constructeur et le modèle de prototype.

Il existe sept modes structurels : le mode adaptateur, le mode décorateur, le mode proxy, le mode apparence, le mode pont, le mode combinaison et le mode poids mouche.

Modèles comportementaux, onze au total : modèle de stratégie, modèle de méthode modèle, modèle d'observateur, sous-modèle itératif, modèle de chaîne de responsabilité, modèle de commande, modèle de mémo, modèle d'état, modèle de visiteur, modèle intermédiaire, mode interprète.

Les spécificités sont les suivantes :

Les types de création sont :

1 Singleton, mode singleton : s'assurer qu'une classe n'a qu'une seule instance et fournir une. méthode d'accès à celui-ci Accès global

point

2. Abstract Factory : Fournit une interface pour créer une série d'objets liés ou interdépendants,

sans préciser leurs classes concrètes.

3. Méthode Factory : définissez une interface pour créer des objets et laissez les sous-classes décider quelle classe instancier. La méthode Factory retarde l'instanciation d'une classe jusqu'à ce que la sous-classe soit créée.

4. Constructeur, mode construction : sépare la construction d'un objet complexe de sa représentation, afin qu'un même processus de construction puisse créer différentes représentations.

5. Prototype, mode prototype : Utilisez des instances de prototype pour spécifier les types d'objets à créer, et créez de nouveaux objets en copiant ces prototypes.

Les types comportementaux sont :

6. Itérateur, mode itérateur : Fournit une méthode pour accéder séquentiellement à chaque élément d'un objet agrégé sans exposer la représentation interne de l'objet.

7. Observateur, modèle d'observateur : définissez des dépendances un à plusieurs entre les objets lorsque l'état d'un objet change, tous les objets qui en dépendent sont notifiés et automatiquement mis à jour.

8. Méthode modèle : définir le squelette d'un algorithme en fonctionnement et reporter certaines étapes aux sous-classes. TemplateMethod permet aux sous-classes de ne pas modifier la structure d'un algorithme. certaines étapes spécifiques de l'algorithme.

9. Commande, mode commande : encapsule une requête en tant qu'objet, vous permettant de paramétrer les clients avec différentes requêtes, de mettre en file d'attente les requêtes et d'enregistrer les journaux de requêtes, et prend en charge les opérations annulables.

10. Etat, mode état : permet à un objet de changer de comportement lorsque son état interne change. L'objet semble avoir changé de classe.

11. Stratégie, modèle de stratégie : Définir une série d'algorithmes, les encapsuler un par un et les rendre interchangeables. Ce modèle rend les algorithmes indépendants des utilisateurs qui les utilisent. .

12. Chine de Responsabilité, modèle de chaîne de responsabilité : Donner à plusieurs objets la possibilité de traiter les demandes, évitant ainsi la relation de couplage entre l'expéditeur et le destinataire de la demande

13. Médiateur, modèle de médiateur : utilisez un objet médiateur pour encapsuler une série d'interactions d'objets.

14. Visiteur, mode visiteur : représente une opération qui agit sur chaque élément dans une structure d'objet Il permet de définir le rôle sans changer la classe de chaque élément. pour cet élément.

15. Interprète, mode interprète : étant donné une langue, définir une représentation de sa grammaire, et définir un

un interprète qui utilise la représentation pour interpréter des phrases dans la langue.

16. Memento, mode mémo : Capturer l'état interne d'un objet sans détruire l'objet, et sauvegarder cet état en dehors de l'objet.

Les types structurels incluent :

17. Composite, mode combinaison : combinez des objets dans une structure arborescente pour représenter la relation entre les parties et le tout. , Composite permet aux utilisateurs d'utiliser des objets uniques et des objets composites de manière cohérente.

18. Façade, mode d'apparence : Fournit une interface cohérente pour un ensemble d'interfaces dans le sous-système. Fa?ade fournit une interface de haut niveau, ce qui rend le sous-système plus facile à utiliser. .

19. Proxy, mode proxy : Fournir un proxy pour d'autres objets pour contrôler l'accès à cet objet

20. un type d'interface dans une autre interface souhaitée par le client. Le mode Adaptateur permet aux classes qui ne peuvent pas fonctionner ensemble en raison d'interfaces incompatibles de travailler ensemble.

21. Decrator, mode décoration : Ajoutez dynamiquement des responsabilités supplémentaires à un objet. En termes de fonctions ajoutées, le mode Decorator est plus flexible que la génération de sous-classes.

22. Bridge, mode pont : sépare la partie abstraite de sa partie implémentation afin qu'elles puissent changer indépendamment.

Vingt-trois, poids mouche, mode poids mouche

En fait, il existe deux catégories : le mode concurrent et le mode pool de threads. Utilisez une image pour le décrire dans son ensemble :

2. Les six principes des modèles de conception

Principe général : principe d'ouverture et de fermeture

Le principe d'ouverture et de fermeture signifie qu'il est ouvert à l'expansion et fermé à la modification. Lorsque le programme doit être étendu, le code original ne peut pas être modifié, mais le code original doit être étendu pour obtenir un effet remplaçable à chaud. Le résumé en une phrase est donc le suivant : afin de rendre le programme évolutif et facile à maintenir et à mettre à niveau. Pour obtenir cet effet, nous devons utiliser des interfaces et des classes abstraites, etc. Nous le mentionnerons plus tard dans la conception spécifique.

1. Principe de responsabilité unique

Ne pas avoir plus d'une raison pour les changements de classe, c'est-à-dire que chaque classe doit mettre en œuvre une seule responsabilité. Sinon, la classe doit être divisée.

2. Principe de substitution de Liskov

Le principe de substitution de Liskov LSP (principe de substitution de Liskov LSP) est l'un des principes de base de la conception orientée objet - ". Dans le principe de substitution de Liskov, dites :

Partout où une classe de base peut apparaître, une sous-classe peut certainement apparaître. LSP est la pierre angulaire de l'héritage et de la réutilisation uniquement lorsque la classe dérivée peut remplacer la classe de base et que la fonctionnalité de l'unité logicielle n'est pas affectée. Seules les classes de base. peut être véritablement réutilisé, et les classes dérivées peuvent également ajouter de nouveaux comportements sur la base des classes de base. Le principe de substitution de Liskov est une étape clé pour compléter le principe « ouvrir-fermer ». est l'implémentation spécifique de l'abstraction, donc le principe de substitution de Liskov est une spécification des étapes spécifiques pour réaliser l'abstraction

Encyclopédie

3.

C'est la base du principe d'ouverture et de fermeture. Le contenu spécifique est : la programmation orientée interface, qui s'appuie sur l'abstraction plutôt que sur le concret lors de l'écriture du code. Lorsqu'une classe concrète est utilisée, elle n'interagit pas avec la classe concrète. , mais avec l'interface de niveau supérieur de la classe concrète.

4. Principe de ségrégation des interfaces

Ce principe signifie : chaque interface n'est pas utilisée par les sous-classes mais doit l'être. implémenté. Sinon, l'interface doit être divisée. Il est préférable d'utiliser plusieurs interfaces isolées plutôt que d'utiliser une seule interface (plusieurs méthodes d'interface sont regroupées en - Une interface)

5. 🎜>

C'est-à-dire : moins une classe en sait sur les classes dont elle dépend, mieux c'est-à-dire que, quelle que soit la complexité de la classe dépendante, la logique doit être encapsulée dans la méthode et fournie. l'extérieur via des méthodes publiques. De cette façon, lorsque la classe dépendante change, cela aura un impact minimal sur la classe. Une autre expression du principe le moins connu est : ne communiquer qu'avec des amis directs tant qu'il existe une relation de couplage entre les classes. cela s'appelle une relation amie. Le couplage

peut être divisé en dépendances, associations, agrégations, combinaisons, etc. Les classes qui apparaissent dans les variables membres, les paramètres de méthode et les valeurs de retour de méthode sont appelées amis directs. les variables et les variables temporaires ne sont pas des amis directs. Nous exigeons que les classes inconnues n'apparaissent pas comme variables locales dans la classe 6. Principe de réutilisation composite

Le principe est d'essayer d'abord d'utiliser la synthèse/agrégation au lieu d'utiliser l'héritage. .

3. Les 23 modèles de conception en Java A. Modèles de création

À partir de cette section, nous présenterons en détail les concepts, les scénarios d'application, etc. et les combiner avec leurs caractéristiques et principes de modèles de conception sont analysés.

Tout d'abord, le modèle d'usine simple n'appartient pas aux modèles impliqués dans 23. Les usines simples sont généralement divisées en : usines simples ordinaires, usines simples multi-méthodes et usines simples à méthode statique.

0. Mode usine simple

Le mode usine simple est divisé en trois types : 01. Ordinaire

consiste à créer une classe usine pour certaines classes qui implémentent la même interface. Créez une instance. Tout d'abord, regardez le schéma de relation :

Par exemple : (Donnons un exemple d'envoi d'e-mails et de SMS) Tout d'abord, créez une interface commune entre les deux :

Deuxièmement, créez la classe d'implémentation :

Enfin, construisez la classe d'usine :

Testons-la :

public interface Sender {
    public void Send();
}

Sortie : il s'agit de l'expéditeur de SMS !

public class MailSender implements Sender {
    @Override
    public void Send() {
    System.out.println("this is mailsender!");
    }
}

public class SmsSender implements Sender {
    @Override
    public void Send() {
    System.out.println("this is sms sender!");
    }
}

02. Méthodes multiples

est une amélioration par rapport au modèle de méthode d'usine ordinaire, si la chaîne transmise est erronée. L'objet ne peut pas être créé correctement et le modèle de méthodes de fabrique multiples fournit respectivement plusieurs méthodes de fabrique pour créer des objets. Diagramme de relation :

public class SendFactory {
    public Sender  produce(String type){
    if ("mail" .equals(type) {
        return new MailSender( );
    }else if("sms" .equals(type)){
        return new SmsSender();
    }else{
        System. out . println("请输入正确的类型！"); 
        return null;)
    }
}

public class FactoryTest {
    public static void main(String[] args) {
        SendFactory factory = new SendFactory();
        Sender sender = factory.produce("sms");
        sender.Send();
    }
}

Modifiez le code ci-dessus et changez la classe SendFactory, comme suit :

La classe de test est la suivante :

Sortie : ceci est mailsender !

Articles associés :

Modèles de conception Java - Six principes des modèles de conception

24 modèles de conception et 7 principes en Java

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!