Konstruktoren gegen Fabrikmethoden

Bei der Modellierung von Klassen, was ist die bevorzugte Art der Initialisierung:

Konstruktoren, oder
Factory-Methoden

Und was wären die überlegungen für die Verwendung entweder von Ihnen?

In bestimmten Situationen, die ich lieber mit einer factory-Methode gibt null zurück, wenn das Objekt nicht erstellt werden kann. Dies macht den code ordentlich. Ich kann einfach überprüfen, ob der zurückgegebene Wert nicht null ist, bevor eine andere Aktion, in Kontrast mit dem auslösen einer exception aus dem Konstruktor. (Ich persönlich mag keine Ausnahmen)

Sagen, ich habe einen Konstruktor der Klasse erwartet einen id-Wert. Der Konstruktor verwendet diesen Wert zum Auffüllen der Klasse aus der Datenbank. In dem Fall, wo ein Datensatz mit der angegebenen id nicht vorhanden ist, wird der Konstruktor wirft eine RecordNotFoundException. In diesem Fall werde ich haben, schließen Sie den Bau aller solcher Klassen, die in einem try..catch-block.

Im Gegensatz zu dieser kann ich über eine statische factory-Methode auf diejenigen Klassen, die den Wert null zurück, wenn der Datensatz nicht gefunden wird.

Welcher Ansatz ist besser in diesem Fall, Konstruktor oder eine factory-Methode?

InformationsquelleAutor der Frage Hemanshu Bhojak | 2009-03-10

ooad oop

60

Ab Seite 108 von Design Patterns: Elements of Reusable Object-Oriented Software von Gamma, Helm, Johnson und Vlissides.

Verwendung der Factory-Methode pattern, wenn
- eine Klasse nicht vorhersehen können der Klasse der Objekte, die er erstellen muss
- eine Klasse möchte, dass seine Unterklassen spezifizieren die Objekte, die es erstellt
- Klassen delegieren Sie die Verantwortung an eine von mehreren Helfer Unterklassen, und Sie möchten, zu lokalisieren, das wissen die Helfer Unterklasse ist die Stellvertretung
InformationsquelleAutor der Antwort Glenn
161

Fragen Sie sich, was Sie sind und warum wir Sie haben. Sie beide sind da, um zu erstellen Sie eine Instanz eines Objekts.
```
ElementarySchool school = new ElementarySchool();
ElementarySchool school = SchoolFactory.Construct(); //new ElementarySchool() inside
```
Keinen Unterschied bisher. Jetzt Stell dir vor, wir haben verschiedene schul-Typen und wir wechseln wollen, von der Nutzung ElementarySchool zu HighSchool (das ist abgeleitet von einem ElementarySchool oder implementiert das gleiche interface ISchool als der ElementarySchool). Der code ändern würde:
```
HighSchool school = new HighSchool();
HighSchool school = SchoolFactory.Construct(); //new HighSchool() inside
```
Im Falle einer Schnittstelle, die wir haben würde:
```
ISchool school = new HighSchool();
ISchool school = SchoolFactory.Construct(); //new HighSchool() inside
```
Nun, wenn Sie diesen code in mehrere Orte, die Sie sehen können, dass die Verwendung von factory-Methode könnte Recht Billig, weil, sobald Sie ändern Sie die factory-Methode, die Sie fertig sind (wenn wir das zweite Beispiel mit den interfaces).

- Und dies ist der wesentliche Unterschied und Vorteil. Wenn Sie beginnen, den Umgang mit einer komplexen Klassenhierarchien und Sie möchten, um dynamisch erstellen eine Instanz einer Klasse aus einer solchen Hierarchie, bekommen Sie den folgenden code. Factory-Methoden könnte, dann nehmen Sie einen parameter, der sagt, die Methode, welche konkrete Instanz zu instanzieren. Lassen Sie uns sagen, Sie haben eine MyStudent Klasse und Sie brauchen, um zu instanziieren entsprechenden ISchool Objekt, so dass Ihre Schüler ist ein Mitglied der Schule.
```
ISchool school = SchoolFactory.ConstructForStudent(myStudent);
```
Jetzt haben Sie einen Platz in der app, enthält die business-Logik, die bestimmt, was ISchool-Objekt zu instanziieren, die für verschiedene IStudent Objekte.

So - für einfache Klassen (value-Objekte, etc.) der Konstruktor ist in Ordnung (Sie wollen nicht overengineer Ihre Anwendung), aber bei komplexen Klassenhierarchien factory-Methode ist eine bevorzugte Art und Weise.

Diesem Weg Folgen Sie das erste design-Prinzip von der gang of four-Buch "- Programm auf eine Schnittstelle, nicht auf eine Implementierung".

InformationsquelleAutor der Antwort David Pokluda
57

Müssen Sie Lesen (wenn Sie Zugriff haben) Effektive Java 2 Punkt 1: Prüfen Sie die statische factory-Methoden statt Konstruktoren.

Statische factory-Methoden Vorteile:
1. Sie haben Namen.
2. Sie sind nicht verpflichtet, ein neues Objekt erstellen jedes mal, wenn Sie aufgerufen werden.
3. Sie zurückkehren können-ein Objekt eines beliebigen Untertyp von Ihrer Rückkehr geben.
4. Sie reduzieren die Ausführlichkeit der Erstellung von parametrisierten Typ-Instanzen.
Statische factory-Methoden Nachteile:
1. Wenn die nur die statische factory-Methoden, Klassen ohne öffentliche oder geschützte Konstruktoren können nicht untergeordnet werden.
2. Sie sind nicht leicht zu unterscheiden von anderen statischen Methoden
InformationsquelleAutor der Antwort cherouvim
23

Standardmäßig Konstruktoren sollten bevorzugt werden, denn Sie sind einfacher zu verstehen und zu schreiben. Allerdings, wenn Sie benötigen insbesondere zur Entkopplung der Bau Feinheiten eines Objekts von seiner semantischen Bedeutung, wie verstanden, durch den client-code, Sie wären besser dran mit Fabriken.

Den Unterschied zwischen Konstruktoren und Fabriken, ist Analog zu der, sagen wir, eine variable und einen Zeiger auf eine variable. Es gibt eine andere Ebene der Dereferenzierung, das ist ein Nachteil; aber es ist ein weiteres Maß an Flexibilität zu, was ein Vorteil ist. Also, während Sie eine Wahl, würden Sie gut beraten, dies zu tun, Kosten /nutzen-Analyse.

InformationsquelleAutor der Antwort Frederick The Fool
11

Ein Zitat aus "Effective Java", 2nd ed., Punkt 1: Prüfen Sie die statische factory-Methoden statt Konstruktoren, p. 5:

"Beachten Sie, dass eine statische factory-Methode ist nicht das gleiche wie die Factory-Methode pattern
von Design Patterns [Gamma95, S. 107]. Die statische factory-Methode beschrieben in
dieser Artikel hat keine direkte Entsprechung in der Design-Muster."

InformationsquelleAutor der Antwort Eugen Labun
11

Verwenden Sie ein Werk nur, wenn Sie benötigen die zusätzliche Kontrolle mit dem Ziel der Erstellung, in einer Weise, die nicht getan werden mit Konstruktoren.

Fabriken haben die Möglichkeit der Zwischenspeicherung zum Beispiel.

Andere Weise zu verwenden, Fabriken ist in einem Szenario wo Sie nicht wissen, die Art, die Sie wollen, zu konstruieren. Oft sehen Sie diese Art der Nutzung in den plugin-factory-Szenarien, bei denen jedes plugin muss eine Ableitung von einem baseclass oder implementieren eine Art von Schnittstelle. Die Fabrik erzeugt Instanzen von Klassen, die sich von der baseclass oder, die das interface implementieren.

InformationsquelleAutor der Antwort Patrick Peters
7

Einem konkreten Beispiel aus einem CAD - /CAM-Anwendung.

Einer schneidbahn erfolgt mit einem Konstruktor. Es ist eine Reihe von Linien und Bögen definieren Sie einen Pfad zu schneiden. Während die Reihe von Linien und Bögen können unterschiedlich sein und haben verschiedene Koordinaten es ist leicht zu handhaben, indem eine Liste in einem Konstruktor auf.

Einer Form wäre, wäre der durch den Einsatz einer factory. Weil, während es ist eine Form, die Klasse jeder Form wäre die Einrichtung unterschiedlich, je nachdem, welche Art von Zustand es ist. Wir wissen nicht, welche Form wir gehen zu initialisieren, bis der Benutzer eine Auswahl vornimmt.

InformationsquelleAutor der Antwort RS Conley
3

Sagen, ich habe einen Konstruktor der Klasse erwartet einen id-Wert. Der Konstruktor verwendet diesen Wert zum Auffüllen der Klasse aus der Datenbank.

Dieser Prozess sollte auf jeden Fall außerhalb eines Konstruktors.
1. Konstruktor sollte keine access-Datenbank.
2. Aufgabe und der Grund für einen Konstruktor zu Daten zu initialisieren Mitglieder und etablieren Klasse invariante Verwendung übergebenen Werte in den Konstruktor.
3. Für alles andere ein besserer Ansatz ist die Verwendung statische factory-Methode oder in komplexeren Fällen eine separate Fabrik oder builder Klasse.
Einige Konstruktor Richtlinien von Microsoft:

Minimale Arbeit in den Konstruktor. Konstruktoren dürfen nicht viel arbeiten, andere als die zur Erfassung der Konstruktor-Parameter. Die Kosten für eine andere Verarbeitung sollte verzögert werden, bis Sie benötigt.

Und

Erwägen Sie die Verwendung einer statischen factory-Methode statt Konstruktor, wenn die Semantik der gewünschte Betrieb nicht direkt zuordnen, um den Bau einer neuen Instanz.

InformationsquelleAutor der Antwort Lightman
0

Manchmal müssen Sie überprüfen, berechnen einige Werte/Bedingungen während der Erstellung eines Objekts. Und wenn es eine Ausnahme - constructro ist sehr schlecht Weg. Also müssen Sie etwas tun, wie dieses:
```
var value = new Instance(1, 2).init()
public function init() {
    try {
        doSome()
    }
    catch (e) {
        soAnotherSome()
    }
}
```
Denen alle weiteren Berechnungen werden in init(). Aber nur du als Entwickler wirklich wissen, über diese init(). Und natürlich, nach Monaten haben Sie es einfach vergessen.
Aber wenn Sie eine Fabrik haben - tun Sie einfach alles, was Sie brauchen, in einer Methode zu verstecken, das init() von direkten aufrufen - also keine Probleme. Mit diesem Ansatz keine Probleme mit den fallen, die auf die Bildung und Speicher undicht.

Jemand gesagt, Sie über caching. Es ist gut so. Aber man muss auch daran denken, Flyweight-Muster das ist schön zu verwenden, mit der Fabrik Weg.

InformationsquelleAutor der Antwort R1K0
0

Neben "effective java" (wie bereits erwähnt in einer anderen Antwort), "clean code" auch fest, dass: bevorzugen Sie statische factory-Methoden (mit Namen, die beschreiben, dass die Argumente) anstelle der überladenen Konstruktoren. ZB nicht schreiben
```
Complex complex = new Complex(23.0);
```
aber stattdessen schreiben
```
Complex complex = Complex.fromRealNumber(23.0);
```
Das Buch geht so weit zu empfehlen, die Complex(float) Konstruktor private, zwingen den Benutzer zum Aufruf der statischen factory-Methode.

InformationsquelleAutor der Antwort blue_note

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.