Design pattern

1. UNIT IV DESIGN PATTERNS
Presented By R.Krishna Prakash,
Assistant Professor/CSE,
Kongunadu College Of Engineering And Technology.
KONGUNADU COLLEGE OF ENGINEERING
AND TECHNOLOGY
(AUTONOMOUS)

2. UNIT IV DESIGN
PATTERNS

3. Design Patterns
• It’s typical solutions to common problems in software design.
• Each pattern is like a blueprint that you can customize to solve a
particular design problem in your code

4. Designing objects with responsibilities
• GRASP-General responsibility assignment software patterns
- GRASP is a tool that helps to master the basics of OOD and
understanding responsibilities
- A learning aid that helps to understand for OO design with
responsibilities

5. • RDD -Responsibility Driven Design
It’s thinking about object oriented design
Doing responsibility- creating action, initializing, controlling
and coordinating activities
Knowing responsibilities- includes knowing about private
and related data

6. Applying Grasp to Object Design
There are nine different GRASP patterns:
(i) Creator
(ii) Information expert
(iii) Low coupling
(iv) Controller
(v) High cohesion
(vi) Polymorphism
(vii) Pure fabrication
(viii) Indirection
(ix) Protected variations

7. Creator
• Its one of the common activities in object oriented system
is creation of object
• General principle is applied for the assignment of creation
responsibilities.

8. If B is a creator of A objects then atleast one of the following
must be true.
• B contains A
• B compositely aggregates A
• B records A
• B closely uses A

10. INFORMATION EXPERT
•Designing objects, interaction between objects are defined
about assigning responsibilities to software classes
This makes the software easier to
• Maintain
• Understand
• Extend

14. LOW COUPLING
Coupling is the measure of less strongly one element is
connected to the other elements.
Types of coupling
There are 2 types of coupling
1) Low coupling or weak coupling
2) High coupling or strong coupling

15. • Low coupling
An element if does not depend on too many other elements like
classes, subsystems systems it is having low coupling
• High coupling
A class with high coupling relies on many other classes.
The problems of high coupling are
• Harder to understand
• Harder to reuse

16. Example

17. Benefits for LOW Coupling
•Not affected by changes in other components
•Simple to understand
•Convenient to reuse

18. HIGH COHESION
•Strongly related and focused responsibilities of an
element. An element has high cohesion if it,
•Difficulties of low cohesion are
•Hard to comprehend
•Hard to reuse
•Hard to maintain

20. Functional Cohesion
(1) Very low cohesion
• A class is solely responsible for many things in different functional areas.
(2) Low cohesion
• A class has sole responsibility for a complex task in one functional area.
(3) High cohesion
• A class has moderate responsibilities in one functional area and
collaborates with others.
(4) Moderate cohesion
• A class has light weight. It is responsible for different areas logically
related to the class concept but not to each other

21. High cohesion is
• Easy to maintain
• Understand
• Reuse
Benefits of high cohesion are
•Clarity
•Ease of comprehension

22. CONTROLLER
•A controller is defined as the first object beyond the user interface
(UI) layer that is responsible for the receiving or handling a system
operation message.

24. Design patterns
Designing for visibility:
• One object to have reference of another is called visibility
Ex: getProductDescription message sent from a Register to a
product catalog means that ProductCatalog instance is
visible to register.

26. Ways of visibility: from Object A to Object B
Attribute visibility – B is an attribute of A
Parameter visibility – B is a parameter of a method of A
Local visibility – B is a local object in a method of A
Global visibility – B is globally visible in some way

27. Attribute visibility

28. Parameter visibility

29. Local visibility

30. Factory Method
•Factory Method is a creational design pattern that provides
an interface for creating objects in a superclass, allows
subclasses to alter the type of objects that will be created.

31. Factory Method pattern
PROBLEM:
◦ A framework with abstract application classes and application-
specific subclasses to instantiate to realize different
implementations
SOLUTION:
◦ The Factory Method pattern encapsulates the knowledge of which
subclass to create and moves this knowledge out of the framework

32. Bridge pattern
The Bridge pattern is designed to separate a class's interface from its
implementation
so you can vary or replace the implementation without changing the
client code.

33. •Decouple an abstraction from its implementation
•Allows different implementations of an interface to be decided upon
dynamically.
•Also known as Handle/Body pattern

34. •Avoid a permanent binding between an abstraction and its
implementation
•Both the abstractions and their implementation should be extensible
by subclass
•Changes in the implementation of an abstraction do not impact the
clients
•Share an implementation among multi objects and this facts should
be hidden from the client
•E.g: Windows, program

35. Structure

36. Solution using Bridge

37. Adapter
• The adapter pattern is adapting between classes and
objects.
• Like any adapter in the real world it is used to be an
interface, a bridge between two objects.
• EX :Camera memory

38. Variations in Adapters
•Class Adapters
Use multiple inheritance to compose classes
•Object Adapters
Object adapters use a compositional technique to adapt
one interface to another.

39. Variations in Adapters
• Name : Adapter
• Problem : If similar components have different
interfaces then how to resolve incompatible interfaces.
• Solution : Using an intermediate adapter object,
convert original interface of a component to another
interface.

40. Object Pattern
adaptee

41. Use of Adapter
•Tax calculators
•Credit authorization services
•Accounting systems etc

42. SINGLETON
•Singleton is a class that allows only a single instance of itself
to be created and gives access to that created instance.
•It contains static variables that can accommodate unique
and private instances of itself.

43. Implementation of singleton
• Singleton is implemented with a ‘1‘ in the top right corner
of name compartment.
• Class X defines a static method getInstance‘ that provides
single instance of X

44. Class
public class Register
{
public void initialize ( )
{
… do some work…
//accessing singleton factory in a getInstance call accounting
Adapter =
ServicesFactory.getInstance().getAccountingAdapter( );
… do some work…
} //other methods…
}//end of class

46. Design Issues in implementation
public static synchronized ServiceFactory getInstance ( )
{
if (instance ==null)
{
instance = newServicesFactory ( );
}
return instance;
}

47. Eager initialization
public class servicesFactory
{
private static servicesFactory instance = new ServicesFactory ( );
public static servicesFactory getInstance ( )
{
Return instance;
}
// other methods…
}

48. Observer pattern
•To extend the solution found for changing data, add the ability for a
GUI window to refresh its sale.
•The Observer design pattern, or more accurately some
implementation of this pattern, is used to assure consistency
between different objects

49. Subject & Observer
Subject
◦The object which will frequently change its state and
upon which other objects depend
Observer
◦The object which depends on a subject and updates
according to its subject's state.

50. Observer Pattern - Example
a b c
60
y
x
5030
30
20
10
z 801010 a b c
a
b
c
a = 50%
b = 30%
c = 20%
change notification
requests, modifications
Subject

51. GOF(Gang of four) design patterns
1. Adapter pattern
2. Factory method
3. Singleton
4. Strategy

52. MAPPING DESIGN TO CODE
•The implementation Model, the UML artifacts
created during the code generation is used as input.
•The implementation artifacts consists of source code,
database definitions, JSP/XML/HTML pages

53. •Java
•C#
•Visual Basic
•C++
•Small talk
•Python

54. Defining a class with method signatures
and attributes

55. Creating Methods from Interaction
Diagrams

56. Message
public void enterItem (itemID, int qty)
ProductDescription desc = catalog.getProductDescription (itemID);
CurrentSale.makeLineItem (desc, qty);

58. Exceptions and Error Handling
•Applications development consider large – scale exception handling
strategies during design modeling.
•Indicated in the property strings of messages and operation
declarations

59. Exceptions and Error Handling
• Exceptions are indicated in the property strings of
messages and operation declarations.
Collection Classes in Code
• There are many one to many relationships.
• These are implemented with the collection object such as
List or Map or array

60. Order of Implementation

61. Order of Implementation