{"id":359,"date":"2024-04-25T18:09:34","date_gmt":"2024-04-25T17:09:34","guid":{"rendered":"https:\/\/www.xn--javaeinfacherklrt-4qb.de\/?p=359"},"modified":"2024-06-03T18:13:29","modified_gmt":"2024-06-03T17:13:29","slug":"das-factory-design-pattern-in-java","status":"publish","type":"post","link":"https:\/\/www.xn--javaeinfacherklrt-4qb.de\/?p=359","title":{"rendered":"Das Factory-Design-Pattern in Java"},"content":{"rendered":"\n

Einf\u00fchrung<\/h2>\n\n\n\n

Das Factory-Design-Pattern, auch bekannt als Fabrikmuster, ist eines der bekanntesten und am h\u00e4ufigsten verwendeten Entwurfsmuster in der Softwareentwicklung. Es geh\u00f6rt zur Kategorie der Erzeugungsmuster (Creational Patterns), die sich mit der Erstellung von Objekten befassen, ohne die Logik der Erstellung zu spezifizieren. Das Hauptziel des Factory-Patterns besteht darin, die Instanziierung von Objekten zu zentralisieren und die Komplexit\u00e4t der Objektbildung zu verbergen, wodurch der Code flexibler, wartbarer und erweiterbarer wird.<\/p>\n\n\n\n

Motivation<\/h2>\n\n\n\n

In der objektorientierten Programmierung (OOP) ist die Erstellung von Objekten eine grundlegende Aufgabe. Jedoch kann der direkte Einsatz von new<\/code> zur Instanziierung von Klassen zu Problemen f\u00fchren, insbesondere wenn der Erstellungsprozess komplex ist oder sich \u00e4ndern kann. Ein solcher Ansatz kann zu einer engen Kopplung zwischen Klassen f\u00fchren und die Wartbarkeit und Erweiterbarkeit des Codes erschweren.<\/p>\n\n\n\n

Das Factory-Pattern l\u00f6st diese Probleme, indem es die Erstellung von Objekten kapselt und zentralisiert. Dadurch kann der Code flexibler gestaltet werden, und \u00c4nderungen an der Erstellung von Objekten m\u00fcssen nur an einer Stelle vorgenommen werden.<\/p>\n\n\n\n

Grundlagen des Factory-Patterns<\/h2>\n\n\n\n

Struktur<\/h3>\n\n\n\n

Das Factory-Pattern besteht im Wesentlichen aus folgenden Komponenten:<\/p>\n\n\n\n

    \n
  1. Produkt (Product)<\/strong>: Ein Interface oder eine abstrakte Klasse, die das zu erstellende Objekt beschreibt.<\/li>\n\n\n\n
  2. Konkretes Produkt (Concrete Product)<\/strong>: Eine konkrete Implementierung des Produktes.<\/li>\n\n\n\n
  3. Erzeuger (Creator)<\/strong>: Eine Klasse, die eine Factory-Methode definiert, welche die Erstellung von Produktobjekten kapselt.<\/li>\n\n\n\n
  4. Konkreter Erzeuger (Concrete Creator)<\/strong>: Eine konkrete Implementierung des Erzeugers, die die Factory-Methode implementiert und ein konkretes Produkt erzeugt.<\/li>\n<\/ol>\n\n\n\n

    Beispiel<\/h3>\n\n\n\n

    Betrachten wir ein einfaches Beispiel, um die Struktur und Funktionsweise des Factory-Patterns zu verdeutlichen. Angenommen, wir entwickeln eine Anwendung, die verschiedene Arten von Formen (z.B. Kreise und Rechtecke) erstellen muss.<\/p>\n\n\n\n

    Produkt-Interface<\/h4>\n\n\n
    public<\/span> interface<\/span> Shape<\/span> <\/span>{\n    void draw();\n}<\/code><\/span>Code-Sprache:<\/span> PHP<\/span> (<\/span>php<\/span>)<\/span><\/small><\/pre>\n\n\n
    Konkrete Produkte<\/h4>\n\n\n
    public<\/span> class<\/span> Circle<\/span> implements<\/span> Shape<\/span> <\/span>{\n    @Override\n    public<\/span> void draw() {\n        System.out.println(\"Drawing a Circle\"<\/span>);\n    }\n}\n\npublic<\/span> class<\/span> Rectangle<\/span> implements<\/span> Shape<\/span> <\/span>{\n    @Override\n    public<\/span> void draw() {\n        System.out.println(\"Drawing a Rectangle\"<\/span>);\n    }\n}<\/code><\/span>Code-Sprache:<\/span> PHP<\/span> (<\/span>php<\/span>)<\/span><\/small><\/pre>\n\n\n
    Erzeuger (Factory)<\/h4>\n\n\n
    public<\/span> class<\/span> ShapeFactory<\/span> <\/span>{\n    \/\/ Factory-Methode zur Erstellung von Shape-Objekten<\/span>\n    public<\/span> Shape getShape(String shapeType) {\n        if<\/span> (shapeType == null<\/span>) {\n            return<\/span> null<\/span>;\n        }\n        if<\/span> (shapeType.equalsIgnoreCase(\"CIRCLE\"<\/span>)) {\n            return<\/span> new<\/span> Circle();\n        } else<\/span> if<\/span> (shapeType.equalsIgnoreCase(\"RECTANGLE\"<\/span>)) {\n            return<\/span> new<\/span> Rectangle();\n        }\n        return<\/span> null<\/span>;\n    }\n}<\/code><\/span>Code-Sprache:<\/span> PHP<\/span> (<\/span>php<\/span>)<\/span><\/small><\/pre>\n\n\n
    Verwendung der Factory<\/h4>\n\n\n
    public class<\/span> FactoryPatternDemo<\/span> <\/span>{\n    public static<\/span> void<\/span> main(String<\/span>[] args) {\n        ShapeFactory shapeFactory = new<\/span> ShapeFactory();\n\n        \/\/ Erstelle ein Circle-Objekt<\/span>\n        Shape shape1 = shapeFactory.getShape(\"CIRCLE\"<\/span>);\n        shape1.draw();\n\n        \/\/ Erstelle ein Rectangle-Objekt<\/span>\n        Shape shape2 = shapeFactory.getShape(\"RECTANGLE\"<\/span>);\n        shape2.draw();\n    }\n}<\/code><\/span>Code-Sprache:<\/span> JavaScript<\/span> (<\/span>javascript<\/span>)<\/span><\/small><\/pre>\n\n\n
    In diesem Beispiel kapselt die ShapeFactory<\/code> die Erstellung von Shape<\/code>-Objekten. Der Client (hier FactoryPatternDemo<\/code>) verwendet die Factory, um Objekte zu erstellen, ohne direkt die konkreten Klassen zu instanziieren.<\/p>\n\n\n\n
    Vorteile des Factory-Patterns<\/h2>\n\n\n\n
      \n
    1. Reduzierte Kopplung<\/strong>: Das Factory-Pattern reduziert die Abh\u00e4ngigkeit zwischen dem Client-Code und den konkreten Klassen. Der Client muss nur das Produkt-Interface kennen und nicht die konkreten Implementierungen.<\/li>\n\n\n\n
    2. Erh\u00f6hte Flexibilit\u00e4t<\/strong>: \u00c4nderungen an der Erstellung von Objekten m\u00fcssen nur an einer Stelle (in der Factory) vorgenommen werden. Neue Produkttypen k\u00f6nnen leicht hinzugef\u00fcgt werden, ohne den bestehenden Client-Code zu \u00e4ndern.<\/li>\n\n\n\n
    3. Zentralisierte Steuerung<\/strong>: Die zentrale Steuerung der Objekterstellung erm\u00f6glicht es, zus\u00e4tzliche Logik (wie Caching, Protokollierung oder Berechtigungspr\u00fcfungen) hinzuzuf\u00fcgen.<\/li>\n\n\n\n
    4. Einfache Wartung<\/strong>: Da die Logik zur Erstellung von Objekten zentralisiert ist, wird der Code leichter wartbar und erweiterbar.<\/li>\n<\/ol>\n\n\n\n
      Erweiterungen des Factory-Patterns<\/h2>\n\n\n\n
      Abstrakte Fabrik (Abstract Factory)<\/h3>\n\n\n\n
      Das Abstrakte Fabrik-Muster erweitert das Factory-Muster, indem es eine Schnittstelle zur Erstellung von verwandten Objekten ohne Angabe ihrer konkreten Klassen definiert. Dieses Muster wird verwendet, wenn ein System unabh\u00e4ngig von den Methoden zur Erstellung, Komposition und Darstellung seiner Objekte sein soll.<\/p>\n\n\n\n
      Beispiel<\/h3>\n\n\n\n
      Angenommen, wir m\u00f6chten verschiedene Arten von UI-Komponenten (z.B. Buttons und TextFields) f\u00fcr verschiedene Betriebssysteme (z.B. Windows und Mac) erstellen.<\/p>\n\n\n\n
      Abstrakte Produkte<\/h4>\n\n\n
      public<\/span> interface<\/span> Button<\/span> <\/span>{\n    void paint();\n}\n\npublic<\/span> interface<\/span> TextField<\/span> <\/span>{\n    void render();\n}<\/code><\/span>Code-Sprache:<\/span> PHP<\/span> (<\/span>php<\/span>)<\/span><\/small><\/pre>\n\n\n
      Konkrete Produkte<\/h4>\n\n\n
      public<\/span> class<\/span> WindowsButton<\/span> implements<\/span> Button<\/span> <\/span>{\n    @Override\n    public<\/span> void paint() {\n        System.out.println(\"Rendering a Windows Button\"<\/span>);\n    }\n}\n\npublic<\/span> class<\/span> MacButton<\/span> implements<\/span> Button<\/span> <\/span>{\n    @Override\n    public<\/span> void paint() {\n        System.out.println(\"Rendering a Mac Button\"<\/span>);\n    }\n}\n\npublic<\/span> class<\/span> WindowsTextField<\/span> implements<\/span> TextField<\/span> <\/span>{\n    @Override\n    public<\/span> void render() {\n        System.out.println(\"Rendering a Windows TextField\"<\/span>);\n    }\n}\n\npublic<\/span> class<\/span> MacTextField<\/span> implements<\/span> TextField<\/span> <\/span>{\n    @Override\n    public<\/span> void render() {\n        System.out.println(\"Rendering a Mac TextField\"<\/span>);\n    }\n}<\/code><\/span>Code-Sprache:<\/span> PHP<\/span> (<\/span>php<\/span>)<\/span><\/small><\/pre>\n\n\n
      Abstrakte Fabrik<\/h4>\n\n\n
      public<\/span> interface<\/span> GUIFactory<\/span> <\/span>{\n    Button createButton();\n    TextField createTextField();\n}<\/code><\/span>Code-Sprache:<\/span> PHP<\/span> (<\/span>php<\/span>)<\/span><\/small><\/pre>\n\n\n
      Konkrete Fabriken<\/h4>\n\n\n
      public<\/span> class<\/span> WindowsFactory<\/span> implements<\/span> GUIFactory<\/span> <\/span>{\n    @Override\n    public<\/span> Button createButton() {\n        return<\/span> new<\/span> WindowsButton();\n    }\n\n    @Override\n    public<\/span> TextField createTextField() {\n        return<\/span> new<\/span> WindowsTextField();\n    }\n}\n\npublic<\/span> class<\/span> MacFactory<\/span> implements<\/span> GUIFactory<\/span> <\/span>{\n    @Override\n    public<\/span> Button createButton() {\n        return<\/span> new<\/span> MacButton();\n    }\n\n    @Override\n    public<\/span> TextField createTextField() {\n        return<\/span> new<\/span> MacTextField();\n    }\n}<\/code><\/span>Code-Sprache:<\/span> PHP<\/span> (<\/span>php<\/span>)<\/span><\/small><\/pre>\n\n\n
      Verwendung der Abstrakten Fabrik<\/h4>\n\n\n
      public<\/span> class<\/span> AbstractFactoryDemo<\/span> <\/span>{\n    private<\/span> static<\/span> Application configureApplication() {\n        Application app;\n        GUIFactory factory;\n        String osName = System.getProperty(\"os.name\"<\/span>).toLowerCase();\n        if<\/span> (osName.contains(\"mac\"<\/span>)) {\n            factory = new<\/span> MacFactory();\n        } else<\/span> {\n            factory = new<\/span> WindowsFactory();\n        }\n        app = new<\/span> Application(factory);\n        return<\/span> app;\n    }\n\n    public<\/span> static<\/span> void main(String[] args) {\n        Application app = configureApplication();\n        app.paint();\n    }\n}\n\npublic<\/span> class<\/span> Application<\/span> <\/span>{\n    private<\/span> Button button;\n    private<\/span> TextField textField;\n\n    public<\/span> Application(GUIFactory factory) {\n        button = factory.createButton();\n        textField = factory.createTextField();\n    }\n\n    public<\/span> void paint() {\n        button.paint();\n        textField.render();\n    }\n}<\/code><\/span>Code-Sprache:<\/span> PHP<\/span> (<\/span>php<\/span>)<\/span><\/small><\/pre>\n\n\n
      In diesem erweiterten Beispiel verwendet die Application<\/code>-Klasse eine abstrakte Fabrik (GUIFactory<\/code>), um verschiedene UI-Komponenten zu erstellen, ohne deren konkrete Implementierungen zu kennen. Dies erm\u00f6glicht eine einfache Anpassung der UI f\u00fcr verschiedene Betriebssysteme, ohne den Hauptcode \u00e4ndern zu m\u00fcssen.<\/p>\n\n\n\n
      Fazit<\/h2>\n\n\n\n
      Das Factory-Design-Pattern ist ein leistungsf\u00e4higes Werkzeug zur Kapselung der Objekterstellung und zur Reduzierung der Kopplung in der Softwareentwicklung. Es bietet Flexibilit\u00e4t, Zentralisierung und Wartbarkeit und ist ein grundlegendes Muster, das jeder Java-Entwickler verstehen und anwenden sollte. Durch die Erweiterung zum Abstract Factory Pattern k\u00f6nnen noch komplexere und flexiblere Objektstrukturen realisiert werden, die eine einfache Anpassung und Erweiterung des Codes erm\u00f6glichen.<\/p>\n","protected":false},"excerpt":{"rendered":"
      Einf\u00fchrung Das Factory-Design-Pattern, auch bekannt als Fabrikmuster, ist eines der bekanntesten und am h\u00e4ufigsten verwendeten Entwurfsmuster in der Softwareentwicklung. Es geh\u00f6rt zur Kategorie der Erzeugungsmuster (Creational Patterns), die sich mit der Erstellung von Objekten befassen, ohne die Logik der Erstellung zu spezifizieren. Das Hauptziel des Factory-Patterns besteht darin, die Instanziierung von Objekten zu zentralisieren und […]<\/p>\n","protected":false},"author":1,"featured_media":0,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[4],"tags":[],"class_list":["post-359","post","type-post","status-publish","format-standard","hentry","category-plain_java"],"_links":{"self":[{"href":"https:\/\/www.xn--javaeinfacherklrt-4qb.de\/index.php?rest_route=\/wp\/v2\/posts\/359","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/www.xn--javaeinfacherklrt-4qb.de\/index.php?rest_route=\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/www.xn--javaeinfacherklrt-4qb.de\/index.php?rest_route=\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/www.xn--javaeinfacherklrt-4qb.de\/index.php?rest_route=\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/www.xn--javaeinfacherklrt-4qb.de\/index.php?rest_route=%2Fwp%2Fv2%2Fcomments&post=359"}],"version-history":[{"count":1,"href":"https:\/\/www.xn--javaeinfacherklrt-4qb.de\/index.php?rest_route=\/wp\/v2\/posts\/359\/revisions"}],"predecessor-version":[{"id":360,"href":"https:\/\/www.xn--javaeinfacherklrt-4qb.de\/index.php?rest_route=\/wp\/v2\/posts\/359\/revisions\/360"}],"wp:attachment":[{"href":"https:\/\/www.xn--javaeinfacherklrt-4qb.de\/index.php?rest_route=%2Fwp%2Fv2%2Fmedia&parent=359"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.xn--javaeinfacherklrt-4qb.de\/index.php?rest_route=%2Fwp%2Fv2%2Fcategories&post=359"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.xn--javaeinfacherklrt-4qb.de\/index.php?rest_route=%2Fwp%2Fv2%2Ftags&post=359"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}