Modèle de conception Java pour débutant (modèle de méthode d'usine)

introduction

C'est le premier message de Qiita. Je voudrais faire de mon mieux pour résumer les 23 types de modèles de conception du GoF qui apparaissent dans la capture approfondie des modèles de conception Java. Nous vous serions reconnaissants si vous pouviez signaler non seulement les erreurs dans le contenu, mais également d'autres choses.

Quel est le modèle de méthode d'usine?

Le modèle de méthode d'usine est un modèle de conception utilisé lorsque vous souhaitez utiliser une sous-classe et une autre en tant que paire. Par exemple, lors de la création d'une fonction pour notifier les attributs (nom, âge, adresse, nombre d'étages d'une pièce) d'une certaine personne (M. Suzuki), des informations sur la personne (nom / âge) et des informations sur le lieu (adresse / étage de la salle) Supposons que vous créez une classe abstraite ClassA qui notifie "nom" et "âge", et une classe abstraite ClassB qui notifie "adresse" et "étage étage de la salle" comme suit.

ClassA.java

abstract class ClassA{
     abstract String getName();
     abstract int    getAge();
}

ClassB.java

abstract class ClassB{
     abstract String getAddress();
     abstract int getFloor();
}

En héritant de ces deux classes abstraites, vous pourrez créer une classe qui notifie les informations de chaque personne. Exemple: Classe qui notifie les informations de M. Suzuki

ClassA1.java

class ClassA1 extends ClassA{
    String getName(){return "Suzuki";}
    int    getAge(){return 28;}
}

ClassB1.java

class ClassB1 extends ClassB{
     String getAddress(){return "Chiba";}
     int    getFloor(){return 1;}
}

Exemple: Classe qui notifie les informations de M. Miyao

ClassA2.java

class ClassA2 extends ClassA{
     String getName(){return "Miyao";}
     int    getAge(){return 23;}
}

ClassB2.java

class ClassB2 extends ClassB{
     String getAddress(){return "Tokyo";}
     int    getFloor(){return 2;}
}

En augmentant le nombre de sous-classes qui héritent de la classe abstraite de cette manière, il est possible de l'étendre afin que des informations sur différentes personnes puissent être récupérées. Toutefois, à mesure que le nombre de sous-classes augmente, les sous-classes qui doivent être utilisées par paires (ClassA1 et ClassB1 et ClassA2 et ClassB2 dans l'exemple ci-dessus) doivent être implémentées correctement.

Le modèle de méthode d'usine est utilisé dans de tels cas. Autrement dit, lors de la création d'un objet de sous-classe qui doit être utilisé comme paire, au lieu d'appeler directement le constructeur de chaque sous-classe, l'une des paires est créée en appelant le constructeur, et l'autre est "de la paire générée". Laissez "un objet" le générer. Pour ce faire, préparez une "méthode pour créer un objet de sous-classe apparié" (méthode d'usine) dans une classe. De cette manière, le modèle de méthode d'usine est un modèle qui prépare une méthode qui crée une paire d'objets. Si vous utilisez le modèle de méthode d'usine, il vous suffit d'appeler la méthode qui crée l'objet apparié, de sorte que l'implémenteur n'a pas besoin de connaître la combinaison de sous-classes utilisées dans la paire. (Dans l'exemple ci-dessus, vous n'avez pas besoin de savoir que la paire ClassA1 est ClassB1.)

L'application du modèle de méthode d'usine à cet exemple donne:

ClassA.java

abstract class ClassA{
      abstract String getName();
      abstract int    getAge();
      abstract ClassB createClassB();//Méthode d'usine
}

Ajout d'une méthode de fabrique createClassB () qui crée et renvoie une sous-classe ClassB appariée à ClassA. L'implémentation de la méthode d'usine est définie dans la sous-classe comme suit.

ClassA1.java

class ClassA1 extends ClassA{
     String getName(){return "suzuki";}
     int    getAge(){return 20;}
     ClassB1 createClassB1(){return new ClassB1();}
}

ClassA2.java

class ClassA2 extends ClassA{
     String getName(){return "Miyao";}
     int    getAge(){return 23;}
     ClassB2 createClassB2(){return new ClassB2();}
}

ClassA1 crée une paire d'objets ClassB1 et ClassA2 crée une paire d'objets ClassB2. En demandant à une classe de prendre en charge la création de l'objet de la classe appariée de cette manière, l'implémenteur n'a pas besoin de connaître la sous-classe appariée lors de l'utilisation de ClassA1 et ClassA2.

La classe principale qui utilise la classe créée est la suivante.

Main.java

class Main{
   public static void main(String args...){
       ClassA classA = new ClassA2();
 
       ClassB classB = classA.createClassB();
    
       System.out.println(classA.getName());   // Miyao
       System.out.println(classA.getAge());    // 23
       System.out.println(classB.getAddress());// Tokyo
       System.out.println(classB.getFloor());  // 2
   }
}

L'implémenteur appelle simplement createClassB () et n'a pas besoin de savoir que la sous-classe qui s'apparie à ClassA2 est ClassB2.