This document discusses design patterns and principles. It begins by defining design patterns as repeatable solutions to common design problems. It then covers several design patterns including Singleton, Strategy, Adapter, Template, Factory, Abstract Factory, and Observer patterns. It also discusses low-level principles like Tell Don't Ask and high-level principles like the Single Responsibility Principle. Finally, it provides examples of how to implement some of the patterns and principles in code.

1. Design Patterns
By Amr A. Ellatief

2. Agenda
• Design Principles
• What is Design pattern
• Types of design patterns
• Singleton pattern
• Strategy pattern
• Adaptor pattern
• Template pattern
• Factory pattern
• Abstract Factory
• Observer pattern

3. What is Design pattern
Design + Pattern

4. Design

5. Design

6. Pattern
• Its like a show, or some repeatable design.

7. Principles of Class Design (OOP Design
Principles)
• Low level Class Design Principles
• High Level Class Design Principles

8. Low Level Class Design Principles
• Tell Don’t Ask
• Once and only Once
• Law of Demeter
• Favor Composition over inheritance.
• Command Query Separation.

9. Low Level Class Design Principles
• Tell Don’t Ask.
• Encapsulate object with its behavior.
• Instead of getting data from object and process it, try to process data in the object.
• Once and only Once.
• If there are two code snippets in your project which are identical, try to put them in
a function and reuse it.
• It reduce the number of lines hence number of probaple bugs, defects,and testing.
• Best line of code, is the line that you don’t write.
• public final constant , Constants.

10. Low Level Class Design Principles
• Law of Demeter
• Try to not call many nested classes.
• As CObject1.getObject2().getObject3().getObject4()
• This will decrease the decoupling.
• Will reduce the ability to test.
• Reusing your code will be easier.

11. Low Level Class Design Principles
• Favor Composition over inheritance.
• In inheritance you benefit from the Super (father) class properties, but think
what happens if we changed the Super Class.(Fragile code)
• Composition is better for testability.
• Composition gives you benefits which may be changed in runtime.

12. Low Level Class Design Principles
• Command Query Separation.
• Queries : return values but don’t change the Queried Entity State.
• getEmployeeName();
• Commands: Don’t return values ,but change the target Entity State.
• updateEmployee();

13. High-level Class Design Principles
• Single Responsibility.
• Open Closed Principle.
• Liskove Substitution Principle
• Interface Segregation Principle.
• Dependency Inversion Principle.

14. High-level Class Design Principles
• Single Responsibility.
• Try to make your Class responsible for single task only.
• Applies on Layers too, jsp and java code.
• Advantages:
• Low coupling .
• Lower dependency.
• Change in one point.
• Disadvantages
• Many classes.

15. High-level Class Design Principles
• Open Closed Principle.
• Better if the System extension could be done, without the change of the code
of the system.
• What we mean is that: system open for extension ,closed for modification.
• As Template design pattern.

16. High-level Class Design Principles
• Liskove Substitution Principle
• Try to make the overridden method have the same result in the child
methods.
• Interface Segregation Principle.
• Don’t use the fat interfaces. It leads to fat Classes.
• We don’t like to make the client override un wanted methods.
• Same idea of modularity.

17. High-level Class Design Principles
• Dependency Inversion Principle.
• Try to make all Classes are depend on interface in their creation.
• The creation should depend on abstraction.
• It enable a third party to control the instantiation of objects.
• You may reduce the new operator instead try some creational patterns
(factory ,abstract factory)

18. High-level Class Design Principles

19. Design PAtterns
Creational
Factory
Abstract Factory
singelton
object bool
prototype
Builder
Structural
Bridge
Composite
Decorator
Facade
proxy
Behavior
Interpreter
Iterator
Chain
observer
Strategy
template

20. Singleton
• Singleton is used when you need to create certain instance from
object.
• You need to keep the same instance most-likely for the hole life cycle
of your app.
• It may be more than one instance could be 1 ,2, .. N instances.

21. Singleton Cont.
• How to make sure that a class could be instantiated only once.
• Private constructor.
• Static keyword.

22. Singleton cont.
• Class diagram

23. Singleton cont.

24. Singleton cont.
• Other ways to make singleton
• Thread safe singleton
• Eager singelton

25. Strategy Pattern
• Problem:
• When you choose from different algorithms in run time, and you may
extend those algorithms in Future.
• Pseudo Code (Bad implementation):
public void doAlgorithm(){
if(algorithm.type=="Algorithm 1"){
perform algorithm_1;
}else if (algorithm.type=="Algorithm 2"){
perform algorithm_1;
}else if(algorithm.type="Algorithm 3"){
perform algorithm 3;
}
What your opinion in this Code ?

26. Strategy Pattern cont.

27. Strategy Pattern cont.

28. Strategy Pattern cont.
• We use the Strategy pattern usually to enable the client Choice from
Algorithms at runtime.
• It hides the complexity of the Algorithm Details from the client.
• It enable for add new algorithm concrete classes without change in
the user class. (Open Closed Principle OCP)
• It reduce the complexity of nested if statement in the Code.

29. Adapter design pattern
• Problem:
• Some time you want to use an object but in the shape of other
object.
• As example use an Enumeration as iterator.
• enumeration.hasMoreElements() -- > iterator.hasNext()
• enumeration. nextElement() ---> iterator. next()

30. Adapter design pattern cont.
• Adapters change the interface of a class without changing its basic
functionality.
• For instance, they might permit interoperability between a geometry
package that requires angles to be specified in radians and a client
that expects to pass angles in degrees.

31. Adapter design pattern cont.
• Use Case : use enumeration as iterator

32. Adapter design pattern cont.

33. Adapter design pattern cont.
• Class Adapter pattern.
• Think how to make the Adapter on the Class level, not on the object
level.

34. Adapter design pattern cont.
• Adapter is about wrapping the basic class in other representable
interface.
• Its Similar to the Facade pattern (however in Façade pattern we may
wrap many classes in one simple interface)

35. Wrap up
• Design Principles
• What is Design pattern
• Types of design patterns
• Singleton pattern
• Strategy pattern
• Adaptor pattern
• Template pattern
• Factory pattern
• Abstract Factory
• Observer pattern

36. Template Design Pattern
• Problem:
• There are two concrete classes which have the similar functionality
however differ only in a few methods.

37. Template Design Pattern cont.
What you think ?

38. Template Design Pattern cont.
• To enhance this code, we use template design pattern.

39. Template Design Pattern cont.

40. Template Design Pattern cont.
• We put the same functionality in one abstract class.
• Making all the concrete objects inherit those common functionality
and perform its own action.
• We could override one of the inherited methods, in this case we call
those as hooks.
• If we want to inforce the user to use certain method with the
functionality we decided in the abstract class we use final.

41. Template Design Pattern cont.
• Note that the method prepare in the abstract class above defines the
main algorithm steps.
•

42. Factory Design pattern
• it's used to construct objects such that they can be decoupled from
the implementing system.
• The factory design pattern is a solution for the object creation, so it
considered as an creational design pattern.
• Its an alternative way for the new operator.
• It generally used to make a single point for creating a category of
opjects.

43. Factory Design pattern cont.

44. Factory Design pattern cont.

45. Abstract Factory Design pattern.
• It considered as additional abstract layer of factory design pattern.
• Abstract factory is used to generate factories , which generates the
objects.
• It should be used when the need is for two categorization levels of
created object required.

46. Abstract Factory Design pattern.

47. Abstract Factory Design pattern.

48. Abstract Factory Design pattern.

49. Observer Design Pattern

50. Observer Design Pattern cont.
• One subject many object that Listen.
• When the subject changed the other object must know
• New Object could be added.
Public updateSubscripers(){
data1=getData ();
Subscriper1.update(data1);
Subscriper1.update(data1);
Subscriper1.update(data1);
// what ypur openion of this solution
}

51. Observer Design Pattern cont.
• Subject : the instance that holds the data, and update the observers.
• Observers: the objects that use the data,and depend on the subject
to update them.
• Each observer implements an interface has method in the Subject.
• Each Subject updates the data in observer by calling this method.

52. Observer Design Pattern cont.

53. Observer Design Pattern cont.

54. Observer Design Pattern cont.

55. Wrap up
• Design Principles
• What is Design pattern
• Types of design patterns
• Singleton pattern
• Strategy pattern
• Adaptor pattern
• Template pattern
• Factory pattern
• Abstract Factory
• Observer pattern

56. Labs
1. create singleton implementation.
2. create singleton implementation supports 3 instances.
3. create singleton implementation supports N instances.
4. Create template design pattern.
5. Create strategy design pattern.
6. Create Factory design pattern.
7. Create factory design pattern which reads the created instances
from properties file.
8. Create observer design pattern.