This essay has been submitted by a student. This is not an example of the work written by our professional essay writers.
Although many techniques are there to help system designer, system analysts and programmer like uses cases and collaboration diagrams ,still the most hardest thing to do is trying to "discover" the object , especially for non professional system designers .
This will defiantly lead to design a system with too many interacted objects or a system which is hard to understand and maintain. Patterns aims to solve this problem by giving lessons from Experts .
Designing a pattern is considered as a solution to a general software problem within a particular context. Design patterns capture evolved solutions that experts and developers have reached them within time for more flexibility in their system designing process.
Patterns do not only talk about how software is structured , but also how classes and object interact with each other especially during runtime .
Patterns are a design description that is both generic and reusable design which is specially designed to solve a problem.
"Pattern" as the name suggests, means series of events occurring in a definite order.
The patterns can be found in Java and J2ee technologies also. Many a times, we find
that there is a particular way of tackling a problem. This way is easy and has been
used many times successfully by a number of people earlier also. This method
becomes a pattern.
Design patterns were first described by architect Christopher Alexander in his book A
Pattern Language: Towns, Buildings, Construction (Oxford University Press, 1977).
The concept he introduced and called patterns -- abstracting solutions to recurring
design problems -- caught the attention of researchers in other fields, especially those
developing object-oriented software in the mid-to-late 1980s
The largest part of Design Patterns is a catalog describing 23 design patterns. Other,
more recent catalogs extend this repertoire and most importantly, extend coverage to
more specialized types of problems. Mark Grand, in Patterns in Java: A Catalog of
Reusable Design Patterns Illustrated with UML, adds patterns addressing problems
involving concurrency, for example, and Core J2EE Patterns: Best Practices and
Design Strategies by Deepak Alur, John Crupi, and Dan Malks focuses on patterns for
multi-tier applications using Java 2 enterprise technologies.
According to Wang (2003), a design pattern is a recipe for solving a certain type of
design problem that captures the high-level objects, their interactions, and their
Software design patterns are schematic descriptions of solutions to recurring problems
in software design. (Jia, 2003)
A design pattern describes how objects communicate without becoming entangled in
each other's data models and methods. (Cooper, 2000)
Design patterns are recurring solutions to design problems you see over and over.
(Alpert, Brown and Woolf, 1998)
And according to Gamma, Helm, Johnson, and Vlissides (1993 ) Patterns identify and
specify abstractions that are above the level of single classes and instances, or of
Why it is important to know about pattern design?
As programmers initially design a program or an implementation , they (or other developers )often discover some improvements which makes the first design more adaptable . Solution comes with design pattern issue which allow for such programs or systems to reuse the knowledge provided by other software developers experts as a pattern that they have designed to capture such solutions. Studying designing patterns provides a common used words and expressions for documentation.
When should (not) we use it?
While using a pattern properly results in reusable code, the consequences often
include some costs as well as benefits. Reusability is often obtained by introducing
encapsulation, or indirection, which can decrease performance and increase
complexity. For example, you can use the Facade pattern to wrap loosely related
classes with a single class to create a single set of functionality that is easy to use. One
possible application might be to create a facade for the Java Internationalization API.
This approach might be reasonable for a stand-alone application, where the need to
obtain text from resource bundles, format dates and time, and so on, is scattered in
various parts of the applications. But this may not be so reasonable for a multitier
enterprise application that separates presentation logic from business. If all calls to the
Internationalization API are isolated in a presentation module -- perhaps by wrapping
them as JSP custom tags -- it would be redundant to add yet another layer of
Some of Java Designed Patterns
This group of design patterns deals with the process of object creation: they create
objects for the programmer, and help him avoid having to instantiate objects directly.
and the program will have earner more flexibility in selecting the objects that you
need to create a particular case.
5.2 Behavioral Patterns
This group of design patterns deals primarily with dynamic interaction among classes
and objects: help the programmer to define connections between objects in your
system, and how the flow is controlled in a complex program.
5.3 Structured patterns
This set of design patterns deals with the composition and structure of static objects
and categories are: to help the programmer to configure groups of objects in the
structures of the largest, such as user interfaces and complex accounting data.
6.1 Overview :
Creation Patterns shows a prescription of the creation of objects , when a decision must be made at the time class is instant , such patterns are used. They abstract the instantiation process .
By that creation patterns help a system they build , to be composed , represented and at the same time independent of how its classes are really created.
Details of such classes are of course, encapsulated by abstract superclass and hidden from users . Users can know only know about abstract class which the class provides by its interface. Inheritance is used by such classes to vary the class that is instantiated. Objects , by creational patterns delegate instantiation to another object. It Keeps the specific type of the concrete class unknown to the user .
6.2 What Creational Patterns performs
They provide independency about how objects are created, composed, and represented within system
Instantiation processes are abstracted , such that
- Knowledge provided about system use of concrete classes is encapsulated .
- Creation and assimilation about instances used for these classes are kept hidden .
They provide governess for the created objects
6.3 Why Creational Patterns?
ï® The are useful for encapsulation of knowledge concerning those concrete classes used by the system.
ï® They hide information about how instances of them are created and how they work together.
ï® They use a small set of behaviors instead of using hard - coding
6.4 List of Creational Patterns
Class scope pattern:
- Abstract Factory
Object scope patterns:
- Factory Method
6.3 Example : Singleton Pattern
There are some classes that have conceptually one instance , such that when we have many printers within a software system but we have only one print spooling , or when having one file system or one window manager. In these classes , when a programmer creates many objects that represent this conceptual instance , it will add complexity and overhead to the system.
For such systems create one object code that represent this instance and reuse it with providing encapsulation for such code.
- While class encapsulation ensures the reuse of the object will provide an easy
facilitated way for clients , this reusing implies a better performance too.