Jaka jest podstawowa różnica między fabrycznymi a abstrakcyjnymi wzorami fabrycznymi? [Zamknięte]

483

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

użytkownik366312
źródło
11
Moim zdaniem jakość odpowiedzi w Różnicach między Abstrakcyjnym Wzorem Fabryki a Metodą Fabryki jest znacznie lepsza niż te tutaj.
KurzedMetal
1
Najważniejsza różnica polega na tym, że Metoda Fabryczna wykorzystuje dziedziczenie (np. Pośrednia jest pionowa createThing()), a Fabryka Abstrakcyjna używa kompozycji (np. Pośrednia jest pozioma getFactory().createThing())
David James
1
To pytanie nie jest tym, co uważają niektórzy z jego odpowiedzi. Nie przegap odpowiedzi Tengiza , która definiuje trzy odrębne terminy Factory, Abstract Factory i Factory Method.
Dave Schweisguth,

Odpowiedzi:

412

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.

John Feminella
źródło
5
@SPI Myślę, że źle mnie zrozumiałeś; sama fabryka nie musi implementować IFruit- tworzy instancję rzeczy, które implementują IFruit. Oczywiście nie musi tworzyć instancji rzeczy, które implementują określony interfejs, ale prawdopodobnie jest to zapach kodu, jeśli masz fabrykę, która produkuje rzeczy, które są ze sobą całkowicie niezwiązane.
John Feminella,
75
Fabryka produkująca fabryki. Musimy iść głębiej ...
Paul Annekov
11
Nigdy nie słyszałem o niczym bardziej niepoprawnym niż to. Jak nazwałbyś fabrykę produkującą interfejsy fabryk abstrakcyjnych (IAbstractFactory)? - Ach, rozumiem, to byłby AbstractAbstractFactory ...
Tengiz,
3
@joaquin Na przykład, gdy potrzebujesz fabryki IFruitFactory. I jak już wspomniałem, jest to całkowicie niepoprawne i wynika jedynie z pomieszania wzorów. Moja odpowiedź poniżej wyjaśnia - istnieje wzór Fabryki Abstrakcyjnej, następnie wzór Metody Fabrycznej, a następnie są zdezorientowani ludzie, którzy myślą, że Streszczenie Fabryki oznacza fabrykę innych fabryk. Fabryka jest tylko ogólnym terminem używanym do oznaczenia dowolnego z istniejących wzorców. Zobacz moją odpowiedź poniżej, aby uzyskać więcej informacji w razie potrzeby.
Tengiz
9
Ta odpowiedź jest po prostu błędna! Według tej książki GOF An Abstract Factory jest obiekt fabryczny, który implementuje interfejs fabryki, dzięki czemu fabryka betonu może być zamienione na inny podklasy. Nie ma to nic wspólnego z tworzeniem fabryk. Usuń tę odpowiedź, ludzie wprowadzają w błąd i wprowadzają w błąd!
Lii
142

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

Sudhakar Kalmari
źródło
6
Dzięki za wyjaśnienie Abstract Factory i Factory Method. Nie rozumiałem, gdzie używamy kompozycji w abstrakcyjnej fabryce do tworzenia obiektów i gdzie używamy dziedziczenia w metodzie fabrycznej. Będzie to bardzo przydatne, jeśli opublikujesz jakiś kod, aby je wyjaśnić. Dziękuję Ci bardzo. czekam na twój kod. Dzięki jeszcze raz.
Harsha
to samo tutaj, byłoby o wiele bardziej jasne, gdyby podejścia do składu i dziedziczenia pokazano w krótkim przykładzie (kod źródłowy).
Aakash
przykład kompozycji: klient klasy publicznej {produkt AbstractProduct; Akcesoria AbstractProductAccessories; Klient publiczny (fabryka AbstractFactory) {AbstractProduct product = factory.createProduct (); } public void run () {product.print (); akcesoria = product.getAccessories (); }}
Asim Ghaffar
Czy w kodzie można wykryć, który z tych dwóch wzorców został użyty?
Warlock
98

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.

cwap
źródło
4
Miły! Czy słusznie jest powiedzieć, że Fabryka Abstrakcyjna jest zbiorem Metod Fabrycznych?
Warlock
2
Wydaje mi się, że byłoby to poprawne, ale pomijałoby to także sens :) Nie-analogicznym przykładem może być FileFactory, który ma metody takie jak CreateBitmapFile () lub CreateTextFile (). Teraz przekażesz odniesienie do tej fabryki do jakiejś usługi. Ale co by się stało, gdybyś chciał przetestować swoją usługę? Będziesz musiał utworzyć interfejs IFileFactory, aby wyśmiewać dostęp do systemu plików. Teraz, w prawdziwym świecie, prawdopodobnie będziesz miał strukturę DI / IoC, która tworzy instancję IFileFactories w zależności od twoich potrzeb. W tym przypadku platforma IoC służyłaby jako fabryka abstrakcyjna.
cwap
5
Jeśli dobrze rozumiem, ta odpowiedź wydaje się sugerować, że Fabryka Abstrakcyjna zawsze produkuje kolejne IFactories, które z kolei można wykorzystać do tworzenia produktów IP. Prezentacja w GoF nie wydaje mi się tego potwierdzać, a wręcz przeciwnie: instancja fabryki abstrakcyjnej bezpośrednio produkuje same produkty IProducts. Innymi słowy, Fabryka Abstrakcyjna GoF nie jest (a raczej nie musi ) być „fabryką”.
SSJ_GZ
1
Definicja abstrakcyjnego wzorca fabrycznego jest nieprawidłowa. Fabryka abstrakcyjna zawiera jedną lub więcej metod fabrycznych, z których każda wytwarza instancję z tej samej rodziny obiektów (nie mylić z hierarchią obiektów). Chociaż abstrakcyjna fabryka może być fabryką fabryk, nie musi nią być. Jest producentem powiązanych produktów.
GiddyUpHorsey
1
Ta odpowiedź jest po prostu błędna! Według tej książki GOF An Abstract Factory jest obiekt fabryczny, który implementuje interfejs fabryki, dzięki czemu fabryka betonu może być zamienione na inny podklasy. Nie ma to nic wspólnego z tworzeniem fabryk. Usuń tę odpowiedź, ludzie wprowadzają w błąd i wprowadzają w błąd!
Lii,
42

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

Syed Tayyab Ali
źródło
3
link referencyjny nie działa
mkobit,
39

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.

Craig Schwarze
źródło
6
Jest to duplikat przyjętej odpowiedzi i jest równie niepoprawny.
jaco0646
36

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

wprowadź opis zdjęcia tutaj

Próbować
źródło
36

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 :

wprowadź opis zdjęcia tutaj

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:

wprowadź opis zdjęcia tutaj

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

wprowadź opis zdjęcia tutaj

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

Ravindra babu
źródło
21

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.

moajiz
źródło
Fajne scenariusze AbstractFactory, ale tak naprawdę nie odpowiedziałeś na pytanie, jakie są różnice między fabryką a fabryką abstrakcyjną.
Adelin
20

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.

Tengiz
źródło
jak mogę odróżnić AbstractFactory, która tworzy inne AbstractFactories, od AbstractFactory, która tworzy określone obiekty? GenericAbstractFactory? Czy AbstractFactoryFactory?
Andrew
Nie ma czegoś takiego we wzorach projektowych. Oba są instancjami wzorca AbstractFactory. Tak więc jeden AbstractFactory tworzy określone obiekty, a drugi AbstractFactory tworzy fabryki (które znów są AbstractFactory).
Tengiz,
Pewnie. Jak więc nazwać te klasy, które robią różne rzeczy? Ponieważ tworzenie innych fabryk i tworzenie innych (prostych) obiektów to dwie różne rzeczy. Nie dbam o wzorce, potrzebuję czytelnego kodu.
Andrew
3
Czytelny kod to kod ujawniający intencje. Podczas nazywania klas nie powinieneś wymieniać zbyt wielu wzorców, chyba że jest to bardzo konieczne. np. jeśli masz abstrakcyjną fabrykę, która tworzy różne transporty, możesz nazwać ją TransportCreator lub TransportFactory, a może nawet TransportMan Manufacturer. A potem, jeśli masz fabrykę tych fabryk, możesz to nazwać czymkolwiek - kimkolwiek otworzy nowych producentów. Może to może być zarządzanie przez producenta? w zasadzie nazywaj rzeczy tak, jak je nazywa Twoja firma, a NIE na podstawie wzorców, które wdrażają.
Tengiz,
16
//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

Narendra Pathai
źródło
5

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 IFruitFactoryCitricFruitFactoryi RedFruitFactory!

Fabriciorissetto
źródło
4

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

Sam
źródło
3

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.

Mahendra Vengurlekar
źródło
3

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.

Akash Aggarwal
źródło
3

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.
    }
}
Abdul Munim
źródło
2

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();
        }
    }
Rashedul.Rubel
źródło
1

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.

Kapil
źródło
1

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.

Satyendra Kumar
źródło