Abstrakte Fabrik – das hört sich am kompliziertesten an, also weiter damit. Die abstrakte Fabrik ist ein Erzeugungsmuster und dient dazu, sich von der Erzeugung ganzer Produktfamilien unabhängig zu machen. Ein prominentes Beispiel sind Fabriken zur Erzeugung von Betriebssystemabhängigen Oberflächenelementen. Es könnte eine Fabrik MSFactory und eine Fabrik MacFactory geben, die beide verschiedene Familien von Oberflächenelementen zu Verfügung stellen. Da auch die Produkte dieselbe Schnittstelle besitzen (z.B. Fenster verschieden, oder Größe ändern), kann die Fabrik gewechselt werden, um die Software auf verschiedenen System laufen zu lassen.
Ich habe mir ein anderes Beispiel einfallen lassen. Ich denke da an ein Ayurveda-Kurhotel, in dem Gäste in drei Gruppen gemäß ihrem Dosha eingeteilt werden und eine Diät machen. Das Bedienungspersonal soll sich nicht um die Erzeugung der Mahlzeiten Gedanken machen müssen, sondern nur wissen, um welche Tageszeit es sich handelt und welches das Dosha des Gastes ist. Deshalb gibt es für die Doshas Kapha, Vata und Pitta jeweils eine eigene Factory, die Frühstück, Mittagessen und Abendessen erstellt.
Hier der Code (C#):
using System;
namespace AbstractFactoryPatternExample
{
public interface IAyurvedaMealFactory
{
IBreakfast CreateBreakfast();
ILunch CreateLunch();
ISupper CreateSupper();
}
public interface IBreakfast{}
public interface ILunch{}
public interface ISupper{}
public class KaphaBreakfast : IBreakfast{}
public class PittaBreakfast : IBreakfast{}
public class VataBreakfast : IBreakfast{}
public class KaphaLunch : ILunch{}
public class PittaLunch : ILunch{}
public class VataLunch : ILunch{}
public class KaphaSupper : ISupper{}
public class PittaSupper : ISupper{}
public class VataSupper : ISupper{}
class KaphaMealFactory : IAyurvedaMealFactory
{
public IBreakfast CreateBreakfast()
{
return new KaphaBreakfast();
}
public ILunch CreateLunch()
{
return new KaphaLunch();
}
public ISupper CreateSupper()
{
return new KaphaSupper();
}
}
class PittaMealFactory : IAyurvedaMealFactory
{
public IBreakfast CreateBreakfast()
{
return new PittaBreakfast();
}
public ILunch CreateLunch()
{
return new PittaLunch();
}
public ISupper CreateSupper()
{
return new PittaSupper();
}
}
class VataMealFactory : IAyurvedaMealFactory
{
public IBreakfast CreateBreakfast()
{
return new VataBreakfast();
}
public ILunch CreateLunch()
{
return new VataLunch();
}
public ISupper CreateSupper()
{
return new VataSupper();
}
}
class MainClass
{
public static void Main (string[] args)
{
Console.WriteLine ("It's morning time and there is a kapha tourist");
Console.WriteLine ("Creating kapha breakfast ...");
IAyurvedaMealFactory kaphaFactory = new KaphaMealFactory();
IBreakfast breakfast = kaphaFactory.CreateBreakfast();
Console.WriteLine(breakfast.ToString());
Console.WriteLine ("\nIt's noon and there is a pitta tourist");
Console.WriteLine ("Creating pitta lunch ...");
IAyurvedaMealFactory pittaFactory = new PittaMealFactory();
ILunch lunch = pittaFactory.CreateLunch();
Console.WriteLine(lunch.ToString());
}
}
}
Das Interface des Produkts könnte man natürlich benutzen, um Rezepte oder Verzehrempfehlungen zu speichern. Nachteil des Musters: Man muss für jedes Produkt alle Fabriken erweitern. Jede neue Fabrik muss alle Produkte herstellen.
