
	Where results make sense

Topic: Creational pattern

Related Topics

Behavioral pattern

Structural pattern

Fundamental pattern

Concurrency pattern

Design pattern (computer science)

Scheduler pattern

Proxy pattern

Interface pattern

Prototype pattern

Adapter pattern

Builder pattern

Bridge pattern

Abstract factory pattern

Singleton pattern

	Creational pattern - Wikipedia, the free encyclopedia
		In software engineering, creational design patterns are design patterns that deal with object creation mechanisms, trying to create objects in a manner suitable to the situation.
		The basic form of object creation could result in design problems or added complexity to the design.
		Creational design patterns solve this problem by somehow controlling this object creation.
	en.wikipedia.org /wiki/Creational_pattern (91 words)

	Prototype pattern - Wikipedia, the free encyclopedia
		A prototype pattern is a creational design pattern used in software development when the type of objects to create is determined by a prototypical instance, which is cloned to produce new objects.
		This pattern is used for example when the inherent cost of creating a new object in the standard way (e.g., using the 'new' keyword) is prohibitively expensive for a given application.
		The Prototype pattern specifies the kind of objects to create using a prototypical instance.
	en.wikipedia.org /wiki/Prototype_pattern (421 words)

	The Factory Method Design Pattern by Gopalan Suresh Raj
		Entity beans can be created by creating an object using an object factory Create method.
		Similarly, Session beans can be created by creating an object using an object factory Create method.
		Creating objects inside a class with a factory method is always more flexible than creating an object directly.
	gsraj.tripod.com /design/creational/factory/factory.html (1693 words)

	Software is too expensive to build cheaply...: Creational vs access patterns, and other diversions (Site not responding. Last check: 2007-10-12)
		The primary point of creational patterns, BTW, is to decouple the type of an object from the class of an object.
		By using a creational pattern, you can separate the concern of what exactly an object is (which class is it) from the question of how you use it (the type you care about).
		In this example, we've gone from a pure creational pattern (create a datasource) to a mixed access/creational pattern (access a datasource to create a connection) to a pure access pattern (access a connection, via dependency injection).
	twasink.net /blog/archives/2004/09/creational_vs_a.html (1528 words)

	Elena Fanea and David Baker- Prototype
		The Prototype pattern is a creational pattern in which new objects are created based on an existing prototype object.
		The prototype pattern can be used in situations where the regular construction of a concrete object would be too complex (compared to cloning a pre-existing object), or where there is a desire to isolate the client from having to know about all concrete product classes (similar to Abstract Factory).
		The prototype pattern is especially useful for cases where the construction and initialization of an object would be more complex or time involving than the cloning (and modification) of an existing object.
	pages.cpsc.ucalgary.ca /~faneael/Prototype_document.htm (2662 words)

	Factory method design pattern
		Creational patterns provide flexibility in what gets created, who creates it, how it gets created and when it's created..
		The second variation of the factory method pattern is the Manufacturer class is a concrete class and provides a default implementation for the factory method (Gamma et al., 1995).
		It is also important, because it is a pattern that is used all the time in object oriented programming even though you may not even know you are using it.
	sern.ucalgary.ca /courses/seng/443/F2004/patternNotes/Marsh_Richelhof_&_Liew (2003 words)

	Discussion 2 - Manini Patel (Site not responding. Last check: 2007-10-12)
		Creational pattern gives more flexibility to program in deciding which objects are needed for a given case.
		Singleton pattern is implemented by creating a class with a method that creates a new instance of the object if the object doesn’t exist.
		If two threads are to execute the creation method at the same time when a singleton does not yet exist, they both must check for an instance of the singleton and then only one should create the new one.
	coweb.cc.gatech.edu /cs2340/4598 (437 words)

	Exploring the Singleton Design Pattern (Building Distributed Applications) (Site not responding. Last check: 2007-10-12)
		Whether a team is assembled to create a new automobile or a new building design, it usually does not have to ponder problems that were solved before.
		The concept of well-defined general purpose units of functionality that are well understood is the motivation for design patterns and the focus of two other design pattern articles, Exploring the Factory Design Pattern and Exploring the Observer Design Pattern.
		For the scope of this article, we are going to discuss the Singleton pattern, which lives in a family of creational patterns.
	msdn.microsoft.com /library/en-us/dnbda/html/singletondespatt.asp?... (2839 words)

	Design and Architecture
		Builder Pattern in VB.NET by Rajesh V. Builder is an object creational design pattern that codifies the construction process outside of the actual steps that carries out the construction - thus allowing the construction process itself to be reused.
		Bridge Pattern in VB.NET by Rajesh V. Bridge Pattern is commonly known as Handle/Body idiom in C++ community.
		Abstract Factory Pattern in VB.NET by Rajesh V. The abstract factory pattern comes under the classification of Creational Patterns.
	www.vbdotnetheaven.com /Sections/Design.asp (321 words)

	Java Creational Design Patterns - Games++
		A Factory pattern is one that returns an instance of one of several possible classes depending on the data provided to it.
		The Protoype pattern is used when creating an instance of a class is very time-consuming or complex in some way.
		The Singleton pattern is grouped with the other Creational patterns, although it is to some extent a “non-creational” pattern.
	www.gamespp.com /java/designpatterns/creational (283 words)

	William Luebke - COMP 204 Design Pattern Answers (Site not responding. Last check: 2007-10-12)
		The Singleton pattern is often paired with the Abstract Factory pattern.
		If it makes more sense to create one object (or set of objects) and then clone it (them) to create instances, rather than simply creating the object directly (a la a vanilla factory) then this pattern should be used.
		The composite pattern capitalizes on the dynamic-dispatch feature of object-oriented programming to allow groups and hierarchies of objects to be treated as just one item by use of a composite object.
	www.cs.unc.edu /~wluebke/comp204/patterns.html (2575 words)

	Increased runtime flexibility and future proofing; the GOF Creational Patterns with C# - by Barry Mossman
		There are various patterns which are designed to isolate such algorithms away into a helper class on their own which is a design technique that is ready for change and likely to minimise impact upon other sections of our code.
		This creational pattern facilitates a system design where the objects that we use could be considered to have features and options that are dynamically chosen at run time.
		The Singleton pattern is a specialist creational pattern as it's primary focus is to facilitate a single shared instance of our object rather than to decouple our client from the object's implementation as with the other creational patterns.
	community.borland.com /article/0,1410,32049,00.html (4303 words)

	SENG 609.04 Design Patterns: Paper
		Creational class patterns defer the responsibility of object creation to subclasses, while creational object patterns defer it to another object.
		A class creational pattern uses inheritance to change the class to be instantiated, while an object creational pattern delegates instantiation to another object.
		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.
	sern.ucalgary.ca /courses/SENG/609.04/W98/hongd/paper3.html (2176 words)

	[No title]
		Pattern name: Structure-Shy Object Purpose: To make object descriptions independent of class names and robust to changes of class structure, augment the class graph to make it a grammar for parsing objects.
		The Structure-Shy Object pattern is very easy to use by someone who knows the concept of a grammar and how a grammar is used to parse sentences.
		The Structure-Shy Object pattern is useful in conjunction with the Prototype pattern; it can be used to create the prototype in a structure-shy way.
	www.ccs.neu.edu /research/demeter/adaptive-patterns/AOP/Structure-Shy-Object (970 words)

	The Singleton Pattern, and the Observer Pattern Tech Tips
		Creational patterns describe how objects are created (or "instantiated" in object-oriented terminology).
		Some common pattern names are Singleton in the creational area, Observer in the behavioral area, and Facade in the structural area.
		The Singleton pattern is useful if you know you only have a single resource, and need to share access to the state information of that single resource.
	java.sun.com /developer/JDCTechTips/2006/tt0113.html (2055 words)

	Using Design Patterns in UML
		The patterns that we encounter need to be captured and documented in a sufficiently descriptive manner so that they can be referred for future use.
		The implementation of the creational pattern is responsible for managing the lifecycle of the instantiated object.
		The Command pattern allows for having well defined command interfaces that are implemented by the object that provides the processing for the client requests packaged as commands.
	www.developer.com /design/print.php/3309461 (860 words)

	Builder - A Design Pattern (Site not responding. Last check: 2007-10-12)
		A creational pattern will hide from the user how the object is created and will give the object a representation which the user of the pattern can then work with.
		Structural patterns are used to arrange a number of objects into a larger representation that encompasses and is solely made up of these objects, depending on each of them.
		One similar pattern is Abstract Factory as “it too may construct complex object” [2].
	www.enel.ucalgary.ca /~tbbulloc/seng443/qa.htm (153 words)

	Introducing IBM Rational Software Architect
		Other instances in which this pattern is useful include logging and printing, such as when you want only one instance of a class to access and control one particular printer at a time.
		The Factory Method Pattern is a creational pattern that defines an interface for creating an object but lets subclasses decide which actual class to instantiate.
		The Chain of Responsibility Pattern is used to promote loose coupling between the sender or initiator of a request (the client) and the system that is receiving the request.
	www-128.ibm.com /developerworks/rational/library/05/524_rsa (2158 words)

	Discussion 2 - Cooper Welch (Site not responding. Last check: 2007-10-12)
		For instance, a creational pattern might allow a program to create objects when necessary, rather than having the programmer instantiate them all directly.
		Creational patterns can be broken down into two sub-categories: class-creational patterns and object-creational patterns.
		Structural patterns concern themselves with how to strategically group and combine classes and objects so as to facilitate the effective creation of large architectures.
	coweb.cc.gatech.edu /cs2340/4591 (392 words)

	COMP 204: Software Design and Implementation
		A facade pattern should be used whenever the dependencies between the clients and the implementation classes of an abstraction become complex enough to need further decoupling.
		The Facade pattern is advantageous in that it shields the clients from having to directly call any of the subsystem components, thereby layering the system and its dependencies and reducing the number of objects that clients deal with.
		A decorator pattern used in modifying an object is used to enrich the behavior of the component while chain of responsibility does not necessarily modify the object since each member of the chain may not respond to each request sent through the chain.
	www.duke.edu /~jad1/comp204 (2414 words)

	Creational_Patterns (Site not responding. Last check: 2007-10-12)
		In many cases, the exact nature of the object that is created could vary with the needs of the program from time to time and abstracting the creation process into a special "creator" class can make your program more flexible and general.
		The Builder Pattern separates the construction of a complex object from its representation, so that several different representations can be created depending on the needs of the program.
		The Singleton Pattern provides a class of which there can be no more than instance, and provides a single global point of access to that instance.
	www.patterndepot.com /put/8/Creational_Patterns.htm (239 words)

	Creational Patterns in C#
		The Singleton Pattern is an example of Creational Pattern.
		The singleton design pattern is used when only one instance of an object is needed throughout the lifetime of an application.
		But by using a private constructor and a static method to create an instance of the class is a popular way to create singleton pattern.
	www.devarticles.com /c/a/C-Sharp/Creational-Patterns-in-C-sharp (898 words)

	"Creational Patterns in Everyday Life" - Pantheon Systems Journal
		Here are creational patterns from the Gang of Four book and examples of such patterns from real life.
		As an example of the Builder pattern, consider a situation where is where the traveler chooses from one of several pre-designed packages at the travel agency - everything is pre-packaged, the entire combination is purchased.
		The creation of a prototype is akin to choosing from a set of model homes.
	www.pantheon.com /journal/pat3.htm (1513 words)

	[No title] (Site not responding. Last check: 2007-10-12)
		The value of creational patterns is to tell us how to structure and encapsulate these decisions.
		Their operation will typically begin with a command to create or edit a word processing document, spreadsheet, time line or whatever type of document or file the application is intended to work with.
		However, if factory objects are required to create multiple kinds of product objects then their createProduct m ethod will need to take the necessary parameters to allow the method to deduce which product class to instantiate.
	www.laputan.org /pub/patterns/grand/Creational.doc (1495 words)

	BiLTeC - Design pattern and software engineering
		In Design Patterns, each pattern is described with its name (and other well-known names); the motivation behind the pattern; its applicability; the structure of the pattern; class/object participants; participant collaborations; pattern consequences; implementation; sample code; known uses; and related patterns.
		This pattern is quite useful in systems where we want to expose a library of products to be used by a client, independent of their implementations.
		A Builder is a creational design pattern meant to "Separate the construction of a complex object from its representation so that the same construction process can create different representations." (GOF) Continuing with our airplane manufacturer analogy, building an airplane consists of assembling the sub-parts.
	www.biltec.org /page.php?id=301 (1433 words)

	Java Tips - The Singleton Pattern (Site not responding. Last check: 2007-10-12)
		One of the commonly used creational patterns is the Singleton pattern.
		The Collator class is another example of this pattern, with a slight difference.
		As shown with BorderFactory, the Factory pattern does not have to be used with the Singleton pattern.
	www.java-tips.org /java-se-tips/java.lang/the-singleton-pattern.html (1173 words)

	Creational Pattern - Abstract Factory (Site not responding. Last check: 2007-10-12)
		In order to avoid duplicating the decision making everywhere an instance is created, we need a mechanism for creating instances of related classes without necessarily knowing which will be instantiated.
		Each object that it produces is known to the receiver of the created object only by that object's interface, not by the object's actual concrete implementation.
		Passing "cd" in the command line creates a family of cd objects (Audio and Video) and "dvd" creates a family of dvd objects (Audio and Video).
	www.c-sharpcorner.com /UploadFile/ajaiman/CreationalPattersAbstFact11142005014550AM/CreationalPattersAbstFact.aspx?ArticleID=554de33d-7bb1-4ecd-8433-51ac78b98323 (692 words)

	Factory Method (A Creational Design Pattern) (Site not responding. Last check: 2007-10-12)
		Define an interface for creating an object, but let subclasses decide which class to instantiate.
		defines the interface of objects the factory method creates.
		Creator may also define a defaullt implementation of the factory method that returns a default ConcreteProduct object.
	www.cs.unc.edu /~vivek/patterns/doc/creational/factorymethod (82 words)

Try your search on: Qwika (all wikis)