Back Matter

Search in book...
Toggle Font Controls
Create new playlist

Name your new playlist

Playlist description (optional)
Sign In

Email address

Password

Forgot Password?

or

Continue with Facebook

Continue with Google
Sign Up

Full Name

Email address

Confirm Email Address

Password

or

Continue with Facebook

Continue with Google

Appendix A: A Brief Overview of GoF Design Patterns

We all have unique thought processes. So, in the early days of software development, engineers faced a common problem—there was no standard to instruct them how to design their applications. Each team followed their own style, and when a new member (experienced or unexperienced) joined an existing team, understanding the architecture was a gigantic task. Senior or experienced members of the team would need to explain the advantages of the existing architecture and why alternative designs were not considered.

The experienced developer also knows how to reduce future efforts by simply reusing the concepts already in place. Design patterns address this kind of issue and provide a common platform for all developers. You can think of them as the recorded experience of experts in the field. Patterns were intended to be applied in object-oriented designs with the intention of reuse.

In 1994, Erich Gamma, Richard Helm, Ralph Johnson, and John Vlissides published the book Design Patterns: Elements of Reusable Object-Oriented Software (Addison-Wesley). In this book, they introduced the concept of design patterns in software development. These authors became known as the Gang of Four. I refer to them as the “GoF” throughout this book . The GoF described 23 patterns that were developed by the common experiences of software developers over a period of time. Nowadays, when a new member joins a development team, the developer is expected to know about the design patterns, and then the developer learns about the existing architecture. This approach allows a developer to actively participate in the development process within a short period of time.

The first concept of a real-life design pattern came from the building architect Christopher Alexander. During his lifetime, he discovered that many of the problems he faced were similar in nature. So, he tried to address those issues with similar types of solutions.

Each pattern describes a problem, which occurs over and over again in our environment, and then describes the core of the solution to that problem, in such a way that you can use this solution a million times over, without ever doing it the same way twice.
—Christopher Alexander

The software engineering community started believing that although these patterns were described for buildings and towns, the same concepts could be applied to patterns in object-oriented design. They felt that we could substitute the original concepts of walls and doors with objects and interfaces. The common thing in both fields is that, at their cores, patterns are solutions to common problems.

Lastly, it is important to note that the GoF discussed the original concepts of design patterns in the context of C++. But Sun Microsystems released its first public implementation of Java 1.0 in 1995, and then it went through various changes. In 1995, Java was totally new to the programming world. But it grew rapidly and secured its rank in the world’s top programming languages within a short period of time, and in today’s market, it is always in high demand. (You may know that later Oracle Corporation acquired Sun Microsystems and the acquisition process was finished on January 27, 2010.)

On the other hand, the concepts of design patterns are universal. So, when you exercise the fundamental concepts of design patterns with Java, you will be a better programmer, and you’ll remake yourself in the programming community.

Key Points

A design pattern describes a general reusable solution to software design problems. While developing software, you may encounter these problems frequently. The basic idea is that you can solve similar kinds of problems with similar kinds of solutions. And these solutions were tested over a long period of time.
Patterns provide a template of how to solve a problem. They can be used in many different situations. At the same time, they help you get the best possible design much faster.
Patterns are descriptions of how to create objects and classes, and customize them to solve a general design problem in a particular context.
The GoF discussed 23 design patterns. Each of these patterns focuses on a particular object-oriented design . Each pattern can also describe the consequences and trade-offs of use. The GoF categorized these 23 patterns based on their purposes, as shown in the following sections.

A. Creational Patterns

Creational patterns abstract the instantiation process. You make the systems independent from the way that their objects are composed, created and represented. In these patterns, you are concerned about “Where should I place the “new” keyword in my application?” This decision can determine the degree of coupling in your classes. The following five patterns belong in this category.

Singleton pattern
Prototype pattern
Factory method pattern
Builder pattern
Abstract factory pattern

B. Structural Patterns

Structural patterns focus on how classes and objects can be composed to form a relatively large structure. They generally use inheritance or composition to group different interfaces or implementations. Your choice of composition over inheritance (and vice versa) can affect the flexibility of your software. The following seven patterns fall into this category.

Proxy pattern
Flyweight pattern
Composite pattern
Bridge pattern
Facade pattern
Decorator pattern
Adapter pattern

C. Behavioral Patterns

Behavioral patterns concentrate on algorithms and the assignment of responsibilities among objects. They focus on communication between them and how objects are interconnected. The following 11 patterns fall into this category.

Observer pattern
Strategy pattern
Template method pattern
Command pattern
Iterator pattern
Memento pattern
State pattern
Mediator pattern
Chain of Responsibility pattern
Visitor pattern
Interpreter pattern

The GoF made another classification based on scope, namely whether the pattern primary focuses on the classes or its objects. Class patterns deal with classes and subclasses. They use inheritance mechanisms, so they are static and fixed at compile time. Object patterns deal with objects that can change at runtime. So, object patterns are dynamic.

For a quick reference, you can refer to the following table , which was introduced by the GoF.

Note

In this book, each chapter is self-contained. You can start with any pattern you like, following the guidelines given at the beginning of the book. I have chosen simple examples so that you can pick up basic ideas quickly. But you must keep reading and practice. Try to link problems and then keep coding. This process helps you master the subject quickly.

Q&A Session

What are the differences between class patterns and object patterns?

In general, class patterns focus on static relationship but object patterns can focus on dynamic relationships. As name suggests, class patterns focus on classes and its subclasses and object patterns focus on the objects relationships.

As per GoF, these patterns can be further differentiated in Table A-1

Table A-1

Class Patterns vs Object Patterns

	Class Patterns	Object Patterns
Creational	Defers object creation to its subclasses.	Defers object creation to another object.
Structural	Focuses on the composition of classes (primarily uses the concept of inheritance).	Focuses on the different ways of composition of objects.
Behavioral	Describes the algorithms and execution flows .	Describes how different objects can work together and complete a task.

2.
Can I combine two or more patterns in an application?
Yes. In real-world scenarios, this type of activity is common.
3.
Do these patterns depend on a particular programming language?
Programming languages can play an important role. But the basic ideas are same, patterns are just like templates and they give you some idea in advance of how you can solve a particular problem. In this book, I primarily focused on object-oriented programming with the concept of reuse. But instead of any object-oriented programming language, suppose you have chosen some other language like C. In that case, you may need to think about the core object-oriented principles such as inheritance, polymorphism, encapsulation, abstraction, and so on, and how to implement them. So, the choice of a particular language is always important because it may have specialized features that can make your life easier.
4.
Should I consider common data structures like arrays and linked lists as design patterns?
The GoF clearly excludes those saying that they are not complex, domain-specific designs for an entire application or subsystem . They can be encoded in classes and reused as is. So, they are not your concern in this book.
5.
If no particular pattern is 100% suitable for my problem, how should I proceed?
An infinite number of problems cannot be solved with a finite number of patterns, for sure. But if you know these common patterns and their trade-offs, you can pick a close match. No one prevents you from using your own pattern for your own problem, but you have to tackle the risk.
6.
Do you suggest any general advice before I jump into the topics?
I always follow the footsteps of my seniors and teachers who are experts in this field. And the following are general suggestions from them.
- Program to a supertype(Abstract class/Interface), not an implementation.
- Prefer composition over inheritance.
- Try to make a loosely coupled system.
- Segregate the code that is likely to vary from the rest of your code.
- Encapsulate what varies.
7.
How can I use this book effectively?
This book focuses on commonly used design patterns. Most likely, you face them very often in your everyday life. But the world is always changing, and new patterns are keep evolving. To understand the necessity of a new pattern, you may also need to understand why an old/existing pattern is not enough to fulfil the requirement. You may consider this book as an attempt to make a solid foundation with design patterns, so that, you can move smoothly in your professional life and you can adapt the upcoming changes easily.

Appendix B: Winning Notes and the Road Ahead

Congratulations. You have reached the end of the journey. Anyone can start a journey but only few can complete it with care. So, you are among the minority who possess the extraordinary capability to cover the distance successfully. I believe that you have enjoyed your learning experience and this experience can help you learn and experiment further. If you continue to think about the discussions, examples, implementations, and the Q&A sessions from the book, you will have more clarity and you will be confident about what you learned, and you can remake yourself in the programming world.

Truly, an in-depth discussion of any particular design pattern would require many more pages, and the size of the book would be too gigantic to digest.

So, what is next? You should not forget the basic principle: learning is a continuous process . This book encourages you to learn the core concepts so that you can continue learning in more depth.

I believe that learning and thinking on your own is not enough. So, I suggest you participate in open forums and join discussion groups to get more clarity on this subject. This process will not only help you, it will help others also.

I have a request. You can always point out areas for improvement in this book, but at the same time, please let me know what you liked about it. In general, it is always easy to criticize but an artistic view and open mind is required to discover the true efforts that are associated with any kind of work.

Thank you and happy coding!

Appendix C: Bibliography

This appendix lists some useful resources.

The following are helpful books.

Gamma, Erich, et al. Design Patterns: Elements of Reusable Object-Oriented Software . Addison-Wesley, 1995.
Freeman, Eric. Head First Design Patterns . O’Reilly, 2016.
Bevis, Tony . Java Design Pattern Essentials . Ability First, 2012.
Brown, William J., and Raphael Malveau. Anti-Patterns: Refactoring Software, Architectures and Projects in Crisis . Wiley, 1998.
Sarcar, Vaskaran. Design Patterns in C# . Apress, 2018.

The following are helpful online resources/websites.

Index

A

AbstractDecorator class

AbstractExpression

Abstract factory pattern

class diagram

code snippet

computer-world example

concept

GoF definition

implementation

Package Explorer view

real-world example

structure

Abstract Window Toolkit (AWT)

Adapter pattern

aboutMe() method

aboutRectangle() method

aboutTriangle() method

challenges

class adapters

class diagram

modified

computer-world

core concept

electrical outlet/AC power adapter

getArea() method

GoF definition

implementation

mobile phone

modified implementation

key characteristics

modified output

object

object-oriented design principles

output

Package Explorer view

high-level structure

modified program

addHeadLights() methods

addNumber()

AnimalFactory class

Antipattern

causes

defined

examples

history

remedy

symptoms

types

Architectural antipatterns

AuthenticationErrorHandler

B

Behavioral patterns

Bill pugh’s solution

Bridge pattern

abstract class

advantages

challenges

characteristics

class diagram

computer-world example

concept

GoF definition

implementation

output

Package Explorer view

real-world example

buildBody() methods

Builder pattern

abstract class

advantages

characteristics

class diagram

computer-world example

concept

construction process

drawbacks/pitfalls

GoF definition

implementation

output

Package Explorer view

real-world example

structure

buildExpression() method

C

Caching mechanism

calculateAreaOfRectangle() method

calculateAreaOfTriangle() method

Caretaker class

Catch block

Centralized management system

Chain-of-responsibility pattern

class diagram

computer-world example

concept

GoF definition

implementation

output

Package Explorer view

real-world example

class adapters

class patterns

clone() method

Command pattern

characteristics

class diagram

computer-world example

concept

GoF definition

implementation

output

Package Explorer view

real-world example

completeCourse() method

completeSpecialPaper() method

Composite pattern

advantages

challenges

class diagram

computer-world example

concept

GoF definition

implementation

output

Package Explorer view

real-world example

usage

ConcreteAggregate

ConcreteBuilder

Concrete implementation

ConcreteIterator

ConcreteSubject class

construct() method

constructCar() methods

constructMilanoRobot() method

createAnimal() method

Creational patterns

currentItem() method

D

Data structures

Decorator pattern

advantages

class diagram

computer-world example

concept

disadvantages

GoF definition

implementation

inheritance

Package Explorer view

real-world example

Deep copy

Default behavior

Design patterns, criticisms

destroyMilanoRobot() method

Development antipatterns

doSomework() method

Double-checked locking

doublePress() method

dummyMethod()

Dynamic behavior

Dynamic binding

Dynamic checking mechanism

E

EmailErrorHandler

Encapsulation

endOperations() methods

execute() method

Experience reuse

Extrinsic state

F

Facade pattern

access

advantages

challenges

class diagram

concept

differences, mediator design pattern

GoF definition

implementation

interfaces

key information, party organizer

output

Package Explorer view

programming language

Factory method pattern

abstract creator class

class diagram

code snippet

computer-world example

concept

GoF definition

implementation

output

Package Explorer view

parallel class hierarchies

real-world example

FaxErrorHandler

Finite state machine

first() method

Flyweight pattern

advantages

challenges

class diagram

computer-world example

concept

core concepts, visualizes

GoF definition

implementation

output

Package Explorer view

real-world example

G

getArea() method

getArea(RectInterface) method

getCaptain() method

getConstructedCar() methods

getEmployeeCount() methods

getRobotFromFactory() method

getRuntime() method

GetVehicle() method

GoF design patterns

behavioral patterns

creational patterns

object-oriented design

reusable solution

structural patterns

GUI frameworks

H

Handle/body pattern

hasNext() method

I

Inheritance

hierarchy

multilevel

multiple base classes

insertWheels() methods

Instantiation process

interpret() method

Interpreter pattern

class diagram

computer-world example

concept

GoF definition

implementation

output

Package Explorer view

real-world example

structure

Intrinsic state

Invocation process

isAdditionalPapersNeeded()

Iterator pattern

class diagram

computer-world example

concept

diagram

GoF definition

implementation

output

Package Explorer view

real-world example

J, K

java.awt.event package

L

Lazy initialization

Lazy instantiation technique

M

main() method

MakeHouse() method

Management antipatterns

Mediator pattern

advantages

analysis

class diagram

communication

computer-world example

concept

definition

implementation

modified illustration ( see Modified illustration, mediator pattern)

output

Package Explorer view

participants

real-world example

structure

Memento pattern

challenges

class diagram

computer-world example

concept

GoF definition

implementation

output

Package Explorer view

real-world example

Model-View-Controller (MVC) pattern

advantages

architecture

ASP.NET project

challenges

class diagram

concept

controller

description

implementation

key components

model

Modified Package Explorer view

multiple views

observer pattern/event-based mechanism

output

Package Explorer view

real-life example

variations

view

Model-View-Presenter (MVP)

ModifiedBuilder return type

Modified Illustration, mediator pattern

analysis

class diagram

implementation

output

Package Explorer view

MouseMotionAdapter class

MSIL code

Multiple inheritance

Multithreaded environment

N

next() method

non-static nested class

NonterminalExpression

notifyRegisteredUsers() methods

Null Object pattern

analysis

characteristic

class diagram

client server architecture

demo

exception

faulty program

implementation

output

Package Explorer view

real-life scenario

remedy

unwanted input

NullVehicle object

O

Object adapters

Object-oriented programming

Object patterns

Object pool pattern

Observer pattern

class diagram

computer-world example

concept

GoF definition

implementation

output

Package Explorer view

real-world example

workflow

one-time deal

open/close principle

Oracle Java documentation

Oracle server–specific connection

Organizational antipatterns

P, Q

Parameterized constructors

Pattern Languages of Program Design (PLoP)

PetAnimalFactory

Polymorphism

Portland patterns repository

preferredAction() methods

printStructures() methods

Private constructor

ProductClass attributes

Programming languages

Protection proxies

Prototype pattern

advantages

challenges

class diagram

computer-world example

concept

field-by-field copy ( see Shallow copy)

GoF definition

implementation

output

Package Explorer view

real-world example

structure

user-defined copy constructor

Proxy pattern

class diagram

computer-world example

concept

GoF definition

implementation

output

Package Explorer view

real-world example

Public setter method

Publish-subscribe pattern

R

Ready-made constructs

RectInterface

Refactoring

Refined abstraction

Remote-control maker

Remote proxies

RobotFacade class

RobotFactory class

S

SAXParserFactory

sendMessage() method

setAdditionalPrice() method

setChanged method

Setter method

Shallow copy

vs . deep copy

implementation

output

showTransportMedium() method

Simple factory pattern

characteristics

class diagram

code snippet

computer-world example

concept

GoF definition

implementation

output

package explorer view

real-world example

Single responsibility

Singleton class

Singleton pattern

characteristics

class diagram

computer-world example

concept

eager initialization

GoF definition

implementation

object creations

output

Package Explorer view

real-world example

Smart reference

Software engineering community

SOLID principles

SQL Server–specific connection

startUpOperations() method

State pattern

characteristics

class diagram

computer-world example

concept

GoF definition

implementation

output

Package Explorer view

real-world example

Static class

Strategy pattern

advantages

class diagram

computer-world example

concept

class Boat extends Vehicle

GoF definition

implementation

output

Package Explorer view

real-world example

vehicle class

Structural patterns

Sun Microsystems

Synchronized method

T

TCP connection

Television (TV)

functionalities

states

Template method pattern

advantages

class diagram

computer-world example

concept

GoF definition

implementation

output

Package Explorer view

real-world example

TerminalExpression

transport() method

TV() constructor

U

Unshared flyweights

User interface (UI)

adapter

antipatterns

V

Vehicle class

Virtual proxies

VisitCompositeElement() method

VisitLeafNode() method

Visitor pattern

class diagram

computer-world example

concept

GoF definition

implementation

output

Package Explorer view

real-world example

tree structure

W, X, Y, Z

WildAnimalFactory

Windows Presentation Foundation (WPF)

..................Content has been hidden....................

You can't read the all page of ebook, please click here login for view all page.

Table of Contents for Back Matter

Create new playlist

Sign In

Sign Up

Index

A

B

C

D

E

F

G

H

I

J, K

L

M

N

O

P, Q

R

S

T

U

V

W, X, Y, Z

Table of Contents for
Back Matter