Factory (Design Pattern)

Factory ist ein Design Pattern, das verwendet werden kann, wenn es nicht möglich und/oder sinnvoll ist, Instanzen mit new zu erzeugen (es könnten ja langwierige Konfigurationen vorgenommen werden müssen). So kann zum Beispiel für gleiche Objekte auch leicht die gleiche Instanz verwendet werden.

Bei diesem gibt es meist eine statische Methode, um das jeweilige Objekt zu erzeugen. Ein Singleton ist eine Form des Factory-Patterns, wobei hier die Factory - Methode sicherstellt, dass es nur eine Instanz gibt.

Es gibt verschiedene Möglichkeiten, wo sich die Factory-Methode befinden kann.

• In der eigenen Klasse:

<code=java> public class Foo {

 private Foo () //Foo soll nur von der factory-Methode instanziiert werden
 {
 }
 public static Foo getFoo (Settings s) //statische factory - Methode
 {
   Foo bar = new Foo();
   //Wende s auf bar an
   return bar;
 }

}</code=java> Das wird zum Beispiel in der Klasse java.net.InetAddress angewandt.

• In einer Factory - Klasse:

<code=java> public class Foo {

 Foo() //Konstruktor nur für package zugänglich, da factory Methode in andere Klasse im selben Package liegt
 {
 }

} public class Bar {

 Bar() //Konstruktor nur für package zugänglich, da factory Methode in andere Klasse im selben Package liegt
 {
 }

} public class FooBarFactory {

 public static Foo getFoo (Settings s) //Factory - Methode für Foo
 {
   Foo f = new Foo(); //erlaubt
   //intialisiere f
   return f;
 }
 public static Bar getBar (Settings s) //Factory - Methode für Bar
 {
   Bar b = new Bar(); //erlaubt
   //intialisiere b
   return b;
 }

} </code=java>

• Mit Hilfe einer "Abstract Factory":

Erklärendes Bild
Das Grundkonzept sieht so aus, wie bei der Factory-Klasse oben. Allerdings sind in diesem Falle alle Klassen abstrakt. Es kann jetzt sowohl von der Factory-Klasse als auch von den faktorisierten (Achtung, meine Wortschöpfung) Klassen mehrere unterschiedliche Ableitungen A, B, C... geben. Die Klasse FooBarFactoryA stellt dann eben FooA und BarA her, und FooBarFactoryB stellt FooB und BarB her. Am deutlichsten macht das folgender Beispielcode aus dem Javabuch: <code=java>/* Listing1010.java */

//------------------------------------------------------------------ //Abstrakte Produkte //------------------------------------------------------------------ abstract class Product1 { }

abstract class Product2 { }

//------------------------------------------------------------------ //Abstrakte Factory //------------------------------------------------------------------ abstract class ProductFactory {

 public abstract Product1 createProduct1();

 public abstract Product2 createProduct2();

 public static ProductFactory getFactory(String variant)
 {
   ProductFactory ret = null;
   if (variant.equals("A")) {
     ret = new ConcreteFactoryVariantA();
   } else if (variant.equals("B")) {
     ret = new ConcreteFactoryVariantB();
   }
   return ret;
 }

 public static ProductFactory getDefaultFactory()
 {
   return getFactory("A");
 }

}

//------------------------------------------------------------------ //Konkrete Produkte für Implementierungsvariante A //------------------------------------------------------------------ class Product1VariantA extends Product1 { }

class Product2VariantA extends Product2 { }

//------------------------------------------------------------------ //Konkrete Factory für Implementierungsvariante A //------------------------------------------------------------------ class ConcreteFactoryVariantA extends ProductFactory {

 public Product1 createProduct1()
 {
   return new Product1VariantA();
 }

 public Product2 createProduct2()
 {
   return new Product2VariantA();
 }

}

//------------------------------------------------------------------ //Konkrete Produkte für Implementierungsvariante B //------------------------------------------------------------------ class Product1VariantB extends Product1 { }

class Product2VariantB extends Product2 { }

//------------------------------------------------------------------ //Konkrete Factory für Implementierungsvariante B //------------------------------------------------------------------ class ConcreteFactoryVariantB extends ProductFactory {

 public Product1 createProduct1()
 {
   return new Product1VariantB();
 }

 public Product2 createProduct2()
 {
   return new Product2VariantB();
 }

} </code=java>

Dieser Artikel (oder zumindest ein Teil von ihm) ist faktisch falsch. Beteilige dich an der Diskussion, wie man ihn berichtigen könnte.