Design Patterns in Java: Das Abstract Factory Pattern
Erfahren Sie alles über das Abstract Factory Design Pattern in Java, eine leistungsstarke Methode zur Strukturierung und Erstellung von Klassen. Entdecken Sie die Unterschiede zu herkömmlichen Factory Patterns und sehen Sie praktische Beispiele für die Anwendung dieses Entwurfsmusters. Verbessern Sie Ihre Java-Programmierkenntnisse und gestalten Sie Ihre Code-Architektur effizienter.
Abstract Factory
Wenn Sie mit dem Factory Design Pattern in Java vertraut sind, werden Sie feststellen, dass wir eine einzige Factory-Klasse haben. Diese Factory-Klasse gibt verschiedene Unterklassen basierend auf der bereitgestellten Eingabe zurück und verwendet if-else- oder switch-Anweisungen, um dies zu erreichen. Im Abstract Factory Pattern verzichten wir auf die if-else-Blöcke und haben eine Factory-Klasse für jede Unterklasse. Dann gibt es eine abstrakte Factory-Klasse, die die Unterklasse basierend auf der Eingabe-Fabrikklasse zurückgibt. Zuerst scheint es verwirrend zu sein, aber sobald Sie die Implementierung sehen, ist es wirklich einfach zu verstehen und den geringen Unterschied zwischen Factory und Abstract Factory Pattern zu erfassen. Wie in unserem Factory Pattern-Beitrag verwenden wir die gleiche Oberklasse und die Unterklasse.
Superklasse und Unterklasse für das Abstract Factory Design Pattern
Computer.java
package com.journaldev.design.model;
public abstract class Computer {
public abstract String getRAM();
public abstract String getHDD();
public abstract String getCPU();
@Override
public String toString(){
return "RAM= "+this.getRAM()+", HDD="+this.getHDD()+", CPU="+this.getCPU();
}
}
PC.java
package com.journaldev.design.model;
public class PC extends Computer {
private String ram;
private String hdd;
private String cpu;
public PC(String ram, String hdd, String cpu){
this.ram=ram;
this.hdd=hdd;
this.cpu=cpu;
}
@Override
public String getRAM() {
return this.ram;
}
@Override
public String getHDD() {
return this.hdd;
}
@Override
public String getCPU() {
return this.cpu;
}
}
Server.java
package com.journaldev.design.model;
public class Server extends Computer {
private String ram;
private String hdd;
private String cpu;
public Server(String ram, String hdd, String cpu){
this.ram=ram;
this.hdd=hdd;
this.cpu=cpu;
}
@Override
public String getRAM() {
return this.ram;
}
@Override
public String getHDD() {
return this.hdd;
}
@Override
public String getCPU() {
return this.cpu;
}
}
Factory-Klasse für jede Unterklasse
Zunächst müssen wir eine abstrakte Factory-Schnittstelle oder abstrakte Klasse erstellen.
ComputerAbstractFactory.java
package com.journaldev.design.abstractfactory;
import com.journaldev.design.model.Computer;
public interface ComputerAbstractFactory {
public Computer createComputer();
}
Beachten Sie, dass die Methode createComputer() eine Instanz der Oberklasse Computer zurückgibt. Jetzt werden unsere Fabrikklassen diese Schnittstelle implementieren und ihre jeweilige Unterklasse zurückgeben.
PCFactory.java
package com.journaldev.design.abstractfactory;
import com.journaldev.design.model.Computer;
import com.journaldev.design.model.PC;
public class PCFactory implements ComputerAbstractFactory {
private String ram;
private String hdd;
private String cpu;
public PCFactory(String ram, String hdd, String cpu){
this.ram=ram;
this.hdd=hdd;
this.cpu=cpu;
}
@Override
public Computer createComputer() {
return new PC(ram,hdd,cpu);
}
}
Ebenso werden wir eine Fabrikklassen für die Server-Unterklasse haben.
ServerFactory.java
package com.journaldev.design.abstractfactory;
import com.journaldev.design.model.Computer;
import com.journaldev.design.model.Server;
public class ServerFactory implements ComputerAbstractFactory {
private String ram;
private String hdd;
private String cpu;
public ServerFactory(String ram, String hdd, String cpu){
this.ram=ram;
this.hdd=hdd;
this.cpu=cpu;
}
@Override
public Computer createComputer() {
return new Server(ram,hdd,cpu);
}
}
Nun werden wir eine Verbraucherklass erstellen, die den Einstiegspunkt für die Clientklassen bietet, um Unterklasse zu erstellen.
ComputerFactory.java
package com.journaldev.design.abstractfactory;
import com.journaldev.design.model.Computer;
public class ComputerFactory {
public static Computer getComputer(ComputerAbstractFactory factory){
return factory.createComputer();
}
}
Beachten Sie, dass es sich um eine einfache Klasse handelt und die Methode getComputer ein Argument vom Typ ComputerAbstractFactory akzeptiert und ein Computer-Objekt zurückgibt. Zu diesem Zeitpunkt sollte die Implementierung klar werden. Lassen Sie uns eine einfache Testmethode schreiben und sehen, wie das Abstract Factory verwendet wird, um die Instanz von Unterklasse zu erhalten.
TestDesignPatterns.java
package com.journaldev.design.test;
import com.journaldev.design.abstractfactory.PCFactory;
import com.journaldev.design.abstractfactory.ServerFactory;
import com.journaldev.design.model.Computer;
public class TestDesignPatterns {
public static void main(String[] args) {
testAbstractFactory();
}
private static void testAbstractFactory() {
Computer pc = com.journaldev.design.abstractfactory.ComputerFactory.getComputer(new PCFactory("2 GB","500 GB","2.4 GHz"));
Computer server = com.journaldev.design.abstractfactory.ComputerFactory.getComputer(new ServerFactory("16 GB","1 TB","2.9 GHz"));
System.out.println("AbstractFactory PC Config::"+pc);
System.out.println("AbstractFactory Server Config::"+server);
}
}
Die Ausgabe des obigen Programms wird sein:
AbstractFactory PC Config::RAM= 2 GB, HDD=500 GB, CPU=2.4 GHz
AbstractFactory Server Config::RAM= 16 GB, HDD=1 TB, CPU=2.9 GHz
Hier ist das Klassendiagramm der Implementierung des Abstract Factory Design Pattern.
Vorteile des Abstract Factory Design Pattern
- Das Abstract Factory Design Pattern bietet einen Ansatz zum Codieren für die Schnittstelle anstelle der Implementierung.
- Das Abstract Factory Pattern ist eine „Fabrik von Fabriken“ und kann problemlos erweitert werden, um weitere Produkte aufzunehmen