Cloud-Lösungen der Zukunft - Testen!

Revolutionäre Cloud-Technologie, ganz ohne versteckte Kosten. Profitieren Sie von unserer Testphase und entdecken Sie umfassende Funktionen. Der Anmeldeprozess ist transparent und unkompliziert. Starten Sie jetzt Ihre Reise in die Cloud - Kostenfrei!

Mit E-Mail anmeldenMit Google anmeldenMit GitHub anmelden
Mit E-Mail anmeldenMit Google anmeldenMit GitHub anmelden

Kategorien

Apache

Databases

Docker

JavaScript

Kubernetes

Linux Basis

MySQL

Python

React

Security

Ubuntu

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

Copy<br /> Code 


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

Copy<br /> Code 


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

Copy<br /> Code 


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

Copy<br /> Code 


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

Copy<br /> Code 


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

Copy<br /> Code 


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

Copy<br /> Code 


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

Copy<br /> Code 


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:

Copy<br /> Code 


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

Starten Sie jetzt Ihre kostenlose Testversion und verbessern Sie Ihre Java-Entwicklung!

Nutzen Sie die Gelegenheit, unsere leistungsstarke Cloud-Plattform 30 Tage lang kostenlos zu testen. Optimieren Sie Ihre Java-Anwendungen mit modernsten Design Patterns wie dem Abstract Factory Pattern. Unsere Plattform bietet Ihnen alle Werkzeuge, die Sie benötigen, um Ihre Projekte effizienter und effektiver zu gestalten. Melden Sie sich jetzt an und erleben Sie die Vorteile unserer Cloud-Lösungen hautnah!

Try for free!

You might be interested in:

https://www.centron.de/en/glossary/server-2/
https://www.centron.de/en/glossary/query-2/