it-swarm.com.de

Was ist der grundlegende Unterschied zwischen den Factory- und den Abstract Factory-Entwurfsmustern?

Was ist der grundlegende Unterschied zwischen den Factory- und den Abstract Factory-Mustern?

472
user366312

Mit dem Factory-Muster erstellen Sie Instanzen von Implementierungen (Apple, Banana, Cherry usw.) einer bestimmten Schnittstelle, z. B. IFruit.

Mit dem Muster "Abstrakte Fabrik" bieten Sie jedem die Möglichkeit, seine eigene Fabrik bereitzustellen. Dies ermöglicht Ihrem Lager, entweder ein IFruitFactory oder ein IJuiceFactory zu sein, ohne dass Ihr Lager etwas über Früchte oder Säfte wissen muss.

401
John Feminella

Quelle für diese Informationen: http://Java.dzone.com/news/intro-design-patterns-abstract

Abstrakte Fabrik vs. Fabrik Methode

Die Methoden einer Abstract Factory werden als Factory-Methoden implementiert. Sowohl das abstrakte Factory-Muster als auch das Factory-Methodenmuster entkoppeln das Client-System von den tatsächlichen Implementierungsklassen über die abstrakten Typen und Factorys. Die Factory-Methode erstellt Objekte durch Vererbung, während die Abstract Factory Objekte durch Komposition erstellt.

Das abstrakte Fabrikmuster besteht aus einer AbstractFactory, einer ConcreteFactory, einem AbstractProduct, einem ConcreteProduct und einem Client.

Wie implementieren

Das abstrakte Fabrikmuster kann unter Verwendung des Fabrikmethodenmusters, des Prototypmusters oder des Singleton-Musters implementiert werden. Das ConcreteFactory-Objekt kann als Singleton implementiert werden, da nur eine Instanz des ConcreteFactory-Objekts benötigt wird.

Das Factory-Methodenmuster ist eine vereinfachte Version des abstrakten Factory-Musters. Das Factory-Methodenmuster ist für die Erstellung von Produkten verantwortlich, die zu einer Familie gehören, während das abstrakte Factory-Muster mehrere Produktfamilien behandelt.

Die Factory-Methode verwendet Schnittstellen und abstrakte Klassen, um den Client von der Generatorklasse und den resultierenden Produkten zu entkoppeln. Abstract Factory verfügt über einen Generator, der ein Container für mehrere Factory-Methoden ist, sowie Schnittstellen, die den Client vom Generator und den Produkten entkoppeln.

Verwendung des Factory-Methodenmusters

Verwenden Sie das Factory-Methodenmuster, wenn ein Client von einem bestimmten Produkt, das er verwendet, abgekoppelt werden muss. Verwenden Sie die Factory-Methode, um einen Kunden von der Verantwortung für das Erstellen und Konfigurieren von Instanzen eines Produkts zu entbinden.

Verwendung des abstrakten Factory-Musters

Verwenden Sie das Abstract Factory-Muster, wenn Clients von Produktklassen abgekoppelt werden müssen. Besonders nützlich für die Programmkonfiguration und -änderung. Das Abstract Factory-Muster kann auch Einschränkungen erzwingen, welche Klassen mit anderen verwendet werden müssen. Es kann eine Menge Arbeit sein, neue konkrete Fabriken herzustellen.

Beispiele:

Beispiel 1 für eine abstrakte Fabrik

Diese Spezifikation für die Scheiben zur Herstellung verschiedener Arten von Teigwaren in einem Teigwarenhersteller ist die abstrakte Fabrik, und jede spezifische Scheibe ist eine Fabrik. Alle Fabriken (Pasta Maker Disks) erben ihre Eigenschaften von der abstrakten Factory. Jede einzelne Festplatte enthält die Informationen zum Erstellen der Pasta, der Pastahersteller jedoch nicht.

Beispiel 2 für eine abstrakte Fabrik:

Die Stempelausrüstung entspricht der Abstract Factory, da sie eine Schnittstelle für Vorgänge ist, mit denen abstrakte Produktobjekte erstellt werden. Die Matrizen entsprechen der Betonfabrik, da sie ein Betonprodukt erzeugen. Jede Teilekategorie (Haube, Tür usw.) entspricht dem abstrakten Produkt. Spezifische Teile (d. H. Fahrertür für 99 camry) entsprechen den konkreten Produkten.

Beispiel für die Factory-Methode:

Die Spielzeugfirma entspricht dem Schöpfer, da sie die Fabrik zum Erstellen von Produktobjekten verwenden kann. Die Abteilung der Spielzeugfirma, die einen bestimmten Spielzeugtyp (Pferd oder Auto) herstellt, entspricht dem ConcreteCreator.

142

Fabrikmuster: Die Fabrik produziert IProduct-Implementierungen

Abstract Factory Pattern: Eine Factory-Factory produziert IFactories, die wiederum IProducts produziert :)

[Update nach den Kommentaren]
Was ich vorher geschrieben habe, ist nach Wikipedia zumindest nicht korrekt. Eine abstrakte Fabrik ist einfach eine Fabrikschnittstelle. Damit können Sie Ihre Fabriken zur Laufzeit wechseln, um verschiedene Fabriken in verschiedenen Kontexten zuzulassen. Beispiele könnten verschiedene Fabriken für verschiedene Betriebssysteme, SQL-Anbieter, Middleware-Treiber usw. sein.

97
cwap

Das abstrakte Fabrikmuster

  • Stellen Sie eine Schnittstelle zum Erstellen von Familien verwandter oder abhängiger Objekte bereit, ohne deren konkrete Klassen anzugeben.

  • Das abstrakte Factory-Muster ist dem Factory-Methodenmuster sehr ähnlich. Ein Unterschied besteht darin, dass beim Abstract Factory-Muster eine Klasse die Verantwortung für die Objektinstanziierung über die Komposition an ein anderes Objekt delegiert, während das Factory-Methodenmuster die Vererbung verwendet und sich auf eine Unterklasse stützt, um die gewünschte Objektinstanziierung zu handhaben.

  • Tatsächlich verwendet das delegierte Objekt häufig Factory-Methoden, um die Instanziierung durchzuführen!

Fabrik muster

  • Factory-Muster sind Beispiele für Kreationsmuster

  • Kreative Muster abstrahieren den Objektinstanziierungsprozess. Sie verbergen, wie Objekte erstellt werden, und machen das Gesamtsystem unabhängig davon, wie seine Objekte erstellt und zusammengesetzt werden.

  • Klassenerstellungsmuster konzentrieren sich auf die Verwendung der Vererbung, um das zu instanziierende Objekt zu bestimmen. Factory-Methode

  • Objekterstellungsmuster konzentrieren sich auf die Delegation der Instanziierung an ein anderes Objekt Abstract Factory

Referenz: Factory vs Abstract Factory

42
Syed Tayyab Ali

Factory-Methode: Sie haben eine Factory, die Objekte erstellt, die von einer bestimmten Basisklasse abgeleitet sind

Abstrakte Factory: Sie haben eine Factory, die andere Factorys erstellt , und diese Factorys erstellen wiederum Objekte, die von Basisklassen abgeleitet sind. Sie tun dies, weil Sie häufig nicht nur ein einzelnes Objekt erstellen möchten (wie bei der Factory-Methode), sondern eine Sammlung zusammengehöriger Objekte erstellen möchten.

38
Craig Schwarze

Abstract Factory ist eine Schnittstelle zum Erstellen verwandter Objekte, aber Factory-Methode ist eine Methode. Abstract Factory wird nach der Factory-Methode implementiert.

enter image description here

37
Trying

Grundlegender Unterschied:

Factory: Erstellt Objekte, ohne die Instanziierungslogik für den Client verfügbar zu machen.

Factory Method: Definieren Sie eine Schnittstelle zum Erstellen eines Objekts, aber lassen Sie die Unterklassen entscheiden, welche Klasse instanziiert werden soll. Mit der Factory-Methode kann eine Klasse die Instanziierung auf Unterklassen verschieben

Abstract Factory: Bietet eine Schnittstelle zum Erstellen von Familien verwandter oder abhängiger Objekte, ohne deren konkrete Klassen anzugeben.

AbstractFactory Muster verwendet Komposition, um die Verantwortung für das Erstellen von Objekten an eine andere Klasse zu delegieren, während Factory-Methode Muster Vererbung verwendet und sich beim Erstellen von Objekten auf abgeleitete Klassen oder Unterklassen stützt

Aus oodesign Artikeln:

Factory Klassendiagramm:

enter image description here

Beispiel: StaticFactory

 public class ShapeFactory {

   //use getShape method to get object of type shape 
   public static Shape getShape(String shapeType){
      if(shapeType == null){
         return null;
      }     
      if(shapeType.equalsIgnoreCase("CIRCLE")){
         return new Circle();

      } else if(shapeType.equalsIgnoreCase("RECTANGLE")){
         return new Rectangle();

      } else if(shapeType.equalsIgnoreCase("SQUARE")){
         return new Square();
      }

      return null;
   }
}

Ein nicht statisches Factory-Implementierungsbeispiel für FactoryMethod finden Sie in diesem Beitrag:

Entwurfsmuster: Factory vs Factory-Methode vs Abstract Factory

Verwendungszeitpunkt: Der Client benötigt nur eine Klasse und kümmert sich nicht darum, welche konkrete Implementierung er erhält.

Factory-Methode Klasse digaram:

enter image description here

Verwendungszweck: Der Client weiß nicht, welche konkreten Klassen zur Laufzeit erstellt werden müssen, sondern möchte nur eine Klasse erhalten, die das erledigt Job.

Abstract Factory Klassendiagramm aus dzone

enter image description here

Verwendungszweck: Wenn Ihr System mehrere Produktfamilien erstellen muss oder Sie eine Produktbibliothek bereitstellen möchten, ohne die Implementierungsdetails preiszugeben.

Quellcodebeispiele in den obigen Artikeln sind sehr gut, um die Konzepte klar zu verstehen.

Verwandte SE-Frage mit Codebeispiel:

Factory Pattern. Wann sind Factory-Methoden anzuwenden?

Unterschiede:

  1. Abstract Factory-Klassen werden häufig mit Factory-Methoden implementiert, können jedoch auch mit Prototype implementiert werden
  2. Entwürfe beginnen mit der Factory-Methode (weniger kompliziert, anpassbarer, Unterklassen vermehren sich) und entwickeln sich zu anderen Kreationsmustern (flexibler, komplexer), bei denen mehr Flexibilität erforderlich ist.
  3. Factory-Methoden werden normalerweise in Template-Methoden aufgerufen.

Andere nützliche Artikel:

factory_method aus der Beschaffung

abstract_factory aus der Beschaffung

abstract-factory-design-pattern von journaldev

34
Ravindra babu

Beispiel/Szenario für Abstract Factory

Ich lebe an einem Ort, an dem es in der Regenzeit regnet, im Winter schneit und im Sommer heiß und sonnig ist. Ich brauche andere Kleidung, um mich vor den Elementen zu schützen. Dazu gehe ich in den Laden in der Nähe meines Hauses und bitte um Kleidung/Gegenstände, um mich zu schützen. Der Ladenbesitzer gibt mir den passenden Artikel für die Umgebung und die Tiefe meiner Tasche. Die Gegenstände, die er mir gibt, sind von gleicher Qualität und Preisklasse. Da er sich meiner Standards bewusst ist, fällt es ihm leicht, dies zu tun. Aber wenn ein reicher Mann auf der anderen Straßenseite die gleichen Anforderungen hat, bekommt er ein teures Markenprodukt. Auffällig ist, dass sich alle Artikel, die er mir gibt, in Bezug auf Qualität, Standard und Kosten ergänzen. Man kann sagen, dass sie miteinander gehen. Gleiches gilt für die Gegenstände, die dieser reiche Kerl bekommt.

Wenn ich mir also das obige Szenario anschaue, schätze ich jetzt die Effizienz des Ladenbesitzers. Ich kann diesen Ladenbesitzer durch einen Abstract-Shop ersetzen. Die Gegenstände bekommen wir mit abstrakten Gegenständen und mir und den Reichen als Perspektive-Kunden. Wir brauchen nur das Produkt/den Gegenstand, der unseren Bedürfnissen entspricht.

Jetzt kann ich mir leicht vorstellen, einen Online-Shop in Betracht zu ziehen, der seinen zahlreichen Kunden eine Reihe von Diensten bietet. Jeder Kunde gehört zu einer der drei Gruppen. Wenn ein Premium-Gruppenbenutzer die Site öffnet, erhält er eine großartige Benutzeroberfläche, ein stark angepasstes Werbefenster, mehr Optionen in den Menüs usw. Dieselben Funktionen werden dem Gold-Benutzer präsentiert, aber die Funktionalität im Menü ist geringer. und etwas weniger egronomische Benutzeroberfläche. Das letzte ist meine Art von Benutzer, ein Benutzer der "freien Gruppe". Ich werde gerade genug bedient, damit ich nicht beleidigt werde. Die Benutzeroberfläche ist ein absolutes Minimum, Werbung ist so weit vom Kurs entfernt, dass ich nicht weiß, was darin enthalten ist, und schließlich hat sich das Menü nur abgemeldet.

Wenn ich die Möglichkeit bekomme, so etwas wie diese Website zu erstellen, würde ich definitiv Abstract Factory Pattern in Betracht ziehen.

Abstrakte Produkte: Werbefenster, Menü, UI Painter.
Abstract Factory: Benutzererfahrung im Web Store
Concreate Factory: Premium-Benutzererfahrung, Gold-Benutzererfahrung, Allgemeine Benutzererfahrung.

21
moajiz

Viele Leute werden sich vielleicht überrascht fühlen, aber diese Frage ist falsch . Wenn Sie diese Frage während eines Interviews hören, müssen Sie dem Interviewer helfen, zu verstehen, wo die Verwirrung ist.

Beginnen wir mit der Tatsache, dass es kein konkretes Muster gibt, das nur als "Fabrik" bezeichnet wird. Es gibt Muster, die als "Abstrakte Fabrik" bezeichnet werden, und es gibt Muster, die als "Fabrikmethode" bezeichnet werden.

Was bedeutet "Fabrik" dann? eine der folgenden Möglichkeiten (alle können je nach Umfang der Referenz als korrekt angesehen werden):

  • Einige Leute benutzen es als Alias ​​(Abkürzung) für " Abstract Factory ".
  • Einige Leute benutzen es als Alias ​​(Abkürzung) für " Factory-Methode ".
  • Einige Leute verwenden ihn als allgemeineren Namen für alle Fabrik-/Kreationsmuster. Z.B. Sowohl "Abstrakte Fabrik" als auch "Fabrikmethode" sind Fabriken.

Und, leider , verwenden viele Leute "Fabrik", um eine andere Art von Fabrik zu bezeichnen, die Fabrik oder Fabriken (oder deren Schnittstellen) schafft. Basierend auf ihrer Theorie:

Das Produkt implementiert IProduct, das von Factory erstellt wird, das IFactory implementiert, das von AbstractFactory erstellt wird.

Um zu verstehen, wie dumm das ist, setzen wir unsere Gleichung fort:

AbstractFactory implementiert IAbstractFactory, das von ... AbstractAbstractFactory ???

Ich hoffe du verstehst den Punkt. Lassen Sie sich nicht verwirren und erfinden Sie keine Dinge, die nicht aus einem bestimmten Grund existieren.

-

S. : Factory für Produkte ist AbstractFactory, und Factory für abstrakte Fabriken wäre ebenfalls nur ein Beispiel für AbstractFactory.

19
Tengiz
//Abstract factory - Provides interface to create factory of related products
interface PizzaIngredientsFactory{    
   public Dough createDough(); //Will return you family of Dough
   public Clam createClam();   //Will return you family of Clam
   public Sauce createSauce(); //Will return you family of Sauce
}

class NYPizzaIngredientsFactory implements PizzaIngredientsFactory{

   @Override
   public Dough createDough(){
      //create the concrete dough instance that NY uses
      return doughInstance;
   }

   //override other methods
} 

Die Lehrbuchdefinitionen werden bereits von anderen Antworten geliefert. Ich dachte, ich würde auch ein Beispiel dafür liefern.

Das PizzaIngredientsFactory ist hier eine abstrakte Factory , da es Methoden zum Erstellen von Produktfamilien bereitstellt.

Beachten Sie, dass jede Methode in der Abstract-Factory eine Factory-Methode für sich ist. Like createDough() ist an sich eine Factory-Methode, deren konkrete Implementierungen von Unterklassen wie NYPizzaIngredientsFactory bereitgestellt werden. Wenn Sie diese also an jedem anderen Ort verwenden, können Instanzen konkreter Zutaten erstellt werden, die zu ihrem Ort gehören.

Fabrik Methode

Bietet eine konkrete Implementierungsinstanz

Im Beispiel:
- createDough() - liefert eine konkrete Implementierung für Teig. Das ist also eine Fabrikmethode

Abstrakte Fabrik

Bietet eine Schnittstelle zum Erstellen einer Familie verwandter Objekte

Im Beispiel:
- PizzaIngredientsFactory ist eine abstrakte Factory, da sie es ermöglicht, eine verwandte Menge von Objekten wie Dough, Clams, Sauce zu erstellen. Für die Erstellung jeder Objektfamilie wird eine Factory-Methode bereitgestellt.

Beispiel aus Head First Design Patterns

16
Narendra Pathai

Ich kann mit Johns Antwort einige Punkte beisteuern:

Abstrakte Fabrik ist eine Fabrik der Fabriken!

Mit der "Factory-Methode" (weil nur "Factory" mehrdeutig ist) erstellen Sie Implementierungen (Lemon, Orange usw.) einer bestimmten Schnittstelle - sagen wir, IFruit. Diese Factory könnte CitricFruitFactory heißen.

Jetzt möchten Sie jedoch eine andere Obstsorte erzeugen, die die CitricFruitFactory nicht erzeugen kann. Vielleicht macht der Code von CitricFruitFactory keinen Sinn, wenn Sie einen Strawberry darin erstellen (Erdbeere ist keine Zitrusfrucht!).

Sie können also eine neue Factory mit dem Namen RedFruitFactory erstellen, die Strawberry, Raspberry usw. erzeugt.

Wie John Feminella sagte: "Mit dem Abstract Factory-Muster erstellen Sie Implementierungen einer bestimmten Factory-Schnittstelle - z. B. IFruitFactory. Jede dieser kann verschiedene Obstsorten herstellen. "

Diese Implementierungen von IFruitFactory sind CitricFruitFactory und RedFruitFactory!

5

Meine Quellen sind: StackOverflow, tutorialspoint.com, programmers.stackexchange.com und CodeProject.com.


Factory Method (auch Factory genannt) dient zum Entkoppeln des Clients einer Interface -Implementierung. Als Beispiel haben wir eine Shape Schnittstelle mit zwei Circle und Square Implementierungen. Wir haben eine Factory-Klasse mit einer Factory-Methode mit einem Determiner-Parameter wie Type und einer neuen zugehörigen Implementierung der Shape-Schnittstelle definiert.


Abstract Factory enthält mehrere Factory-Methoden oder eine Factory-Schnittstelle von mehreren Factory-Implementierungen. Für das nächste Beispiel oben haben wir eine Color Schnittstelle mit zwei Red und Yellow Implementierungen. Wir haben eine ShapeColorFactory Schnittstelle mit zwei RedCircleFactory und YellowSquareFactory definiert. Der folgende Code erklärt dieses Konzept:

interface ShapeColorFactory
{
    public Shape getShape();
    public Color getColor();
}

class RedCircleFactory implements ShapeColorFactory
{
    @Override
    public Shape getShape() {
        return new Circle();
    }

    @Override
    public Color getColor() {
        return new Red();
    }
}
class YellowSquareFactory implements ShapeColorFactory
{
    @Override
    public Shape getShape() {
        return new Square();
    }

    @Override
    public Color getColor() {
        return new Yellow();
    }
} 

Hier Unterschied zwischen FactoryMethod und AbstractFactory. Factory Method als einfach eine konkrete Klasse einer Schnittstelle zurückgeben, aber Abstract Factory Rückkehr factory of factory. Mit anderen Worten Abstract Factory verschiedene Mähdrescher einer Reihe von Schnittstellen zurückgeben.


Ich hoffe meine Erklärung ist hilfreich.

4
Sam

Erweiterung der Antwort von John Feminella:

Apple, Banana, Cherry implementiert FruitFactory und hat eine Methode namens Create, die allein für die Erstellung von Apple oder Banane oder Kirsche. Mit der Methode Factory sind Sie fertig.

Nun wollen Sie Create einen speziellen Salat aus Ihren Früchten und da kommt Ihr Abstract Factory. Abstract Factory versteht es, Ihren speziellen Salat aus Apfel, Banane und Kirsche herzustellen.

public class Apple implements Fruit, FruitFactory {
    public Fruit Create() {
        // Apple creation logic goes here
    }
}

public class Banana implements Fruit, FruitFactory {
    public Fruit Create() {
        // Banana creation logic goes here
    }
}

public class Cherry implements Fruit, FruitFactory {
    public Fruit Create() {
        // Cherry creation logic goes here
    }
}

public class SpecialSalad implements Salad, SaladFactory {
    public static Salad Create(FruitFactory[] fruits) {
        // loop through the factory and create the fruits.
        // then you're ready to cut and slice your fruits 
        // to create your special salad.
    }
}
3
Abdul Munim

Der Hauptunterschied in diesen Fabriken besteht darin, wann Sie mit den Fabriken arbeiten und wann Sie sie verwenden möchten.

Wenn Sie IOC (Inversion der Steuerung, z. B. Konstruktorinjektion)) ausführen, wissen Sie manchmal, dass Sie feste Objekte erstellen können von Früchten können Sie einfaches Fabrikmuster verwenden.

Wenn Sie jedoch häufig keine festen Objekte erstellen möchten, werden diese später im Programmablauf angezeigt. Die Konfiguration gibt jedoch an, welche Art von Factory Sie zu Beginn verwenden möchten. Anstatt Objekte zu erstellen, können Sie Factorys, die von einer allgemeinen Factory-Klasse abgeleitet sind, an den Konstruktor in IOC weitergeben.

Daher denke ich, dass es auch um die Lebensdauer und Schöpfung des Objekts geht.

Sowohl Factory Method Als auch Abstract Factory Entkoppeln die Clients von den konkreten Typen. Beide erstellen Objekte, aber die Methode Factory verwendet die Vererbung, während Abstract Factory Die Komposition verwendet.

Der Factory Method Wird in Unterklassen vererbt, um die konkreten Objekte (Produkte) zu erstellen, während der Abstract Factory Eine Schnittstelle zum Erstellen der Familie verwandter Produkte bereitstellt und die Unterklasse dieser Schnittstelle definiert, wie verwandte Produkte erstellt werden.

Diese Unterklassen werden dann, wenn sie instanziiert sind, in Produktklassen übergeben, wo sie als abstrakter Typ verwendet werden. Die verwandten Produkte in einem Abstract Factory Werden häufig mit Factory Method Implementiert.

3
Akash Aggarwal

Per Definition können wir die Unterschiede von zwei herausziehen:

Factory: Eine Schnittstelle wird zum Erstellen eines Objekts verwendet, die Unterklasse entscheidet jedoch, welche Klasse instanziiert werden soll. Die Erstellung des Objekts erfolgt, wenn es erforderlich ist.

Abstrakte Fabrik: Abstrakte Fabrik Muster fungiert als Superfabrik, die andere Fabriken erstellt. In Abstract Factory Pattern ist eine Schnittstelle dafür verantwortlich, eine Reihe zusammengehöriger Objekte oder abhängiger Objekte zu erstellen, ohne deren konkrete Klassen anzugeben.

In den obigen Definitionen können wir also einen bestimmten Unterschied betonen. Das heißt, Factory-Muster ist für die Erstellung von Objekten verantwortlich, und Abstract Factory ist für die Erstellung einer Reihe verwandter Objekte verantwortlich. offensichtlich beides über eine schnittstelle.

Fabrik muster:

public interface IFactory{
  void VehicleType(string n);
 }

 public class Scooter : IFactory{
  public void VehicleType(string n){
   Console.WriteLine("Vehicle type: " + n);
  }
 }

 public class Bike : IFactory{
  public void VehicleType(string n) {
  Console.WriteLine("Vehicle type: " + n);
  }
 }

 public interface IVehicleFactory{
  IFactory GetVehicleType(string Vehicle);
 }

 public class ConcreteVehicleFactory : IVehicleFactory{
 public IFactory GetVehicleType(string Vehicle){
   switch (Vehicle){
    case "Scooter":
     return new Scooter();
    case "Bike":
     return new Bike();
    default:
    return new Scooter();
  }
 }

 class Program{
  static void Main(string[] args){
   IVehicleFactory factory = new ConcreteVehicleFactory();
   IFactory scooter = factory.GetVehicleType("Scooter");
   scooter.VehicleType("Scooter");

   IFactory bike = factory.GetVehicleType("Bike");
   bike.VehicleType("Bike");

   Console.ReadKey();
 }
}

Abstrakte fabrik muster:

interface IVehicleFactory{
 IBike GetBike();
 IScooter GetScooter();
}

class HondaFactory : IVehicleFactory{
     public IBike GetBike(){
            return new FZS();
     }
     public IScooter GetScooter(){
            return new FZscooter();
     }
 }
class HeroFactory: IVehicleFactory{
      public IBike GetBike(){
            return new Pulsur();
     }
      public IScooter GetScooter(){
            return new PulsurScooter();
     }
}

interface IBike
    {
        string Name();
    }
interface IScooter
    {
        string Name();
    }

class FZS:IBike{
   public string Name(){
     return "FZS";
   }
}
class Pulsur:IBike{
   public string Name(){
     return "Pulsur";
   }
}

class FZscooter:IScooter {
  public string Name(){
     return "FZscooter";
   }
}

class PulsurScooter:IScooter{
  public string Name(){
     return "PulsurScooter";
   }
}

enum MANUFACTURERS
{
    HONDA,
    HERO
}

class VehicleTypeCheck{
        IBike bike;
        IScooter scooter;
        IVehicleFactory factory;
        MANUFACTURERS manu;

        public VehicleTypeCheck(MANUFACTURERS m){
            manu = m;
        }

        public void CheckProducts()
        {
            switch (manu){
                case MANUFACTURERS.HONDA:
                    factory = new HondaFactory();
                    break;
                case MANUFACTURERS.HERO:
                    factory = new HeroFactory();
                    break;
            }

      Console.WriteLine("Bike: " + factory.GetBike().Name() + "\nScooter: " +      factory.GetScooter().Name());
        }
  }

class Program
    {
        static void Main(string[] args)
        {
            VehicleTypeCheck chk = new VehicleTypeCheck(MANUFACTURERS.HONDA);
            chk.CheckProducts();

            chk= new VehicleTypeCheck(MANUFACTURERS.HERO);
            chk.CheckProducts();

            Console.Read();
        }
    }
2
Rashedul.Rubel

Abstract Factory ist eine Vorlage zum Erstellen verschiedener Arten von Schnittstellen. Angenommen, Sie haben ein Projekt, bei dem Sie verschiedene Arten von CSV-Dateien analysieren müssen, die mengen-, preis- und artikelspezifische Informationen enthalten. Einige enthalten Daten zu Früchten, andere zu Pralinen. Nach dem Parsen müssen Sie diese Informationen in der entsprechenden Datenbank aktualisieren Eine abstrakte Factory, die Ihre Parser- und Modifier-Factory zurückgibt, und diese Parser-Factory kann dann Ihr Chocolate-Parser-Objekt, Fruit-Parser-Objekt usw. zurückgeben. Ebenso kann Modifier Factory Chocolate-Modifier-Objekt, Fruit-Modifier-Objekt usw. zurückgeben.

1
Kapil

Überprüfen Sie hier: http://www.allapplabs.com/Java_design_patterns/abstract_factory_pattern.htm Es scheint, dass die Factory-Methode eine bestimmte Klasse (nicht abstrakt) als Basisklasse verwendet, während die Abstract Factory eine abstrakte Klasse für verwendet diese. Auch wenn eine Schnittstelle anstelle einer abstrakten Klasse verwendet wird, ist das Ergebnis eine andere Implementierung des Abstract Factory-Musters.

: D

1
hackus

Ich denke, wir können den Unterschied zwischen diesen beiden verstehen, indem wir einen Java8-Beispielcode sehen:

  interface Something{}

  interface OneWhoCanProvideSomething {
     Something getSomething();
  }

  interface OneWhoCanProvideCreatorsOfSomething{
     OneWhoCanProvideSomething getCreator();
  }


public class AbstractFactoryExample {

    public static void main(String[] args) {
        //I need something
        //Let's create one
        Something something = new Something() {};

        //Or ask someone (FACTORY pattern)
        OneWhoCanProvideSomething oneWhoCanProvideSomethingOfTypeA = () -> null;
        OneWhoCanProvideSomething oneWhoCanProvideSomethingOfTypeB = () -> null;

        //Or ask someone who knows soemone who can create something (ABSTRACT FACTORY pattern)
        OneWhoCanProvideCreatorsOfSomething oneWhoCanProvideCreatorsOfSomething = () -> null;

        //Same thing, but you don't need to write you own interfaces
        Supplier<Something> supplierOfSomething = () -> null;
        Supplier<Supplier<Something>> supplierOfSupplier = () -> null;
    }

}

Nun stellt sich die Frage, welche Art der Erstellung Sie verwenden sollten und warum: Der erste Weg (kein Muster, nur einfacher Konstruktor): Die Erstellung selbst ist keine gute Idee, Sie müssen die ganze Arbeit erledigen, und Ihr Client-Code ist daran gebunden die jeweilige Implementierung.

Der zweite Weg (unter Verwendung des Factory-Musters): Bietet den Vorteil, dass Sie jede Art von Implementierung übergeben können, die abhängig von einer bestimmten Bedingung einen anderen Typ von etwas bereitstellen kann (möglicherweise ein Parameter, der an die Erstellungsmethode übergeben wird).

Der dritte Weg (mit Abstract Factory-Muster): Dies gibt Ihnen mehr Flexibilität. Sie können verschiedene Arten von Erstellern von etwas finden, die auf einer bestimmten Bedingung basieren (möglicherweise wurde ein Parameter übergeben).

Beachten Sie, dass Sie immer mit dem Factory-Muster davonkommen können, wenn Sie zwei Bedingungen miteinander kombinieren (was die Codekomplexität und die Kopplung geringfügig erhöht). Ich denke, aus diesem Grund sehen wir selten Anwendungsfälle im wirklichen Leben des abstrakten Fabrikmusters.

1
Satyendra Kumar