Was ist der grundlegende Unterschied zwischen den Factory und Abstract Factory Design Patterns?

Question

Was ist der grundlegende Unterschied zwischen Factory und Abstract Factory Patterns?

Answer 1

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

Fabrik: Eine Schnittstelle wird zur Erstellung eines Objekts verwendet, aber die Unterklasse entscheidet, welche Klasse instanziiert werden soll. Die Erstellung eines Objekts erfolgt, wenn es erforderlich ist.

Abstrakte Fabrik: Das Muster Abstract Factory fungiert als Superfabrik, die andere Fabriken erstellt. Im Abstract Factory-Muster ist eine Schnittstelle für die Erstellung einer Reihe von verwandten oder abhängigen Objekten verantwortlich, ohne deren konkrete Klassen zu spezifizieren.

In den obigen Definitionen können wir also einen besonderen Unterschied hervorheben, nämlich dass das Factory-Muster für die Erstellung von Objekten zuständig ist und die Abstract Factory für die Erstellung einer Reihe von verwandten Objekten; offensichtlich beide durch eine Schnittstelle.

Fabrikmuster:

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();
 }
}

Abstraktes 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();
        }
    }

Answer 2

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

---

Factory Method (auch genannt Factory ) ist für den entkoppelten Client eines Interface Umsetzung. Als Beispiel haben wir eine Shape Schnittstelle mit zwei Circle y Square Implementierungen. Wir haben eine Fabrikklasse mit einer Fabrikmethode mit einem Bestimmungsparameter wie Type und die damit verbundene neue Umsetzung von Shape Schnittstelle.

---

Abstract Factory enthält mehrere Fabrikmethoden oder eine Fabrikschnittstelle durch mehrere Fabrikimplementierungen. Für das nächste obige Beispiel haben wir eine Color Schnittstelle mit zwei Red y Yellow Implementierungen. Wir haben eine ShapeColorFactory Schnittstelle mit zwei RedCircleFactory y YellowSquareFactory . Der folgende Code soll dieses Konzept erklären:

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 y AbstractFactory . Factory Method als einfach eine konkrete Klasse einer Schnittstelle zurückgeben, sondern Abstract Factory return factory of factory . Mit anderen Worten Abstract Factory verschiedene Kombinationen aus einer Reihe von Schnittstellen zurückgeben.

---

Ich hoffe, meine Erklärung ist hilfreich.

Answer 3

Zu Johns Antwort habe ich einige Punkte beizutragen, und zwar wie folgt

Die abstrakte Fabrik ist eine Fabrik der Fabriken!

Mit der "Factory-Methode" (denn "Factory" allein ist mehrdeutig) erzeugen Sie Implementierungen ( Lemon , Orange usw.) einer bestimmten Schnittstelle - sagen wir, IFruit . Diese Fabrik könnte genannt werden CitricFruitFactory .

Nun möchten Sie aber eine andere Obstsorte erstellen, die die CitricFruitFactory nicht erstellen kann. Vielleicht ist der Code von CitricFruitFactory würde keinen Sinn machen, wenn Sie eine Strawberry enthalten (Erdbeeren sind keine Zitrusfrüchte!).

Sie könnten also eine neue Factory namens RedFruitFactory das produziert Strawberry , Raspberry , usw.

Wie John Feminella sagte: "Mit dem abstrakten Factory-Muster erzeugen Sie Implementierungen einer bestimmten Factory-Schnittstelle - z. B., IFruitFactory . Jeder von ihnen weiß, wie man verschiedene Arten von Früchten erzeugt".

Die Umsetzung von IFruitFactory sind CitricFruitFactory y RedFruitFactory !

Answer 4

Der Hauptunterschied bei diesen Fabriken besteht darin, was man mit den Fabriken machen will und wann man sie benutzen will.

Manchmal, wenn Sie IOC (Inversion der Kontrolle, z. B. Konstruktorinjektion) durchführen, wissen Sie, dass Sie feste Objekte erstellen können. Wie im obigen Beispiel der Früchte erwähnt, können Sie, wenn Sie bereit sind, Objekte aus Früchten zu erstellen, einfache Fabrikmuster .

In vielen Fällen möchten Sie jedoch keine soliden Objekte erstellen, diese kommen erst später im Programmablauf hinzu. Aber die Konfiguration sagt Ihnen, welche Art von Fabrik Sie zu Beginn verwenden wollen. Anstatt Objekte zu erstellen, können Sie Fabriken, die von einer gemeinsamen Fabrikklasse abgeleitet sind, an den Konstruktor in IOC weitergeben.

Ich denke, es geht auch um die Lebensdauer und die Erstellung von Objekten.

Answer 5

Erweiterung der Antwort von John Feminella:

Apple , Banana , Cherry implementiert FruitFactory und das hat eine Methode namens Create die allein für die Erzeugung von Apfel, Banane oder Kirsche verantwortlich ist. Sie sind fertig, mit Ihrem Factory Methode.

Jetzt wollen Sie Create einen speziellen Salat aus Ihren Früchten und da kommt Ihr Abstrakte Fabrik . Abstract Factory weiß, wie man aus Apfel, Banane und Kirsche einen besonderen Salat zaubert.

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.
    }
}