Java-Anfänger-Entwurfsmuster (Factory-Methodenmuster)

Einführung

Dies ist Qiitas erster Beitrag. Ich möchte mein Bestes geben, um die 23 Arten von GoF-Entwurfsmustern zusammenzufassen, die bei der gründlichen Erfassung von Java-Entwurfsmustern auftreten. Wir würden uns freuen, wenn Sie nicht nur auf die inhaltlichen Fehler, sondern auch auf andere Dinge hinweisen könnten.

Was ist das Factory-Methodenmuster?

Das Factory-Methodenmuster ist ein Entwurfsmuster, das verwendet wird, wenn Sie eine Unterklasse und eine andere als Paar verwenden möchten. Zum Beispiel beim Erstellen einer Funktion zum Benachrichtigen der Attribute (Name, Alter, Adresse, Anzahl der Stockwerke eines Raums) einer bestimmten Person (Herr Suzuki), Informationen über die Person (Name / Alter) und Informationen über den Ort (Adresse / Stockwerk des Raums) Angenommen, Sie erstellen eine abstrakte Klasse ClassA, die "Name" und "Alter" benachrichtigt, und eine abstrakte Klasse ClassB, die "Adresse" und "Etage des Raums" wie folgt benachrichtigt.

ClassA.java

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

ClassB.java

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

Durch das Erben dieser beiden abstrakten Klassen können Sie eine Klasse erstellen, die die Informationen jeder Person benachrichtigt. Beispiel: Klasse, die die Informationen von Herrn Suzuki benachrichtigt

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;}
}

Beispiel: Klasse, die die Informationen von Herrn Miyao benachrichtigt

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;}
}

Durch Erhöhen der Anzahl der Unterklassen, die die abstrakte Klasse auf diese Weise erben, kann sie erweitert werden, sodass Informationen zu verschiedenen Personen abgerufen werden können. Mit zunehmender Anzahl von Unterklassen müssen jedoch die Unterklassen, die paarweise verwendet werden sollen (Klasse A1 und Klasse B1 sowie Klasse A2 und Klasse B2 im obigen Beispiel), korrekt implementiert werden.

In solchen Fällen wird das Factory-Methodenmuster verwendet. Das heißt, wenn ein Unterklassenobjekt erstellt wird, das als Paar verwendet werden muss, anstatt den Konstruktor jeder Unterklasse direkt aufzurufen, wird eines der Paare durch Aufrufen des Konstruktors erstellt, und das andere ist "des generierten Paares". Lassen Sie "ein Objekt" es erzeugen. Bereiten Sie dazu eine "Methode zum Erstellen eines gepaarten Unterklassenobjekts" (Factory-Methode) in einer Klasse vor. Auf diese Weise ist das Factory-Methodenmuster ein Muster, das eine Methode vorbereitet, mit der ein Objektpaar erstellt wird. Wenn Sie das Factory-Methodenmuster verwenden, müssen Sie nur die Methode aufrufen, mit der das gepaarte Objekt erstellt wird, sodass der Implementierer die Kombination der im Paar verwendeten Unterklassen nicht kennen muss. (Im obigen Beispiel müssen Sie nicht wissen, dass das ClassA1-Paar ClassB1 ist.)

Das Anwenden des Factory-Methodenmusters auf dieses Beispiel ergibt:

ClassA.java

abstract class ClassA{
      abstract String getName();
      abstract int    getAge();
      abstract ClassB createClassB();//Fabrikmethode
}

Es wurde eine Factory-Methode createClassB () hinzugefügt, die eine gepaarte ClassB-Unterklasse erstellt und an ClassA zurückgibt. Die Implementierung der Factory-Methode wird in der Unterklasse wie folgt definiert.

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 erstellt ein Paar von ClassB1-Objekten und ClassA2 erstellt ein Paar von ClassB2-Objekten. Wenn eine Klasse das Objekt der gepaarten Klasse auf diese Weise erstellt, muss der Implementierer bei Verwendung von ClassA1 und ClassA2 die gepaarte Unterklasse nicht kennen.

Die Hauptklasse, die die erstellte Klasse verwendet, lautet wie folgt.

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
   }
}

Der Implementierer ruft einfach createClassB () auf und muss nicht wissen, dass die mit ClassA2 gepaarte Unterklasse ClassB2 ist.