Abstract factory pattern - Wikipedia, the free encyclopedia - The Diigo Meta page

• 10 Dec 14
  

  sark julian
  • The abstract factory pattern provides a way to encapsulate a group of individual factories that have a common theme without specifying their concrete classes
  • the client software creates a concrete implementation of the abstract factory and then uses the generic interface of the factory to create the concrete objects that are part of the theme
• 29 Oct 14
  

  Joe Abousselam

  design-patterns

• 20 Aug 14
  

  anushri123
  • The client doesn't know (or care) which concrete objects it gets from each of these internal factories, since it uses only the generic interfaces of their products.^[1]
  • This insulates client code from object creation by having clients ask a factory object to create an object of the desired abstract type and to return an abstract pointer to the object.^[4]
  • The client code has no knowledge whatsoever of the concrete type, not needing to include any header files or class declarations related to it. The client code deals only with the abstract type. Objects of a concrete type are indeed created by the factory, but the client code accesses such objects only through their abstract interface.^[5]
  • The different factory then creates objects of a different concrete type, but still returns a pointer of the same abstract type as before — thus insulating the client code from change
  • If all factory objects are stored globally in a singleton object, and all client code goes through the singleton to access the proper factory for object creation, then changing factories is as easy as changing the singleton object.^[5]

  3 more annotations...

• 17 Dec 13
  

  Ludvig Svenonius
  • the client software creates a concrete implementation of the abstract factory and then uses the generic interface
• 08 Nov 13
  

  György Hévizi
  • encapsulate a group of individual factories
  • without specifying their concrete classes
  • common theme

  1 more annotation...

• 07 Oct 13
  

  rocketshooter
  • way to encapsulate a group of individual factories that have a common theme without specifying their concrete classes
  • uses the generic interface of the factory to create the concrete objects that are part of the theme
  • lient software creates a concrete implementation of the abstract factory
  • normal usage
  • client does not know
  • which concrete objects it gets from each of these internal factories
  • nly the generic interfaces of their products
  • eparates the details of implementation of a set of objects from their general usage
  • provides interfaces to create a number of products
  • abstract factory class DocumentCreator
  • example
  • system would have any number of derived concrete versions of the DocumentCreator class like FancyDocumentCreator or ModernDocumentCreator,
  • createResume()
  • createLetter()
  • ach with a different implementation of createLetter() and createResume()
  • would create a corresponding object like FancyLetter or ModernResume
  • Each of these products is derived from a simple abstract class like Letter or Resume
  • client code would get an appropriate instance of the DocumentCreator and call its factory methods
  • resulting objects would be created from the same DocumentCreator implementation
  • would share a common theme (they would all be fancy or modern objects).
  • client would only need to know how to handle the abstract Letter or Resume class, not the specific version that it got from the concrete facto
  • makes it possible to interchange concrete implementations without changing the code that uses them
  • may result in unnecessary complexity and extra work in the initial writing of code

  21 more annotations...

• 27 Jul 13
  

  Xuan Dong

  qual designPattern

  • insulates client code from object creation by having clients ask a factory object to create an object of the desired abstract type and to return an abstract pointer to the object
  • The client code has no knowledge whatsoever of the concrete type, not needing to include any header files or class declarations related to it.
  • Adding new concrete types is done by modifying the client code to use a different factory, a modification that is typically one line in one file
  • If all factory objects are stored globally in a singleton object, and all client code goes through the singleton to access the proper factory for object creation, then changing factories is as easy as changing the singleton object.^[5]

  2 more annotations...

• 30 Mar 13
  

  marco_antonio_almeida_silva

  abstract factory posa architecture design pattern designpattern development programming

• 16 Jan 13
  

  Chunyang Liu

  design_pattern oo

• 13 Jul 12
  

  LeStef DuSud

  programming Pattern .net

  • Abstract factory pattern
• 18 Jun 12
  

  nox winter
  • Abstract factory pattern
  • Example
  • /* GUIFactory example -- */

  1 more annotation...

• 15 Apr 11
  

  Amir Rosenblatt

  factory abstract pattern programming

• 10 Mar 10
  

  akiraliu

  pattern

• 20 May 09
  

  pilgrim78

  A software design pattern, the Abstract Factory Pattern provides a way to encapsulate a group of individual factories that have a common theme. In normal usage, the client software would create a concrete implementation of the abstract factory and then us

  programming patterns design wikipedia

• 24 Nov 08
  

  Sachin Sharma

  Abstract Factory

  java design design_pattern

• 04 Aug 08
  

  D R

  factory elmélet programming development wikipedia design-pattern fromDelicious

• 13 May 08
  

  Jonathan Lovelace

  patterns

• 09 Aug 07
  

  aj

  design_patterns development programming java reference

• 19 Jul 07
  

  fletort

  factory c++ architecture patterns designpatterns

• 10 May 07
  

  rineone

  design pattern factory

Would you like to comment?

Join Diigo for a free account, or sign in if you are already a member.