Jaka jest podstawowa różnica między fabrycznymi i abstrakcyjnymi wzorami fabrycznymi?

Wzorkiem Factory produkować przypadki wdrożeń ( Apple, Banana, Cherry, itd) konkretnego interfejsu - na przykład IFruit.

Dzięki wzorowi fabryki abstrakcyjnej zapewniasz każdemu sposób na zapewnienie własnej fabryki. Dzięki temu twój magazyn może być albo, IFruitFactoryalbo IJuiceFactorybez, aby twój magazyn wiedział coś o owocach lub sokach.

Źródło tych informacji pochodzi z: http://java.dzone.com/news/intro-design-patterns-abstract

Fabryka abstrakcyjna a metoda fabryczna

Metody Fabryki Abstrakcyjnej są wdrażane jako Metody Fabryczne. Zarówno abstrakcyjny wzorzec fabryczny, jak i fabryczny wzorzec metody oddzielają system klienta od faktycznych klas implementacji poprzez typy abstrakcyjne i fabryki. Metoda fabryczna tworzy obiekty poprzez dziedziczenie, podczas gdy fabryka abstrakcyjna tworzy obiekty poprzez kompozycję.

Abstrakcyjny wzór fabryki składa się z AbstractFactory, ConcreteFactory, AbstractProduct, ConcreteProduct i Client.

Jak wdrożyć

Abstrakcyjny wzór fabryczny można zaimplementować przy użyciu wzoru metody przemysłowej, wzoru prototypowego lub wzoru singletonowego. Obiekt ConcreteFactory można zaimplementować jako Singleton, ponieważ potrzebna jest tylko jedna instancja obiektu ConcreteFactory.

Wzorzec metody fabrycznej jest uproszczoną wersją wzorca abstrakcyjnego fabryki. Wzorzec Metody Fabrycznej odpowiada za tworzenie produktów należących do jednej rodziny, natomiast wzorzec Fabryki Abstrakcyjnej dotyczy wielu rodzin produktów.

Metoda fabryczna wykorzystuje interfejsy i klasy abstrakcyjne w celu oddzielenia klienta od klasy generatora i powstałych produktów. Abstract Factory ma generator, który jest kontenerem dla kilku metod fabrycznych, wraz z interfejsami oddzielającymi klienta od generatora i produktów.

Kiedy stosować wzorzec metody fabrycznej

Użyj wzorca metody fabrycznej, gdy zachodzi potrzeba oddzielenia klienta od konkretnego używanego produktu. Użyj metody fabrycznej, aby zwolnić klienta z odpowiedzialności za tworzenie i konfigurowanie instancji produktu.

Kiedy stosować abstrakcyjny wzór fabryczny

Użyj wzorca fabryki abstrakcyjnej, gdy klienci muszą być oddzieleni od klas produktów. Szczególnie przydatny do konfiguracji i modyfikacji programu. Wzorzec fabryki abstrakcyjnej może również wymuszać ograniczenia dotyczące tego, które klasy należy stosować z innymi. Tworzenie nowych konkretnych fabryk może być bardzo pracochłonne.

Przykłady:

Przykład fabryki abstrakcyjnej 1

Ta specyfikacja dysków do przygotowywania różnych rodzajów makaronów w maszynie do makaronów to Fabryka abstrakcyjna, a każdy konkretny dysk to Fabryka. wszystkie fabryki (dyski do produkcji makaronów) dziedziczą swoje właściwości z abstrakcyjnej fabryki. Każdy dysk zawiera informacje na temat tworzenia makaronu, a producent makaronu nie.

Przykład 2 fabryki abstrakcyjnej:

Sprzęt do tłoczenia odpowiada fabryce abstrakcyjnej, ponieważ jest interfejsem dla operacji tworzących abstrakcyjne obiekty produktu. Matryce odpowiadają fabryce betonu, ponieważ tworzą konkretny produkt. Każda kategoria części (kaptur, drzwi itp.) Odpowiada produktowi abstrakcyjnemu. Określone części (tj. Drzwi od strony kierowcy dla 99 kamer) odpowiadają produktom betonowym.

Przykład metody fabrycznej:

Firma z zabawkami odpowiada Twórcy, ponieważ może wykorzystywać fabrykę do tworzenia przedmiotów produktu. Podział firmy zajmującej się zabawkami, która produkuje określony rodzaj zabawek (koń lub samochód) odpowiada ConcreteCreator.

Wzór fabryczny: fabryka produkuje wdrożenia IProduct

Abstrakcyjny wzór fabryki: fabryka produkuje IFactories, które z kolei produkują produkty IP :)

[Zaktualizuj zgodnie z komentarzami]
To, co napisałem wcześniej, jest co najmniej niepoprawne według Wikipedii . Fabryka abstrakcyjna to po prostu interfejs fabryczny. Dzięki niemu możesz przełączać fabryki w czasie wykonywania, aby zezwolić na różne fabryki w różnych kontekstach. Przykładami mogą być różne fabryki dla różnych systemów operacyjnych, dostawcy SQL, sterowniki oprogramowania pośredniego itp.

Abstrakcyjny wzór fabryki

• Zapewnij interfejs do tworzenia rodzin powiązanych lub zależnych obiektów bez określania ich konkretnych klas.

• Wzorzec Fabryki abstrakcyjnej jest bardzo podobny do wzorca Metody Fabrycznej. Jedna różnica między nimi polega na tym, że we wzorcu fabryki abstrakcyjnej klasa przenosi odpowiedzialność tworzenia instancji obiektu na inny obiekt poprzez kompozycję, podczas gdy wzór metody fabryki używa dziedziczenia i opiera się na podklasie, aby obsłużyć pożądaną instancję obiektu.

• W rzeczywistości delegowany obiekt często korzysta z metod fabrycznych w celu wykonania wystąpienia!

Wzór fabryczny

• Wzory fabryczne są przykładami wzorców kreacyjnych

• Wzory kreacyjne abstrakcyjne proces tworzenia instancji obiektu. Ukryją sposób tworzenia obiektów i pomagają uniezależnić cały system od sposobu tworzenia i komponowania jego obiektów.

• Klasowe wzorce tworzenia skupiają się na wykorzystaniu dziedziczenia do podjęcia decyzji o utworzeniu instancji obiektu Metoda fabryczna

• Wzorce tworzenia obiektów skupiają się na delegowaniu instancji do innego obiektu Abstract Factory

Odniesienie: Fabryka kontra fabryka abstrakcyjna

Metoda fabryczna: masz fabrykę, która tworzy obiekty, które wywodzą się z określonej klasy bazowej

Fabryka abstrakcyjna: masz fabrykę, która tworzy inne fabryki , a te z kolei tworzą obiekty pochodzące z klas podstawowych. Robisz to, ponieważ często nie chcesz po prostu utworzyć jednego obiektu (jak w metodzie Factory) - raczej chcesz utworzyć kolekcję powiązanych obiektów.

Fabryka abstrakcyjna to interfejs do tworzenia powiązanych obiektów, ale metoda fabryczna jest metodą. Fabryka abstrakcyjna jest realizowana metodą fabryczną.

Podstawowa różnica:

Fabryka: Tworzy obiekty bez ujawniania klientowi logiki tworzenia instancji.

Metoda fabryczna : Zdefiniuj interfejs do tworzenia obiektu, ale pozwól, aby podklasy zdecydowały, którą klasę utworzyć. Metoda Factory pozwala klasie odroczyć tworzenie instancji do podklas

Fabryka abstrakcyjna : zapewnia interfejs do tworzenia rodzin powiązanych lub zależnych obiektów bez określania ich konkretnych klas.

Wzorzec AbstractFactory używa kompozycji do delegowania odpowiedzialności za tworzenie obiektu do innej klasy, podczas gdy metoda Factory wzorzec wykorzystuje dziedziczenie i do tworzenia obiektu wykorzystuje klasę pochodną lub podklasę

Z artykułów oodesign :

Schemat klasy fabrycznej :

Przykład: 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;
   }
}

Fabryka niestatyczna implementująca przykład FactoryMethod jest dostępna w tym poście:

Wzory projektowe: Fabryka kontra metoda fabryczna kontra fabryka abstrakcyjna

Kiedy używać: Klient potrzebuje tylko klasy i nie dba o to, jaką konkretną implementację otrzymuje.

Klasa metody fabrycznej digaram:

Kiedy używać: Klient nie wie, jakie konkretne klasy będzie musiał utworzyć w czasie wykonywania, ale chce tylko uzyskać klasę, która wykona zadanie.

Abstrakcyjny schemat klasy Factory z dzone

Kiedy stosować: Gdy system musi utworzyć wiele rodzin produktów lub chcesz udostępnić bibliotekę produktów bez ujawniania szczegółów implementacji.

Przykłady kodu źródłowego w powyższych artykułach bardzo dobrze rozumieją pojęcia.

Powiązane pytanie SE z przykładem kodu:

Wzór fabryczny. Kiedy stosować metody fabryczne?

Różnice:

1. Abstrakcyjne klasy Factory są często implementowane za pomocą metod fabrycznych, ale można je również zaimplementować przy użyciu Prototypu
2. Projekty zaczynają się od Metody Fabrycznej (mniej skomplikowane, bardziej konfigurowalne, podklasy rozprzestrzeniają się) i ewoluują w kierunku innych wzorców tworzenia (bardziej elastycznych, bardziej złożonych), w których potrzebna jest większa elastyczność.
3. Metody fabryczne są zwykle wywoływane w ramach metod szablonów.

Inne przydatne artykuły:

factory_method z zaopatrzenia

abstract_factory z zaopatrzenia

abstrakcyjny wzór fabryczny z dziennika dziennikalewskiego

Przykład / scenariusz dla fabryki abstrakcyjnej

Mieszkam w miejscu, gdzie pada deszcz w porze deszczowej, w zimie pada śnieg, a latem jest gorąco i słonecznie. Potrzebuję różnego rodzaju ubrań, aby uchronić się przed żywiołami. Aby to zrobić, idę do sklepu w pobliżu mojego domu i proszę o odzież / przedmioty do ochrony. Właściciel sklepu daje mi odpowiedni przedmiot w zależności od środowiska i głębokości kieszeni. Przedmioty, które mi daje, mają ten sam poziom jakości i przedziału cenowego. Ponieważ jest świadomy moich standardów, łatwo mu to zrobić. Ale kiedy bogaty facet z drugiej strony ulicy ma takie same wymagania, dostaje drogi markowy przedmiot. Jedną zauważalną rzeczą jest to, że wszystkie elementy, które mi daje, uzupełniają się pod względem jakości, standardu i kosztu. Można powiedzieć, że idą ze sobą. To samo dotyczy przedmiotów, które otrzymuje ten bogaty facet.

Patrząc na powyższy scenariusz, doceniam teraz skuteczność właściciela sklepu. Mogę zastąpić tego sklepikarza sklepem abstrakcyjnym. Przedmioty, które otrzymujemy z przedmiotami abstrakcyjnymi oraz ja i bogaci jako klienci perspektywiczni. Potrzebujemy tylko produktu / produktu, który odpowiada naszym potrzebom.

Teraz mogę z łatwością zobaczyć siebie rozważającą sklep internetowy, który zapewnia zestaw usług dla jego licznych klientów. Każdy klient należy do jednej z trzech grup. Gdy użytkownik grupy premium otwiera stronę, dostaje świetny interfejs użytkownika, wysoce spersonalizowane okienko reklamowe, więcej opcji w menu itp. Ten sam zestaw funkcji jest prezentowany złotemu użytkownikowi, ale funkcjonalność w menu jest mniejsza, reklamy są w większości odpowiednie, i nieco mniej egronomiczny interfejs użytkownika. Ostatni to mój rodzaj użytkownika, użytkownik „wolnej grupy”. Właśnie dostałem tyle, żebym się nie obraził. Interfejs użytkownika jest absolutnym minimum, reklamy są tak daleko, że nie wiem, co się w nim znajduje, wreszcie menu się wylogowało.

Gdybym miał szansę zbudować coś w rodzaju tej strony, zdecydowanie wziąłbym pod uwagę Abstract Factory Pattern.

Produkty abstrakcyjne: panel reklamowy, menu, malarz interfejsu użytkownika.
Fabryka abstrakcyjna: Web Store User Experience
Concreate Factory: Premium User Experience, Gold User Experience, General User Experience.

Wiele osób może się dziwić, ale to pytanie jest nieprawidłowe . Jeśli usłyszysz to pytanie podczas wywiadu, musisz pomóc ankieterowi zrozumieć, gdzie jest zamieszanie.

Zacznijmy od tego, że nie ma konkretnego wzorca, który nazywa się po prostu „fabryką”. Istnieje wzorzec nazywany „Fabryką abstrakcyjną” i istnieje wzorzec nazywany „Metodą fabryczną”.

Co zatem oznacza „fabryka”? jedno z poniższych (wszystkie można uznać za prawidłowe, w zależności od zakresu odniesienia):

• Niektórzy ludzie używają go jako aliasu (skrótu) do „ Abstract Factory ”.
• Niektóre osoby używają go jako aliasu (skrótu) dla „ Metody fabrycznej ”.
• Niektóre osoby używają go jako bardziej ogólnej nazwy dla wszystkich wzorców fabrycznych / kreacyjnych. Np. Zarówno „Fabryka abstrakcyjna”, jak i „Metoda fabryczna” są fabrykami.

I niestety wiele osób używa „Fabryki” do oznaczenia innego rodzaju fabryki, która tworzy fabrykę lub fabryki (lub ich interfejsy). W oparciu o ich teorię:

Produkt implementuje IProduct, który jest tworzony przez Factory, który implementuje IFactory, który jest tworzony przez AbstractFactory.

Aby zrozumieć, jak głupie jest to, kontynuujmy nasze równanie:

AbstractFactory implementuje IAbstractFactory, który jest tworzony przez ... AbstractAbstractFactory ???

Mam nadzieję, że rozumiesz. Nie daj się zwieść i nie wymyślaj rzeczy, które nie istnieją z jakiegoś powodu.

-

PS : Fabryka Produktów to AbstractFactory, a Fabryka Fabryk Abstrakcyjnych byłaby tylko kolejnym przykładem AbstractFactory.

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

Definicje podręczników są już dostarczane przez inne odpowiedzi. Myślałem, że dam też przykład.

Więc tu PizzaIngredientsFactoryjest streszczenie fabryki , gdyż zapewnia metody stworzyć rodzinę produktów pokrewnych.

Zauważ, że każda metoda w fabryce abstrakcyjnej jest sama w sobie metodą fabryczną . Podobnie jak createDough()sama w sobie jest metodą fabryczną, której konkretne implementacje zapewnią podklasy takie jak NYPizzaIngredientsFactory. Używając tego, każda inna lokalizacja może tworzyć instancje konkretnych składników, które należą do ich lokalizacji.

Metoda fabryczna

Zapewnia przykład konkretnej implementacji

W przykładzie:
- createDough()- zapewnia konkretną implementację ciasta. To jest metoda fabryczna

Fabryka abstrakcyjna

Zapewnia interfejs do tworzenia rodziny powiązanych obiektów

Na przykład:
- PizzaIngredientsFactoryJest to streszczenie fabryki, gdyż pozwala na tworzenie powiązanego zestawu obiektów, takich jak Dough, Clams, Sauce. Do tworzenia każdej rodziny obiektów zapewnia metodę fabryczną.

Przykład z wzorców projektowych Head First

Mam kilka uwag do odpowiedzi w odpowiedzi Johna:

Fabryka abstrakcyjna to fabryka fabryk!

Z „Factory Method” (bo tylko „fabryka” jest niejednoznaczne), można produkować implementacje ( Lemon, Orangeetc.) dotyczące konkretnego interfejsu - na przykład IFruit. Można by nazwać tę fabrykę CitricFruitFactory.

Ale teraz chcesz stworzyć inne rodzaje owoców, których CitricFruitFactory nie jest w stanie stworzyć. Może kod CitricFruitFactorynie miałby sensu, gdybyś utworzyłStrawberry w nim (truskawka nie jest owocem cytrynowym!).

Więc można utworzyć nową fabrykę o nazwie RedFruitFactory, która produkuje Strawberry, Raspberryitp

Jak powiedział John Feminella: „Za pomocą wzoru Fabryka abstrakcyjna tworzysz implementacje określonego interfejsu Fabryki - np IFruitFactory. Każdy z nich wie, jak tworzyć różne rodzaje owoców”.

Te implementacje IFruitFactorysą CitricFruitFactoryi RedFruitFactory!

Moje źródła są: StackOverflow, tutorialspoint.com, programmers.stackexchange.comi CodeProject.com.

Factory Method(nazywany także Factory) służy do odłączania klienta od Interfaceimplementacji. Na przykład mamy Shapeinterfejs z dwoma Circlei Squareimplementacjami. Zdefiniowaliśmy klasę fabryczną za pomocą metody fabrycznej z parametrem determinującym, takim jak Typei nowa powiązana implementacja Shapeinterfejsu.

Abstract Factoryzawiera kilka metod fabrycznych lub interfejs fabryczny przez kilka implementacji fabrycznych. Dla następnej powyższej próbki mamy Colorinterfejs z dwoma Redi Yellowimplementacjami. Zdefiniowaliśmy ShapeColorFactoryinterfejs z dwoma RedCircleFactoryi YellowSquareFactory. Poniższy kod wyjaśniający tę koncepcję:

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

Tutaj różnica między FactoryMethodi AbstractFactory. Factory Methodpo prostu zwraca konkretną klasę interfejsu, ale Abstract Factoryzwraca factory of factory. Innymi słowy, Abstract Factoryzwraca różne kombinacje serii interfejsów.

Mam nadzieję, że moje wyjaśnienie przyda się.

Główną różnicą w tych fabrykach jest to, co chcesz robić z fabrykami i kiedy chcesz z nich korzystać.

Czasami, gdy wykonujesz IOC (odwrócenie kontroli, np. Wstrzykiwanie konstruktora), wiesz, że możesz tworzyć obiekty stałe. Jak wspomniano w powyższym przykładzie owoców, jeśli jesteś gotowy do tworzenia obiektów owoców, możesz użyć prostego wzoru fabrycznego .

Ale wiele razy nie chcesz tworzyć obiektów stałych, będą one pojawiać się później w toku programu. Ale konfiguracja mówi ci, jakiej fabryki chcesz użyć na początku, zamiast tworzyć obiekty, możesz przekazać konstruktorom w IOC fabryki, które pochodzą ze wspólnej klasy fabryki.

Myślę więc, że dotyczy to także czasu życia i stworzenia obiektu.

Zarówno Factory Methodi Abstract Factoryutrzymać klientów odłączony od rodzaju betonu. Oba tworzą obiekty, ale Factorymetoda używa dziedziczenia natomiastAbstract Factory kompozycja.

Factory MethodJest dziedziczone w podklasach do tworzenia obiektów betonowych (produkty) mając na uwadze,Abstract Factory zapewniają interfejs do tworzenia rodzinę pokrewnych produktów i podklasy tych interfejsu określić sposób tworzenia produktów pokrewnych.

Następnie te podklasy, gdy instancja jest przekazywana do klas produktów, gdzie jest używana jako typ abstrakcyjny. Powiązane produkty Abstract Factorysą często wdrażane przy użyciu Factory Method.

Rozszerzenie odpowiedzi Johna Feminelli:

Apple, Banana, CherryNarzędzia FruitFactoryoraz posiada metodę zwaną Createktóry jest odpowiedzialny tworzenia jabłko lub banana lub wiśniowy. Skończyłeś ze swoją Factorymetodą.

Teraz chcesz Createspecjalną sałatkę z owoców i oto twoja Fabryka Abstrakcyjna . Abstract Factory wie, jak stworzyć specjalną sałatkę z jabłek, bananów i wiśni.

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

Z definicji możemy wyciągnąć różnice dwóch:

Fabryka: interfejs jest używany do tworzenia obiektu, ale podklasa decyduje, którą klasę utworzyć. Tworzenie obiektu odbywa się, gdy jest to wymagane.

Fabryka abstrakcyjna: wzór Fabryki abstrakcyjnej działa jak super-fabryka, która tworzy inne fabryki. We wzorcu fabryki abstrakcyjnej interfejs jest odpowiedzialny za tworzenie zestawu powiązanych obiektów lub obiektów zależnych bez określania ich konkretnych klas.

Tak więc w powyższych definicjach możemy podkreślić konkretną różnicę. to znaczy, wzór Factory jest odpowiedzialny za tworzenie obiektów, a Abstract Factory jest odpowiedzialny za tworzenie zestawu powiązanych obiektów; oczywiście oba za pośrednictwem interfejsu.

Wzór fabryczny:

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

Abstrakcyjny wzór fabryki:

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

Sprawdź tutaj: http://www.allapplabs.com/java_design_patterns/abstract_factory_pattern.htm wydaje się, że metoda Factory używa konkretnej klasy (nie abstrakcyjnej) jako klasy podstawowej, podczas gdy fabryka abstrakcyjna używa do tego klasy abstrakcyjnej. Również jeśli użyjesz interfejsu zamiast klasy abstrakcyjnej, wynikiem będzie inna implementacja wzorca fabryki abstrakcyjnej.

:RE

Abstract Factory to szablon do tworzenia różnego rodzaju interfejsów. Załóżmy, że masz projekt, który wymaga parsowania różnych typów plików csv zawierających informacje o ilości, cenie i produkcie, takie jak niektóre zawierają dane o owocach, inne o czekoladkach, a następnie po analizie musisz zaktualizować te informacje w odpowiedniej bazie danych, abyś mógł mieć teraz jedna abstrakcyjna fabryka zwraca ci parser i modyfikator, a następnie ta fabryka parserów może zwrócić ci obiekt parsera czekolady, obiekt parsera owoców itp. i podobnie fabryka modyfikatorów może zwrócić obiekt modyfikatora czekolady, obiekt modyfikatora owoców itp.

Myślę, że możemy zrozumieć różnicę między tymi dwoma, widząc przykładowy kod Java8:

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

}

Teraz pytanie brzmi: z jakiego sposobu tworzenia należy skorzystać i dlaczego: Pierwszy sposób (bez wzorca, zwykły konstruktor): tworzenie samemu nie jest dobrym pomysłem, musisz wykonać całą pracę, a kod klienta jest powiązany konkretne wdrożenie.

Drugi sposób (przy użyciu wzorca fabrycznego): zapewnia tę korzyść, że można przekazać dowolny typ implementacji, który może zapewnić inny typ czegoś w zależności od pewnych warunków (być może parametr przekazany do metody tworzenia).

Trzeci sposób (przy użyciu wzoru Fabryka abstrakcyjna): Daje to większą elastyczność. Możesz znaleźć różne typy twórców czegoś w oparciu o jakiś warunek (być może przekazany parametr).

Zauważ, że zawsze możesz uciec od wzorca fabrycznego, łącząc ze sobą dwa warunki (co nieznacznie zwiększa złożoność kodu i sprzężenie). Wydaje mi się, że dlatego rzadko widzimy rzeczywiste przypadki użycia wzorca abstrakcyjnego.