1. Présentation
Dans l'ensemble, les modèles de conception sont divisés en trois catégories:
(1) Mode créatif , un total de cinq types: mode méthode d'usine, mode d'usine abstrait, mode singleton, mode générateur et mode prototype.
(2) Modes structurels , un total de sept types: mode adaptateur, mode décorateur, mode proxy, mode d'apparence, mode pont, mode combinaison et mode de plaisir.
(3) Mode comportemental , un total de onze: mode politique, mode de méthode du modèle, mode observateur, sous-mode itératif, mode de chaîne de responsabilité, mode de commande, mode mémo, mode d'état, mode visiteur, mode intermédiaire et mode interprète.
2. Six principes du modèle de conception
1. Principe de fermeture ouverte
Le principe de l'ouverture et de la fermeture est d'ouvrir aux extensions et à proximité des modifications. Lorsque le programme doit être élargi, vous ne pouvez pas modifier le code d'origine pour obtenir un effet de fiche à chaud.
2. Principe de substitution de Liskov
Sa description officielle est relativement abstraite et peut être utilisée pour Baidu. En fait, il peut être compris comme suit: (1) La capacité d'une sous-classe doit être supérieure ou égale à la classe parent, c'est-à-dire les méthodes que la classe parent peut utiliser et la sous-classe peut utiliser. (2) Il en va de même pour la valeur de retour. Supposons qu'une méthode de classe parent renvoie une liste et qu'une sous-classe renvoie une liste Array, ce qui peut bien sûr être fait. Si la méthode de la classe parent renvoie un ArrayList et que la classe enfant renvoie une liste, cela n'a pas de sens. Ici, la capacité des sous-classes à retourner les valeurs est inférieure à celle des classes parentales. (3) Il y a aussi des cas où des exceptions sont lancées. Toute méthode de sous-classe peut déclarer une sous-classe qui lance la méthode de la classe parent pour déclarer une exception.
Il ne peut pas déclarer que l'exception que la classe parent n'a pas déclarée est lancée.
3. Principe d'inversion de dépendance
C'est la base du principe de l'ouverture et de la fermeture, et le contenu spécifique: programmation orientée vers l'interface, en s'appuyant sur l'abstraction plutôt que sur le béton.
4. Principe de ségrégation de l'interface
Ce principe signifie: l'utilisation de plusieurs interfaces isolées est meilleure que d'utiliser une seule interface. Cela signifie également réduire le degré de couplage entre les classes. De là, nous pouvons voir que le modèle de conception est en fait l'idée de conception d'un logiciel, à partir d'une grande architecture logicielle, pour la commodité de la mise à niveau et de la maintenance. Par conséquent, l'article ci-dessus est apparu plusieurs fois: réduire la dépendance et réduire le couplage.
5. Principe Demeter
Pourquoi le principe de la moindre connaissance? Autrement dit, une entité devrait interagir avec d'autres entités le moins possible, afin que les modules fonctionnels du système soient relativement indépendants.
6. Principe de réutilisation composite
Le principe est d'essayer d'utiliser des méthodes de synthèse / agrégation plutôt que d'héritage.
3. Mode de création
Il existe cinq types de modes de création: le mode méthode d'usine, le mode d'usine abstrait, le mode singleton, le mode générateur et le mode prototype.
3.1. Modèle de méthode d'usine
Le mode Méthode d'usine est divisé en trois types: mode d'usine ordinaire, mode méthode d'usine multiple et mode de méthode d'usine statique.
3.1.1. Modèle d'usine ordinaire
Le modèle d'usine ordinaire consiste à établir une classe d'usine et à créer des instances de certaines classes qui implémentent la même interface.
package com.mode.create; Interface publique MyInterface {public void print ();} package com.mode.create; classe publique MyClassone implémente MyInterface {@Override public void print () {System.out.println ("myClassone"); }} package com.mode.create; La classe publique MyClasstwo implémente MyInterface {@Override public void print () {System.out.println ("mycLasstwo"); }} package com.mode.create; classe publique myfactory {public myInterface produce (string type) {if ("one" .equals (type)) {return new myClassone (); } else if ("deux" .equals (type)) {return new myClasstwo (); } else {System.out.println ("aucun type à trouver"); retourner null; }}} package com.mode.create; classe publique FactoryTest {public static void main (String [] args) {myfactory factory = new myfactory (); MyInterface myi = factory.produce ("un"); myi.print (); }}Je pense que les résultats de Factorytest devraient être évidents.
Comprenons à nouveau cette phrase: le modèle d'usine ordinaire consiste à établir une classe d'usine et à créer des instances de certaines classes qui implémentent la même interface.
3.1.2. Modes de méthodes d'usine multiples
Plusieurs modes de méthode d'usine sont une amélioration du mode de méthode d'usine ordinaire. Plusieurs modes de méthode d'usine sont de fournir plusieurs méthodes d'usine pour créer des objets séparément.
Regardons directement le code. Nous modifions MyFactory et Factorytest comme suit:
package com.mode.create; classe publique MyFactory {public myInterface produceOne () {return new MyClassone (); } public myInterface produtwo () {return new myclasstwo (); }} package com.mode.create; classe publique FactoryTest {public static void main (String [] args) {myfactory factory = new myfactory (); MyInterface myi = factory.produceOne (); myi.print (); }}Les résultats de l'opération sont également très évidents.
Comprenons à nouveau cette phrase: plusieurs modes de méthode d'usine sont une amélioration du mode de méthode d'usine ordinaire. Plusieurs modes de méthode d'usine sont de fournir plusieurs méthodes d'usine pour créer des objets séparément.
3.1.3. Mode de méthode d'usine statique
Mode de méthode d'usine statique, définissez les méthodes dans les modes de méthode d'usine ci-dessus sur statique, et il n'est pas nécessaire de créer une instance, il suffit de l'appeler directement.
Regardons directement le code. Nous modifions MyFactory et Factorytest comme suit:
package com.mode.create; classe publique MyFactory {public static myInterface produceOne () {return new myClassone (); } public static myInterface produtwo () {return new myclasstwo (); }} package com.mode.create; classe publique FactoryTest {public static void main (String [] args) {myInterface myi = myfactory.produceOne (); myi.print (); }}Les résultats de l'opération sont encore très évidents.
Revoir à nouveau: mode de méthode d'usine statique, définissez les méthodes dans les modes de méthode d'usine ci-dessus sur statique, et il n'est pas nécessaire de créer une instance, il suffit de l'appeler directement.
3.2. Modèle d'usine abstrait
Il y a un problème avec le modèle de méthode d'usine que la création de classe dépend des classes d'usine, c'est-à-dire que si vous souhaitez étendre le programme, vous devez modifier la classe d'usine, qui viole le principe de fermeture.
Pour résoudre ce problème, jetons un œil au modèle d'usine abstrait: créez plusieurs classes d'usine, de sorte qu'une fois que de nouvelles fonctions sont nécessaires, vous pouvez ajouter directement de nouvelles classes d'usine, sans modifier le code précédent.
Cela est conforme au principe de fermeture.
Jetons un coup d'œil au code ci-dessous:
MyInterface, MyClassone, MyClasstwo reste inchangé.
Les interfaces et classes suivantes sont ajoutées:
package com.mode.create; fournisseur d'interface publique {public myInterface produce (); } package com.mode.create; classe publique MyFactoryOne implémente le fournisseur {@Override public myInterface produce () {return new MyClassone (); }} package com.mode.create; classe publique MyFactoryTwo implémente le fournisseur {@Override public myInterface produce () {return new myclasstwo (); }}Modifiez la classe de test Factorytest comme suit:
package com.mode.create; classe publique FactoryTest {public static void main (String [] args) {provider provider = new myfactoryOne (); MyInterface myi = provider.produce (); myi.print (); }}Les résultats de l'opération sont toujours évidents.
Revoir à nouveau: Le modèle d'usine abstrait est de créer plusieurs classes d'usine, de sorte qu'une fois que de nouvelles fonctions sont nécessaires, vous pouvez ajouter directement de nouvelles classes d'usine, sans modifier le code précédent.
3.3. Mode singleton
Singleton Pattern, pas besoin d'explications trop.
Regardez simplement le code:
test de package; classe publique MyObject {MyObject statique privé MyObject; MyObject privé () {} public static myObject getInstance () {if (myObject! = null) {} else {myObject = new myObject (); } return myObject; }}Cependant, cela entraînera des problèmes multiples. Pour une explication détaillée, vous pouvez voir le chapitre 6 du livre "Core Technology of Java Multi-Threading Programming".
3.4. Mode générateur
Modèle de constructeur: consiste à séparer la construction d'un objet complexe de sa représentation, afin que le même processus de construction puisse créer différentes représentations.
Il a l'air très abstrait littéralement, mais en fait c'est aussi très abstrait! ! ! !
Le mode Builder comprend généralement les caractères suivants:
(1) Builder: Donnez une interface abstraite pour normaliser la construction de divers composants de l'objet produit. Cette interface spécifie quelles parties d'objets complexes sont créés et n'implique pas la création de composants d'objets spécifiques.
(2) Concretebuilder: implémente l'interface du constructeur et définit la création de diverses parties d'objets complexes pour différentes logiques métier. Une fois le processus de construction terminé, un exemple du produit est fourni.
(3) Directeur: appelle les constructeurs spécifiques pour créer différentes parties d'objets complexes. L'instructeur n'implique pas d'informations de produit spécifiques, mais n'est responsable que de s'assurer que toutes les parties de l'objet sont créées intactes ou dans un certain ordre.
(4) Produit: l'objet complexe à créer.
Il est courant de construire des méchants dans le développement de jeux, et l'exigence est: les méchants doivent inclure la tête, le corps et les pieds.
Jetons un coup d'œil au code suivant:
Produit (objet complexe à créer.):
package com.mode.create; Personne de classe publique {tête de chaîne privée; corps de cordes privées; pied de chaîne privé; String public gethead () {return Head; } public void sethead (chaîne head) {this.head = head; } public String getBody () {return body; } public void setBody (String body) {this.body = body; } public String getFoot () {retour du pied; } public void setFoot (String Foot) {this.foot = foot; }} Builder (donne une interface abstraite pour normaliser la construction de divers composants d'un objet de produit. Cette interface spécifie quelles parties d'un objet complexe sont créées pour être implémentées et n'implique pas la création de composants d'objets spécifiques.):
package com.mode.create; interface publique Personbuilder {void buildhead (); void buildBody (); void buildfoot (); Personne BuildSerson ();} Concretebuilder (implémente l'interface du constructeur, qui incarne la création de diverses parties d'objets complexes pour différentes logiques métier. Une fois le processus de construction terminé, fournissez un exemple du produit.):
package com.mode.create; classe publique ManBuilder met en œuvre du personnel de personne {personne personne; public manbuilder () {personne = new personne (); } public void BuildBody () {Person.setBody ("Build the Man's Body"); } public void buildfoot () {Person.setfoot ("Build the Man's Feet"); } public void buildhead () {personne.sethead ("construire la tête de l'homme"); } Public BuildSerson () {Personne de retour; }} Directeur (Appelez le constructeur spécifique pour créer diverses parties d'objets complexes. L'instructeur n'implique pas d'informations de produit spécifiques. Il est seulement responsable de s'assurer que les parties de l'objet sont créées intactes ou dans un certain ordre.):
package com.mode.create; classe publique PersonDirector {Public Person ConstructSerson (Personbuilder PB) {PB.BuildHead (); pb.buildBody (); pb.buildfoot (); retour pb.buildPerson (); }} Classe de test:
package com.mode.create; Test de classe publique {public static void main (String [] args) {persondirector pd = new PersonDirector (); Personne personne = pd.constructSon (new manbuilder ()); System.out.println (personne.getBody ()); System.out.println (Person.getFoot ()); System.out.println (Person.GetHead ()); }}Résultats en cours:
Revue: Modèle du constructeur: consiste à séparer la construction d'un objet complexe de sa représentation, afin que le même processus de construction puisse créer différentes représentations.
3.5. Mode prototype
L'idée de ce modèle est d'utiliser un objet comme prototype, de le copier et de le cloner, et de produire un nouvel objet similaire à l'objet d'origine.
En parlant de copier des objets, j'en parlerai en combinaison avec une copie peu profonde et une copie profonde des objets. Tout d'abord, vous devez comprendre le concept de copie profonde et superficielle des objets:
Copie peu profonde: Après la copie d'un objet, les variables du type de données de base seront recréées, tandis que le type de référence pointe vers l'objet d'origine.
Copie profonde: Après la copie d'un objet, le type de données de base et le type de référence sont recréés. Autrement dit, la copie profonde est complètement copiée, tandis que la copie peu profonde n'est pas approfondie.
Écrivez un exemple de copie de profondeur:
package com.mode.create; import java.io.bytearrayinputStream; import java.io.bytearrayoutputStream; import java.io.ioException; import java.io.objectInputStream; import java.io.objectOutStream; import java.io.serializable; La classe publique Prototype implémente clonable, sérialisable {private static final long SerialVersionUID = 1l; base int privée; entier privé Obj; / * copie superficielle * / public clone () lance clonenotsupportedException {// parce que l'interface clonable est une interface vide, vous pouvez définir le nom de la méthode de la classe d'implémentation à volonté // tel que clonea ou cloneb proto = (prototype) super.clone (); return proto; } / * copie profonde * / objet public DeepClone () lève ioException, classNotFoundException {/ * Écrivez le flux binaire dans l'objet actuel * / bytearrayoutputStream bos = new ByTearRayOutStream (); ObjectOutputStream OOS = new ObjectOutputStream (BOS); oos.writeObject (this); / * Lisez le nouvel objet généré par le flux binaire * / bytearrayInputStream bis = new ByteArrayInputStream (bos.toByTearray ()); ObjectInputStream oiS = new ObjectInputStream (bis); return ois.readObject (); } public int getBase () {return base; } public void setBase (int base) {this.base = base; } public entier getOBJ () {return obj; } public void setObj (entier obj) {this.obj = obj; }} Classe de test:
package com.mode.create; Importer java.io.ioException; public class test {public static void main (String [] args) lève ClonenotsupportEdException, classNotFoundException, ioException {prototype prototype = new prototype (); prototype.setbase (1); prototype.setObj (nouvel entier (2)); / * Copie peu profonde * / prototype Prototype1 = (prototype) prototype.clone (); / * Copie profonde * / prototype Prototype2 = (prototype) prototype.deepClone (); System.out.println (prototype1.getObj () == prototype1.getObj ()); System.out.println (prototype1.getObj () == prototype2.getObj ()); }}Résultats en cours:
Ce qui précède concerne cet article, j'espère qu'il sera utile à l'apprentissage de tout le monde.