Menü

Entwurfsmuster in Java: Singleton, Factory und Builder

  • Haupt
  • Andere
  • Entwurfsmuster in Java: Singleton, Factory und Builder

design patterns java

Versuchen Sie Unser Instrument, Um Probleme Zu Beseitigen

In diesem Tutorial werden wir Design Patterns in Java diskutieren. Wir werden Singleton-, Factory- und Builder-Muster mit Beispielen und Vorteilen untersuchen:

Wenn wir ein bestimmtes Problem lösen, können wir es effizienter lösen, wenn bereits einige Best Practices definiert sind. Dies wird uns in der Tat helfen, diese Best Practices zu befolgen und zuverlässigere Lösungen zu entwickeln.

Diese empfohlene Vorgehensweise das kann verwendet werden, um sich zu entwickeln bewährte Lösungen zur Lösung von Problemen heißen “ Designmuster ”. Erfahrene OOP-Softwareentwickler verwenden Entwurfsmuster, um bestimmte Aufgaben zu lösen.

=> Schauen Sie sich hier den Java Beginners Guide an

Entwurfsmuster in Java

Was du lernen wirst:

Entwurfsmuster in Java

Designmuster wurden erstmals 1977 von Christopher Alexander erfunden. Später schrieben vier Entwickler, nämlich Erich Gamma, Richard Helm, John Vlissides und Ralph Johnson, ein Buch mit dem Titel „ Gang of Four-Design-Muster, Elemente wiederverwendbarer objektorientierter Software Im Jahr 1995.

Von da an wurden alle Designmuster als „ Gruppe von vier Designmustern ”.

So drucken Sie ein Element eines Arrays in Java

Entwurfsmuster sind unabhängig von Programmiersprachen, da sie zur Lösung allgemeiner objektorientierter Entwurfsprobleme verwendet werden und nicht nur auf eine bestimmte Programmiersprache beschränkt sind. Im Grunde ist es also eine Idee und keine Implementierung.

Auf diese Weise können wir mithilfe von Entwurfsmustern Programme entwickeln, die effizienter, flexibler, wartbarer und wiederverwendbarer sind.

Vorteile von Designmustern

Nachfolgend sind einige der Vorteile der Verwendung von Entwurfsmustern in unseren Anwendungen aufgeführt:

  • Entwurfsmuster sind wiederverwendbar und können von mehreren Projekten verwendet werden.
  • Wir können die Systemarchitektur mithilfe von Entwurfsmustern definieren.
  • Entwurfsmuster bieten Transparenz für das Anwendungsdesign.
  • Designmuster sind bereits gut getestet und bewiesen, damit wir sie problemlos verwenden können.
  • Entwurfsmuster ermöglichen es uns, bessere Systeme zu erstellen und Klarheit über die Systemarchitektur zu schaffen.

Wann werden Entwurfsmuster verwendet?

Wann sollten wir also genau die Entwurfsmuster verwenden?

Normalerweise verwenden wir ein Entwurfsmuster während der anfänglichen Analyse- und Anforderungsphase von SDLC (Software Development Life Cycle). Bei Verwendung während der Analyse- und Anforderungsphase von SDLC werden weitere Informationen zu dieser Phase bereitgestellt. Java unterstützt intern Entwurfsmuster.

Entwurfsmuster in Java werden wie folgt kategorisiert:

Entwurfsmuster in Java

In diesem Tutorial interessieren wir uns nur für kreative Designmuster.

Kreative Designmuster werden weiter wie folgt klassifiziert:

Kreative Designmuster

In diesem Tutorial werden die folgenden Entwurfsmuster erläutert:

  • Singleton-Entwurfsmuster
  • Fabrikentwurfsmuster
  • Builder-Entwurfsmuster

Beginnen wir mit einem Singleton-Entwurfsmuster in Java.

Empfohlene Lektüre = >> Entwurfsmuster für flaschenbasierte Apps

Singleton-Muster in Java

Ein Singleton-Muster ist eine Art Erstellungsmuster in Java. Singleton-Muster ist ein Entwurfsmuster, in dem nur eine Instanz einer Klasse in der virtuellen Java-Maschine vorhanden ist. Eine Singleton-Klasse (Implementierung eines Singleton-Musters) muss einen globalen Zugriffspunkt bereitstellen, um die Instanz der Klasse abzurufen.

Mit anderen Worten, ein Singleton-Muster schränkt die Instanziierung einer Klasse ein. Das Singleton-Muster wird bei der Implementierung des Loggers für Anwendungen verwendet. Es wird auch in der Thread-Pool-Implementierung oder im Cache verwendet.

Die Java-Klassen, java.awt.Desktop und java.lang.runtime Verwenden Sie auch ein Singleton-Muster.

Vorteile

  • Da nur eine Instanz der Singleton-Klasse verwendet wird, sparen wir Speicher.
  • Gewährleistet außerdem die Wiederverwendbarkeit, da immer wieder dasselbe Singleton-Objekt verwendet wird.

Kommen wir nun zur Implementierung des Singleton-Musters.

Implementierung des Singleton-Musters

Wie bereits erwähnt, beschränkt ein Singleton-Entwurfsmuster die Klasse auf nur eine Instanz, und dieser Instanz wird ein globaler Zugriffspunkt zugewiesen. Dies waren alles Klassen, die sich immer wieder auf dasselbe Objekt beziehen.

Das folgende UML-Diagramm erläutert das Singleton-Muster.

Implementierung des Singleton-Musters

Wie das obige UML-Diagramm zeigt, ist für eine Singleton-Klasse eine einzelne Instanz definiert, auf die wir mit der Methode getInstance () zugreifen. Eine Singleton-Factory, die für das Erstellen von Objekten verantwortlich ist, verwendet die Methode getInstance, um immer wieder dasselbe Objekt (das sich in der Klasse befindet) zurückzugeben.

Wie implementieren wir das Singleton-Muster in einem Programm?

Wir erstellen eine Singleton-Klasse und haben ihren Konstruktor als 'privat', damit die Klasse nicht instanziiert werden kann. Dann erstellen wir eine private Instanz dieser Singleton-Klasse innerhalb der Klasse selbst. Dann haben wir eine spezielle öffentliche Methode getInstance (), die ein Singleton-Objekt an die Außenwelt zurückgibt.

Diese Implementierung dieser Singleton-Klasse, wie oben erläutert, wird im folgenden Java-Programm gezeigt.

class SingletonObject { //create an object of SingletonObject private static SingletonObject instance = new SingletonObject(); //private constructor so that we cannot instantiate the class private SingletonObject(){} //returns the only available object public static SingletonObject getInstance(){ return instance; } public void printMessage(){ System.out.println('Hello from Singleton object!!!'); } } public class Main { public static void main(String() args) { //illegal statement because constructor is private //Compile Time Error: The constructor SingletonObject() is not visible //SingletonObject object = new SingletonObject(); //call getInstance to retrieve the object available from the class SingletonObject object = SingletonObject.getInstance(); //show the message object.printMessage(); } }

Ausgabe:

Implementierung eines Singleton-Musters in einem Programm

Wenn wir nun die Hauptmethode überprüfen, beachten Sie, dass der Compiler einen Kompilierungsfehler ausgibt, wenn wir versuchen, ein Objekt der Singleton-Klasse mit einem neuen Operator zu erstellen (siehe den kommentierten Code in der Hauptmethode). Wir erhalten das Objekt der Singleton-Klasse mit der Methode getInstance () und können es dann wie gewohnt verwenden, um auf Methoden zuzugreifen.

Fabrikmuster in Java

Das Factory-Muster wird in Java auch als 'Factory Method Pattern' oder 'Virtual Constructor' bezeichnet. In diesem Muster erstellen wir eine Schnittstelle oder eine abstrakte Klasse mit Methodendeklarationen. Anschließend sind die konkreten Klassen oder Unterklassen, die diese Schnittstelle implementieren oder die Klasse erben, für die Erstellung von Instanzen der Klasse verantwortlich.

Vorteile

  • Das Factory-Muster ist eine Art Erstellungsmuster und das in Java am häufigsten verwendete Muster.
  • Durch die Verwendung eines Factory-Musters stellen wir sicher, dass die eigentliche Erstellungslogik nicht der Außenwelt ausgesetzt ist.

Wenn also eine Klasse, die ein Factory-Muster implementiert, über eine Methode zur Berechnung des Zinssatzes verfügt, implementieren die konkreten Klassen diese Klasse und implementieren auch die Methode zur Berechnung des Zinssatzes.

Dann wird es eine andere Klasse geben, die eine Factory-Klasse ist, die auf diese konkreten Klasseninstanzen zugreift, sodass wir nicht wissen, wie die Logik zur Berechnung des Zinssatzes implementiert wird. Wir rufen nur die Methode auf und erhalten die Ausgabe.

Wann genau können wir das Factory-Methodenmuster verwenden?

Wenn die übergeordneten Klassen beschließen, die Erstellung von Instanzen an ihre Unterklassen zu delegieren, können wir ein Factory-Muster verwenden (dies wird oben erläutert). Wir können die Factory-Methode auch verwenden, wenn die Klasse nicht weiß, welche Unterklassen erstellt werden sollen.

Lassen Sie uns nun die Implementierung des Factory-Methodenmusters sehen.

Implementierung des Fabrikmusters

Als Beispiel implementieren wir eine generische Formschnittstelle. Über diese Schnittstelle können wir verschiedene konkrete Klassen wie den Kreis, das Rechteck usw. ableiten. Dann haben wir eine shapeFactory-Klasse, die auf die konkreten Klassenobjekte zugreift. Die UML für dieses Muster ist unten dargestellt.

Geräte des Fabrikmusters

Wie bereits erläutert, ist dies das UML-Diagramm für das Factory-Muster. Jetzt werden wir ein Java-Programm implementieren, das das Factory-Muster demonstriert.

//Geometric_shape interface interface Geometric_shape { void draw_shape(); } //Geometric shape classes implementing Geometric_shape interface class Rectangle implements Geometric_shape { @Override public void draw_shape() { System.out.println('Rectangle class::draw_shape() method.'); } } class Square implements Geometric_shape { @Override public void draw_shape() { System.out.println('Square class::draw_shape() method.'); } } class Circle implements Geometric_shape { @Override public void draw_shape() { System.out.println('Circle class::draw_shape() method.'); } } //Factory class for Geometric_shape class ShapeFactory { //shapeObject method gets particular shapeType (circle, Square or Rectangle) public Geometric_shape shapeObject(String shapeType){ if(shapeType == null){ return null; } //retrieve Circle object if(shapeType.equalsIgnoreCase('Circle')){ return new Circle(); //retrieve Rectangle object } else if(shapeType.equalsIgnoreCase('Rectangle')){ return new Rectangle(); ////retrieve Square object } else if(shapeType.equalsIgnoreCase('Square')){ return new Square(); } return null; } } public class Main { public static void main(String() args) { //Create a ShapeFactory object to get different geometric shapes ShapeFactory shapeFactory = new ShapeFactory(); //circle Geometric_shape shape_Circle = shapeFactory.shapeObject('CIRCLE'); //draw method of Circle shape_Circle.draw_shape(); //Rectangle Geometric_shape shape_Rectangle = shapeFactory.shapeObject('RECTANGLE'); //draw method of Rectangle shape_Rectangle.draw_shape(); //Square Geometric_shape shape_Square = shapeFactory.shapeObject('SQUARE'); //draw method of square shape_Square.draw_shape(); } }

Ausgabe:

Werksmuster - Ausgabe

Builder-Muster in Java

Im Builder-Muster verwenden wir einen schrittweisen Ansatz, um ein komplexes Objekt mit kleinen und einfachen Objekten zu erstellen.

Wenn wir also auf ein Objekt stoßen, das nicht in einem einzigen Schritt erstellt werden kann, wählen wir ein Builder-Muster.

Vorteile

  • Mit dem Builder-Muster können wir die Konstruktion und Darstellung eines Objekts trennen.
  • Wir können auch die interne Darstellung des Objekts ändern.
  • Mit dem Builder-Muster können wir komplexe Designs wie ein gesamtes Liefersystem erstellen.

Ein praktisches Beispiel für ein Builder-Muster ist das Bestellsystem für Lebensmittel, das komplexe Schritte zum Sammeln bestellter Lebensmittel, zum Verpacken, Abrechnen, Erstellen von Bestellungen und anschließenden Versand umfasst.

In diesem Tutorial implementieren wir ein Beispiel für ein Tablet-Bestellsystem unter Verwendung des Builder-Musters.

Implementierung des Builder-Musters

Das allgemeine UML-Diagramm für das Builder-Muster ist unten angegeben.

Implementierung des Builder-Musters

Das obige Diagramm zeigt das UML-Diagramm des Builder-Musters. Wie im obigen Diagramm gezeigt, enthält das Builder-Muster vier Komponenten.

  • Produkt: Dies stellt das komplexe Objekt dar, das erstellt werden soll.
  • Builder Abstrakte Klasse: Eine abstrakte Klasse, die Prototypen aller Funktionen enthält, die zum Erstellen eines komplexen Objekts erforderlich sind.
  • ConcreteBuilder Klasse: Dies ist eine konkrete Klasse, die von der Builder-Klasse erbt und ein bestimmtes komplexes Objekt erstellt. Wir können so viele ConcreteBuilder-Klassen haben, wie wir brauchen.
  • Regieklasse: Diese Klasse steuert die Algorithmen, die das Endprodukt generieren.

Das folgende Programmierbeispiel zeigt die Demonstration eines Builder-Musters mit einem Building-System für die Bestellung von Tablets.

import java.util.ArrayList; import java.util.List; //Packing interface for tablets interface Packing { public String pack(); public int price(); } //Tablet class - abstract abstract class Tablet implements Packing{ public abstract String pack(); } //company - extends Tablet abstract class Company extends Tablet{ public abstract int price(); } //Lenovo tablet class Lenovo extends Company{ @Override public int price(){ return 541; } @Override public String pack(){ return 'Lenovo Yoga'; } } //Micromax tablet class MicroMax extends Company { @Override public int price(){ return 338; } @Override public String pack(){ return 'MicroMax'; } } //Tablet type class TabType { private List items=new ArrayList(); //add items public void addItem(Packing packs) { items.add(packs); } //retrieve cost public void getCost(){ for (Packing packs : items) { packs.price(); } } //show all items public void showItems(){ for (Packing packing : items){ System.out.print('Tablet name : '+packing.pack()); System.out.println(', Price(in U.S.Dollars) : '+packing.price()); } } } //builder class for tablets order class TabBuilder { public TabType buildLenovoTab(){ TabType lenovo =new TabType(); lenovo.addItem(new Lenovo()); return lenovo; } public TabType buildMicroMaxTab(){ TabType mmx=new TabType(); mmx.addItem(new MicroMax()); return mmx; } } public class Main{ public static void main(String args()){ //build the tablets order and display the order TabBuilder tabBuilder=new TabBuilder(); TabType tabtype1=tabBuilder.buildLenovoTab(); tabtype1.showItems(); TabType tabtype2=tabBuilder.buildMicroMaxTab(); tabtype2.showItems(); } }

Ausgabe:

Build Pattern - Ausgabe

Im obigen Beispiel haben wir das komplette Tablet-Bestellsystem für zwei Tablet-Marken erstellt, d. H. Lenovo und Micromax. Dies sind die konkretenBuilder-Klassen, die von der abstrakten Klassenfirma erben. Dann haben wir eine TabBuilder-Klasse, die die Bestellungen für beide Tablet-Klassen erstellt.

Häufig gestellte Fragen

F # 1) Was sind Entwurfsmuster in Java? Welche Arten von Entwurfsmustern gibt es in Java?

Online-Backup-Software für Dienstleister

Antworten: Entwurfsmuster sind die Best Practices, mit denen bewährte Lösungen entwickelt werden können.

Java hat drei Arten von Entwurfsmustern:

  • Kreatives Designmuster: Factory-Muster, abstraktes Factory-Muster, Singleton-Muster, Builder-Muster und Prototyp-Muster sind Beispiele für kreative Designmuster. Diese befassen sich hauptsächlich mit der Erstellung von Objekten.
  • Strukturelles Entwurfsmuster: Sie werden hauptsächlich zum Erstellen einer Klassenstruktur verwendet. Adapter-, Brücken- und Verbundmuster sind beliebte strukturelle Entwurfsmuster.
  • Verhaltensentwurfsmuster: Diese bieten eine bessere Interaktion zwischen den Objekten sowie die Flexibilität, die Implementierung einfach zu erweitern. Beobachtermuster, Strategiemuster usw. sind einige Beispiele für Verhaltensmuster.

F # 2) Warum werden Entwurfsmuster verwendet?

Antworten: Entwurfsmuster bieten uns ein bewährtes und getestetes Lösungsmodell, mit dem wir komplexe Probleme lösen können. Konstruktionsmuster ermöglichen es uns, zusammenhängende Module mit loser Kopplung zu bauen. Designmuster machen auch die Interaktion zwischen Designern effizienter und effektiver.

F # 3) Was sind die Beispiele für Muster?

Antworten: Beispiele für natürliche Muster sind sichtbare Regelmäßigkeiten in der Natur. Natürliche Muster wie Symmetrien, Bäume, Wellen, Schäume, Streifen, Risse usw. sind einige Beispiele für natürliche Muster.

F # 4) Ist MVC ein Entwurfsmuster?

Antworten: Ja, es ist eine Art Entwurfsmuster, mit dem wir eine Anwendung erstellen können, die aus dem Datenmodell, der Präsentation oder der Ansichtsebene und dem Controller besteht. Wir können es eher als architektonisches Muster klassifizieren.

Fazit

Damit ist unsere Diskussion über Entwurfsmuster in Java abgeschlossen. Obwohl Java drei Arten von Entwurfsmustern unterstützt, nämlich. Kreations-, Struktur- und Verhaltensmuster interessieren uns mehr für das kreative Designmuster.

Gemäß dem Umfang dieses Tutorials haben wir drei Beispiele für kreative Entwurfsmuster erörtert, nämlich Singleton-Muster, Factory-Muster und Builder-Muster.

Das Singleton-Muster ist das einfachste Entwurfsmuster, und die Factory-Methode soll ein weit verbreitetes Entwurfsmuster sein. Das Builder-Muster wird zum Erstellen komplexer Objekte verwendet und hauptsächlich zum Entwickeln komplexer Anwendungen.

=> Lesen Sie hier den perfekten Java-Schulungsleitfaden.

Literatur-Empfehlungen

^