Abstraktes Fabrikmuster in Java

Tutorials
Java

Willkommen zum Beispiel des abstrakten Fabrikentwurfsmusters in Java. Das abstrakte Fabrikentwurfsmuster ist eines der Erzeugungsmuster. Das abstrakte Fabrikmuster ist fast ähnlich dem Fabrikmuster, außer der Tatsache, dass es eher wie eine Fabrik von Fabriken ist.

Abstrakte Fabrik

Wenn Sie mit dem Fabrikentwurfsmuster in Java vertraut sind, werden Sie feststellen, dass wir eine einzige Fabrikklasse haben. Diese Fabrikklasse gibt verschiedene Unterklasse basierend auf dem bereitgestellten Eingang zurück, und die Fabrikklasse verwendet eine If-Else- oder Switch-Anweisung, um dies zu erreichen. Im abstrakten Fabrikmuster werden wir den If-Else-Block los und haben für jede Unterklasse eine Fabrikklasse. Dann eine abstrakte Fabrikklasse, die die Unterklasse basierend auf der Eingabefabrikklasse zurückgibt. Zuerst scheint es verwirrend, aber sobald Sie die Implementierung sehen, ist es wirklich einfach, den geringen Unterschied zwischen Fabrik- und abstraktem Fabrikmuster zu erfassen und zu verstehen. Wie in unserem Fabrikmusterbeitrag werden wir dieselbe Superklasse und dieselben Unterklassen verwenden.

Abstract Factory Design Pattern Superklasse und Unterklassen

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 Schnittstellen- oder abstrakte Klasse für die abstrakte Fabrik 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 Fabrik-Klassen dieses Interface 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);
	}

}

Ähnlich werden wir eine Fabrik-Klasse für die Unterklasse Server 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);
	}

}

Jetzt erstellen wir eine Verbraucherklasse, die den Einstiegspunkt für die Client-Klassen bereitstellt, um Unterklassen 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 Objekt vom Typ Computer zurückgibt. Zu diesem Zeitpunkt sollte die Implementierung klar werden. Lassen Sie uns eine einfache Testmethode schreiben und sehen, wie die abstrakte Fabrik verwendet wird, um eine Instanz von Unterklassen 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.factory.ComputerFactory;
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 lautet:

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 abstrakten Fabrik-Designmusters.

Vorteile des abstrakten Fabrik-Designmusters

  • Das abstrakte Fabrik-Designmuster bietet einen Ansatz zum Programmieren für Schnittstellen anstelle von Implementierungen.
  • Das abstrakte Fabrik-Muster ist eine „Fabrik von Fabriken“ und kann leicht erweitert werden, um weitere Produkte aufzunehmen. Beispielsweise können wir eine weitere Unterklassen Laptop und eine Fabrik LaptopFactory hinzufügen.
  • Das abstrakte Fabrik-Muster ist robust und vermeidet die bedingte Logik des Fabrik-Musters.

Abstraktes Fabrik Designmuster Beispiele in JDK

  • javax.xml.parsers.DocumentBuilderFactory#newInstance()
  • javax.xml.transform.TransformerFactory#newInstance()
  • javax.xml.xpath.XPathFactory#newInstance()

Video-Tutorial zum Abstrakten Fabrik Designmuster

I recently uploaded a video on YouTube for abstract factory design pattern. In the video, I discuss when and how to implement an abstract factory pattern. I have also discussed what is the difference between the factory pattern and abstract factory design pattern. https://youtu.be/BPkYkyVWOaw

Sie können den Beispielcode von meinem GitHub-Projekt herunterladen.

Source:
https://www.digitalocean.com/community/tutorials/abstract-factory-design-pattern-in-java