Ajs 2 b

More on Design Patterns

Pre-assessment Questions

2. Which UML diagram depicts the sequential invocation of methods of a
system?
a) Sequence
b) Collaboration
c) Package
d) Use Case

©NIIT Architecting J2EE Solutions Lesson 2B / Slide 1 of 35



2. Which option identifies the scope of a system in a Use Case diagram
and is represented by a solid rectangle?
a) Use Case
b) Message
c) Actor
d) State boundary




2. Consider the statements:
Statement A: Extent relationship indicates that an existing use case is
extended by additional behavior to obtain another use case.
Statement B: Include relationship indicates that the functions of one
use case are included in the functions of the other.
Identify the correct option.
a) Statement A is true and statement B is false
b) Statement A is false and statement B is true
c) Both, statements A and B, are true
d) Both, statements A and B, are false




2. Consider the statements:
Statement A: Component diagram represents the grouping of related
classes, interfaces, and methods of a given system.
Statement B: Component diagram elements represent the various
components of business entities of a given system.
Identify the correct option.
a) Statement A is true and statement B is false
b) Statement A is false and statement B is true
c) Both, statements A and B, are true
d) Both, statements A and B, are false




2. Which element of GoF’s design pattern emphasizes on relationships,
responsibilities, and collaborations among the constituents of a pattern?
a) Pattern name
b) Solution
c) Problem
d) Consequences



Solutions to Pre-assessment Questions

1. a. Sequence
2. d. State boundary
3. c. Both, statements A and B, are true
4. b. Statement A is false and statement B is true
5. b. Solution



Objectives

In this lesson you will learn to:

• Use Structural Design Patterns
• Use Behavioral Design Patterns



Structural Design Patterns
• Structural design patterns
• Represent the composition of classes and objects.
• Defines how classes inherit each other.
• The class-creation pattern uses inheritance in order to provide more functional
program interfaces.
• The object-creation pattern defines how objects can be composed to provide
new functionality using object composition.
• The various structural design patterns are Adaptor, Bridge, Composite,
Decorator, Façade, Flyweight, and Proxy.



Structural Design Patterns (Contd.)
• Adapter Pattern
• The Adapter design pattern
• Converts the interface of a class into an interface that is required by
the client.
• The advantages of using Adapter design pattern are:
• Enabling two or more incompatible objects to interact with each
other.
• Making an existing functionality reusable.
• The participants of Adapter design pattern are:
• adapterTest : Implements the methods of MouseAdapter class.
• MouseListener: Receives the mouse events generated.
• MouseAdapter: Provides blank implementation of the methods
defined in the MouseListener abstract class.



• Class diagram of the Adapter design pattern



• Bridge Pattern
• The Bridge design pattern
• Separates an interface and its implementation. This enables both the
interface and its interface to change without affecting each other.
• Uses encapsulation, aggregation, and inheritance to divide
responsibilities into various classes.
• The advantages of using Bridge design pattern are:
• Separates the implementation details from interface.
• Hides implementation details from the client.




• The participants of Bridge design pattern are:
• ClientApp: Invokes the methods of ConcreteImplementor1 and
ConcreteImplementor2 class.
• Abstraction: Defines the methods that are implemented by
ConcreteImplementor1 and ConcreteImplementor2 classes.
• RefinedAbstraction: Extends the methods defined by class, Abstraction.
• Implementor: Extends the methods of the Abstraction class to the
implementation classes, ConcreteImplementor1 and
ConcreteImplementor2.
• ConcreteImplementor1: Implements the methods defined in the abstract
class, Implementor.

• ConcreteImplementor2: Implements the methods defined in the abstract
class, Implementor.



• Class diagram of the Bridge design pattern



• Composite Pattern
• The Composite design pattern
• Composes objects into tree structures.
• Enables a client to identically treat both the single component and
collection of components.
• The advantages of Composite design pattern are:
• Adds new components.
• Describes the hierarchies of a class, which consists of primitive and
complex objects.



• The participants of Composite design pattern are:
• ClientClass: Invokes methods of an object through Component interface.
• Component: Declares interface for accessing and managing its child
components.
• Leaf: Defines an object in composition, which has no children.
• Composite: Defines behavior for parent components and stores child
components.



• Class diagram of the Composite design pattern



• Decorator Pattern
• The Decorator design pattern
• Enables you to extend the functionality of a particular object of a
class and dynamically provide additional responsibilities to it.
• Uses composition instead of inheritance in order to extend the
functionality, the Decorator design pattern.
• The advantages of using Decorator design pattern are:
• It makes it easy to code a behavior, by enabling you to create
functionality classes.
• It is more flexible as compared to static inheritance.
• It improves the extensibility of an object as you code new classes
to make a change in functionality.



• The participants of Decorator design pattern are:
• Component: Describes the functionality that the client requires.
• ConcreteComponent: Implements the functionality described in the
abstract class, Component and represents the object to which you
can add additional functionalities.
• Decorator: Enables ConcreteDecorator1 and ConcreteDecorator2 to
implement the functionality of the abstract class, Component.
• ConcreteDecorator1: Implements the functionality of the abstract
class, Component through the abstract class, Decorator.
• ConcreteDecorator2: Implements the functionality of the abstract
class, Component through the abstract class, Decorator.



• Class diagram of the Decorator design pattern



• Facade Pattern
• The Façade design pattern
• Provides a unified interface to a collection of interfaces in a
subsystem.
• The advantages of using Façade design pattern are:
• Simplifies the interfacing that makes it difficult to use a large amount
of coupling.
• Protects the client from the complex subsystem components.
• The Façade design pattern has two participants:
• Façade: Is also a participant of a system that intercepts client
requests and dispatches the request to the subsystem to service the
client request.
• SubSystemN: Defines an application, which uses a façade to interact
with the client. There can be multiple subsystems in an application,
such as SubSystem1, SubSystem2, …, SubSystemN.



• Class diagram of the Façade design pattern



• Flyweight Pattern
• The Flyweight design pattern is used to efficiently share information
between a large numbers of objects.
• Several objects may exist in a system, each using some information
and thereby consuming a large amount of memory.
• If all the objects share some static information, you can remove that
information from each object and place in one object.
• All other objects can refer to this object, thus reducing the memory
requirement of the system.
• The object, which contains the common information that is referenced
by other objects, is known as the flyweight object.



• The advantages of using Flyweight design pattern are:
• Enabling large amount objects to share information.
• Making optimum use of memory.
• The participants of Flyweight design pattern are:
• FlyweightFactory: Creates the flyweight objects.
• Flyweight: Declares an interface to enable the flyweights to interact
with the abstract state.
• ClientApp: Invokes the methods of FlyweightFactory class.
• ConcreteFlyweight: Implements the functionality of the abstract class,
Flyweight.



• Class diagram of the Flyweight design pattern



• Proxy Pattern
• The Proxy design pattern enables you to provide a stand-in object in
place of another object.
• The stand-in object receives the requests that are meant for the original
object and delegates the requests to the original object.
• The examples of proxy are remote and virtual.
• A remote proxy object provides a local representation of an object that
runs in a different address space.



• The advantages of using Proxy design pattern are:
• A remote proxy provides location transparency to the client of
object.
• A virtual proxy provides memory optimization be creating objects
when required.

• The participants of Proxy design pattern are:
• ClientProgram: Invokes the methods on a remote object.
• InterfaceMatter: Declares the methods, which are implemented
by the Matter class.
• Matter: An object that provides services to its clients.
• Proxy: An object that intercepts the requests and delegates them
to the original object.



• Class diagram of the Proxy design pattern



Identifying Structural Design Patterns
• Problem Statement
• BlueMoon Inc. provides software consultancy services. The
company foresees a high demand for the retail automation
software. As a result, BlueMoon Inc. decides to develop Retailer
Automation Solution (RAS), which provides the functions to update
the inventory, automate the sales record, and reduce the
transaction-processing time. RAS needs to be developed in a way
that it can be modified according to the specific requirements of
each retailer. For this reason, BlueMoon Inc. ensures that RAS is
extensible and adaptable, which enables BlueMoon Inc. to reuse
the components of the RAS to create customized solutions for
different retailers. John, the software consultant at BlueMoon Inc.
decides to model the structural diagram and identify the various
structural design patterns, which will enable him to reuse the
existing components.



Identifying Structural Design Patterns
(Contd.)
• Solution
• To solve the preceding problem, perform the following tasks:
• Draw the structural diagram of the application.
• Identify the Decorator design pattern.
• Identify the Proxy design pattern.
• Identify the Bridge design pattern.
• Identify the Facade design pattern.



Behavioral Design Patterns

• The Behavioral design pattern
• Defines the state, behavior, and communication among the objects.
• Various Behavioral design patterns are Chain of Responsibility,
Command, Interpreter, Iterator, Mediator, Memento, Observer, State,
Strategy, Template Method, and Visitor.
• Chain of Responsibility Pattern
• Chain of Responsibility design pattern
• Decouples the sender and receiver of a request by introducing a
number of objects between them.
• The advantages of using Chain of Responsibility design pattern are:
• Enabling a group of classes to act as a single class.
• Providing flexibility while dividing responsibilities among the
objects.



Behavioral Design Patterns (Contd.)

• Class diagram of the Chain of Responsibility design pattern



• Command Pattern
• The Command design pattern
• Encapsulates a request as an object and enables the queuing and
logging of requests.
• Supports undo operations.
• The advantages of using Command design pattern are:
• Enables you to execute the commands whenever the resources are
available.
• Enables you to add new commands, as the existing classes do not
change.



• Class diagram of the Command design pattern



Summary
• Structural design patterns that describe the composition of the classes and
objects. This design pattern introduces a level of indirection between a client
class and the class that the client wants to use. The various structural design
patterns are:
• Adapter: Enables classes of different interfaces work together in a
single program.
• Bridge: Separates an interface from its implementation so that either
can be changed without affecting each other.
• Composite: Enables a client to identically treat both the single
component and collection of components.
• Decorator: Enables you to extend the functionality of a particular object
and dynamically provide additional responsibilities to it.
• Façade: provides a unified interface to a collection of interfaces in a
subsystem.
• Flyweight: Enable you to share information among a number of objects.
• Proxy: Enables you to provide a stand-in object in place of another
object.



Summary(Contd.)
• Behavioral design patterns that describe the behavior of an object. The
various Behavioral design patterns are Chain of Responsibility, Command,
Interpreter, Iterator, Mediator, Memento, Observer, State, Strategy,
Template Method, and Visitor.
• Chain of Responsibility: Defines a number of classes can handle a
request without knowing the capabilities of other classes.
• Command: Dispatches a request to a specific application.


Ajs 2 b

Recommended

Recommended

More Related Content

What's hot

What's hot (20)

Viewers also liked

Viewers also liked (18)

Similar to Ajs 2 b

Similar to Ajs 2 b (20)

More from Niit Care

More from Niit Care (17)

Recently uploaded

Recently uploaded (20)

Ajs 2 b