
	Where results make sense

Topic: Abstract factory pattern

Related Topics

Adapter pattern

Prototype pattern

Factory method pattern

Creational pattern

Builder pattern

Anonymous subroutine objects pattern

Object (computer science)

Strategy pattern

Command pattern

Bridge pattern

Singleton pattern

Lazy initialization pattern

Composite pattern

Visitor pattern

Delegation pattern

In the News (Sun 27 May 12)

EXECUTIVE POWER

Iran

ANALYSIS

Pakistan

Family compact

	Abstract Factory Patterns in C# (Site not responding. Last check: 2007-10-18)
		The Abstract Factory provides an interface to create and return one of several families of related objects.
		This pattern is found in the sheet metal stamping equipment used in the manufacture of Japanese automobiles.
		The abstract factory is a factory object that returns one of several factories.
	www.c-sharpcorner.com /Language/AbstractFactoryPatternsinCSRVS.asp (443 words)

	Abstract factory pattern - Wikipedia, the free encyclopedia
		In normal usage, the client software would create a concrete implementation of the abstract factory and then use the generic interfaces to create the concrete objects that are part of the theme.
		The factory determines the actual concrete type of object to be created, and it is here that the object is actually created (in C++, for instance, by the new operator).
		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.
	en.wikipedia.org /wiki/Abstract_factory_pattern (778 words)

	Design Pattern Synopses
		The Filter pattern is a special case of the Decorator pattern, where a data source or data sink object is wrapped to add logic to the handling of a data stream.
		The Composite pattern also allows the objects in the tree to be manipulated in a consistent manner, by requiring all of the objects in the tree to have a common superclass or interface.
		The Flyweight pattern is often combined with the Composite pattern to represent the leaf nodes of a hierarchical structure with shared objects.
	www.mindspring.com /~mgrand/pattern_synopses.htm (4381 words)

	Introduction to Design Patterns in Delphi
		This pattern is useful when you want to encapsulate the construction of a class and isolate knowledge of the concrete class from the client application through an abstract interface.
		Abstract is used in base classes to declare a method in the interface and defer its implementation to a descendant class.
		Abstract methods are never implemented in the base class and must be implemented in descendant classes to be used.
	www.obsof.com /delphi_tips/pattern.html (3216 words)

	Factory method pattern - Wikipedia, the free encyclopedia
		Factory Method, one of the patterns from the Design Patterns book, handles this problem by defining a separate method for creating the objects, which subclasses can then override to specify the derived type of product that will be created.
		Factory Methods are common in toolkits and frameworks where library code needs to create objects of types which may be subclassed by applications using the framework.
		When factory methods are used for disambiguation like this, the constructor is often made private to force clients to use the factory methods.
	en.wikipedia.org /wiki/Factory_method_pattern (816 words)

	Pattern Summaries: Abstract Factory Pattern
		Concrete factories are concrete subclasses of an abstract factory that implements its methods to create instances of concrete widget classes for the same platform.
		In that case, the abstract factory class will typically have a static variable set to the concrete factory class that is used for the duration of the program run.
		If the abstract factory object will use information provided by the requesting client to select among multiple concrete factory objects, you can hard code the selection logic and choice of concrete factory objects in the abstract factory class.
	www.developer.com /java/article.php/626161 (1739 words)

	Factory Method
		So another fellow I was discussing patterns with decided that my rather HandWaving definition of a factory method (something that looks like it gets you an object you didn't have before) was far too imprecise, and often just dead wrong.
		The pattern describes the interface, not the implementation, so questions about whether a new object is created (implementation), can't/don't apply to the question of whether some collection of methods follow FactoryMethod pattern.
		Factory Method is directly related to the polymorphism, it’s provides facility to redefine the method (Creating Factory of method) in further hierarchy of classes.
	c2.com /cgi/wiki?FactoryMethod (1446 words)

	JAVA GLOSSARY, Abstract Factory
		Abstract factory is a design pattern where you create several objects and their inter-relationships with a single command.
		This pattern is one level of abstraction higher than factory pattern.
		One of the main advantages of Abstract Factory Pattern is that it isolates the concrete classes that are generated.
	www.allapplabs.com /glossary/abstract_factory.htm (119 words)

	[No title] (Site not responding. Last check: 2007-10-18)
		The Abstract Factory encapsulates all of the Factory Methods in a separate class, so that's there's a distinct separation between them and the system code that uses those methods and the classes they create.
		The Abstract Factory is used to develop frameworks and systems that can be configured with one of multiple families of products, an example would be having separate factories for different user interface classes for controls on Windows versus controls on another operating system.
		The Abstract Factory Method design pattern gives you all of the flexibility of using the Factory Method pattern, because it uses factory methods as well for the actual creation methods.
	www.devhood.com /tutorials/tutorial_details.aspx?tutorial_id=654 (1085 words)

	[No title]
		A factory method is simply a method, usually defined as static, whose sole purpose is to return an instance of a class.
		In order for a factory implementation to be able to dynamically create different concrete subclass instances, there must be a common base class or shared interface implemented by all classes that the factory will create.
		Now that you have seen the typical factory pattern, let's take a look at how a DI container not only achieves many of the same goals, but also adds a significant amount of flexibility and functionality to your application.
	msdn.microsoft.com /msdnmag/issues/05/09/DesignPatterns/default.aspx (3809 words)

	SENG 609.04 Design Patterns: Paper
		The Factory Method pattern is most used to implement AbstractFactory classes because it is simple and easy to understand and implement, while the Prototype pattern makes the Abstract Factory more flexible by dynamically creating the product objects and more compact by reducing the hierarchy of the concrete factory subclasses.
		The Prototype pattern is especially successful in solving such problems: a class belongs to a framework, and it want to access instances of the application-specific classes in a hierarchy that it has no idea (and should not know) what they actually look like.
		The prototype pattern can be used to reduce the hierarchy of factories (existed in Abstract Factory pattern) or creators (existed in Factory Method) that parallels the product classes hierarchy.
	sern.ucalgary.ca /courses/SENG/609.04/W98/hongd/paper3.html (2176 words)

	Abstract Factory Design Pattern in C# and VB.NET. (via CobWeb/3.1 planetlab2.isi.jhu.edu) (Site not responding. Last check: 2007-10-18)
		Abstract Factory Design Pattern in C# and VB.NET.
		Object creation has been abstracted and there is no need for hard-coded class names in the client code.
		Although the animals created by the Continent factories are different, the interactions among the animals remain the same.
	www.dofactory.com.cob-web.org:8888 /Patterns/PatternAbstract.aspx (232 words)

	ASPN : Python Cookbook : Factory pattern (Site not responding. Last check: 2007-10-18)
		In the factory pattern you have an object that creates other objects.
		Factory is useful to separate implementation from interface.
		When you want to instanciate an object you call its factory and the factory creates the instance.
	aspn.activestate.com /ASPN/Cookbook/Python/Recipe/86900 (139 words)

	Abstract Factory
		Factory method, which is often implemented with an abstract factory.
		Singleton, which is often implemented with an abstract factory.
		Facade, which is often used with an abstract factory by providing an interface for creating implementing class.
	www.javacamp.org /designpattern/abstractfactory.html (252 words)

	Abstract Factory Summary - Design Patterns (Site not responding. Last check: 2007-10-18)
		The Abstract Factory pattern is designed to decouple the creation of the objects from the code wanting some object.
		Then, only the creation of the factory would need to be changed in order to change the whole program such that it used a different set of subclasses.
		Each of these could be a concrete factory (with only the allowed "look and feel"s for each platform) that provides the basic building blocks of the GUI system.
	pages.cpsc.ucalgary.ca /~heard/dp/abstract-factory-summary.html (347 words)

	Factory Patterns (Site not responding. Last check: 2007-10-18)
		In the Abstract Factory pattern, a special class, called a factory, is created whose sole purpose is to instantiate instances of a class.
		The first is that the factory is an object instance, which means it can be passed as an argument to a method.
		It gets this name because the factory class itself is generally an abstract class.
	www.exciton.cs.rice.edu /CppResources/DesignPatterns/Factory.html (264 words)

	Anthony Park :: 100% Geek Content by Volume
		The caller of the factory does not know (or care) which concrete implementation of the factory it is working with.
		When calling creation methods on the abstract class, such as createBrowser(), the caller does not know (or care) which concrete implementation of the Browser class is returned, as long as it is a descendant of the Browser generalization.
		In the class adapter pattern, the class uses multiple inheritance to implement the existing interface, and the new interface that is needed.
	www.anpark.com /2006/05/using-design-patterns-to-improve.aspx (1968 words)

	Comp201 (Site not responding. Last check: 2007-10-18)
		We usually pass the factory as an argument to the constructor of the visitor.
		The intent of this pattern is to provide an abstract specification for manufacturing a family of related objects (for examples, the empty and non-empty IList) without specifying their actual concrete classes thus hiding all details of implementation from the user.
		The revision process is driven along by a repetitive application of the abstract decomposition techniques such as separating the variant and invariant.
	www.owlnet.rice.edu /~comp201/06-spring/lectures/lec20 (1953 words)

	Together Tutorial -- Part 7 (Site not responding. Last check: 2007-10-18)
		The focus will be on the Abstract Factory pattern, which is one of the 11 GoF patterns shipped with Together.
		Together patterns are useful for automatic creation of code that is tedious to write.
		Creating a pattern can result in a pretty messy diagram, especially if new classes or interfaces are generated in the process.
	www.utc.edu /Academic/ComputerScience/SmartStart/7classpatterns.html (1246 words)

	Abstract Factory Design Pattern in ADO.NET 2.0
		Abstract Factory Pattern can be used when we want to return one of several related classes of objects, each of which can return several different objects on request.
		In other words, the Abstract Factory is a factory object that returns one of several groups of classes.
		The final day of the Patterns and Practices Summit West 2005 started with a keynote presentation from Mike Kropp, General Manager of the Patterns and Practices team, on the future of Patterns and Practices.
	www.theserverside.net /news/thread.tss?thread_id=39555 (2134 words)

	Learning Design Patterns - Factory Pattern \| CodeSnipers.com (Site not responding. Last check: 2007-10-18)
		Regardless of the implementation, the goal of the factory pattern is to encapsulate object creation so that the design isn't as dependant on concrete classes.
		Simple factories are often designed as a class with a static method (aka static factory) that returns the object requested.
		The factory method pattern takes the simple factory one step further by becoming an abstract class that has an abstract method for instantiating the object (at least usually; they don't have to be abstract if there is only one object type).
	codesnipers.com /?q=node/216 (432 words)

	Pattern Summaries: Abstract Factory Pattern
		The essence of a pattern is a reusable solution for a recurring problem.
		An abstract factory class defines methods to create an instance of each abstract class that represents a user interface widget.
		Mark Grand is the author of a series of books titled "Patterns in Java." He is a consultant who specializes in object-oriented design and Java.
	www.developer.com /java/other/article.php/626001 (1645 words)

	Abstract Factory Design Pattern Implementation in C# and VB.NET
		The class of the resultant instance is unknown to the client of the Abstract Factory.
		The second form of Abstract Factory is an abstract class defining a common protocol of
		Concrete subclasses of the abstract factory implement this protocol to answer instances of the appropriate suite of classes.
	www.devcity.net /PrintArticle.aspx?ArticleID=15 (658 words)

	Ruby: AbstractFactoryPattern (Site not responding. Last check: 2007-10-18)
		Code that uses the factory can yield to the block, or call the proc, every time a new object is needed.
		My understanding of Abstract Factory is that there's an additional level of indirection involved.
		The use of the Abstract Factory method is to shield the rest of the code from that knowledge.
	wiki.rubygarden.org /Ruby/page/show/AbstractFactoryPattern (538 words)

Try your search on: Qwika (all wikis)