Design Patterns : The Ultimate Blueprint for Software
•
1 recomendación•1,507 vistas
Object Oriented Programming is one of the biggest evolution ever happened to the software industry. Lots of languages started implementing OOP concepts thinking it would add lot of value and will improve the adaptability of the languages. While the OOP provides the concepts, programming languages still lack the essence that is needed for better software design. Design patterns fill the gap by providing solution templates for commonly occurring design problems. As any other software entity, Design Patterns is an evolving subject and it has reached its extreme maturity now by covering most of the design problems that the current software industry is facing. Practicing design patterns has helped the success ratio of software projects these days immensely. Design patterns have become a magic wand in the hands of successful software programmers and architects.
Recomendados
Recomendados
Más contenido relacionado
La actualidad más candente
La actualidad más candente (19)
Destacado
Destacado (11)
Similar a Design Patterns : The Ultimate Blueprint for Software
Similar a Design Patterns : The Ultimate Blueprint for Software (20)
Más de Edureka!
Más de Edureka! (20)
Último
Último (20)
Design Patterns : The Ultimate Blueprint for Software
- 1. www.edureka.co/design-patterns View Design Patterns course details at www.edureka.co/design-patterns For Queries during the session and class recording: Post on Twitter @edurekaIN: #askEdureka Post on Facebook /edurekaIN For more details please contact us: US : 1800 275 9730 (toll free) INDIA : +91 88808 62004 Email us : sales@edureka.co Design Patterns : The Ultimate Blueprint for Software
- 2. Slide 2 www.edureka.co/design-patterns At the end of this session, you will be able to: Objectives Know what is Software Design Patterns Understand the need of Software Design Patterns Code with Adapter Pattern Communicate among objects with Mediator Pattern Distribute Responsibility using Chain Of Responsibility Pattern Decorate your objects with Decorator Pattern
- 3. Slide 3 www.edureka.co/design-patterns Software Design Patterns & Gang Of Four(GOF) Software design patterns describe relationship among classes to solve a general and repeatable design problem in a specific context with proven solution Anyone who knows something about Software Design Patterns will certainly be aware of famous book “Elements of Reusable Object-Oriented Software” written by Erich Gamma, Richard Helm, Ralph Johnson and John Vlissides popularly knows as Gang Of Four(GOF) This is the most popular book written on Software Design Patterns by Erich Gamma, Richard Helm, Ralph Johnson and John Vlissides, known as Gang Of Four
- 4. Slide 4 www.edureka.co/design-patterns Classification of Software Design Patterns Software Design Patterns Creational Design Pattern Factory Pattern Object Pool Pattern Singleton Pattern Structural Design Pattern Adapter Pattern Decorator Pattern Composite Pattern Behavioral Design Pattern Chain of Responsibility Pattern Mediator Pattern Observer Pattern . . . . . . . . .
- 5. Slide 5 www.edureka.co/design-patterns Importance of Design Patterns Just knowing a Programming Language is not enough to engineer a software application While building an application its important that we keep the future requirements and changes in mind otherwise you will have to change the code that you had written earlier Building a large application is never easy, so its very important that you design it correctly and then start coding the application Design Patterns provides efficient techniques to create a flexible application design
- 6. Slide 6Slide 6Slide 6 www.edureka.co/design-patterns Adapter Pattern converts interface of a class into another interface Adapter Pattern lets two incompatible interfaces work together For example European sockets are circular and American plugs are rectangular, now to plug an American rectangular plug into European circular socket you need an adapter Adapter Pattern Adapter
- 7. Slide 7Slide 7Slide 7 www.edureka.co/design-patterns Adapter Pattern – UML Diagram
- 8. Slide 8Slide 8Slide 8 www.edureka.co/design-patterns Problem Statement Application development confines working with various third party APIs There are lots of cases where the client code can not directly work with third party API because it provides a different interface then what your client code expects For example suppose there is lot of client code already written using Enumeration, but you need to use a third party API that uses Iterators rather than Enumeration Solution One solution is to change entire client code to target interface Other solution is to use an Adapter that adapts client code to target interface without changing any previous code
- 9. Slide 9Slide 9Slide 9 www.edureka.co/design-patterns Implementing Adapter Pattern Client Code is written using Enumeration Third Party API uses Iterator
- 10. Slide 10Slide 10Slide 10 www.edureka.co/design-patterns Implementing Adapter Pattern (Contd.) Adapter implements the target interface (Iterator) Adapter adapts Enumeration to Iterator While using Adapter pattern we don’t change client code or third party code
- 11. Slide 11Slide 11Slide 11 www.edureka.co/design-patterns Decorator Pattern Decorator pattern refers to creation of wrapper to original object by providing extra functionalities to it While the same functionality can be achieved by using sub-classes, it is not a preferred approach where there is a need to add same kind of functionality to lot of different object, it increases the number of subclasses and creates a memory over-head You can use the same decorator to decorate different objects
- 12. Slide 12Slide 12Slide 12 www.edureka.co/design-patterns Decorator Pattern - UML Diagram Decorators implement the same interface or abstract class as the component they are going to decorate ConcreteComponent is the object we are going to dynamically add new behavior to. It extends Component
- 13. Slide 13Slide 13Slide 13 www.edureka.co/design-patterns Beverage CappuccinoEspressoDarkRoast Understanding Decorator Pattern Suppose you have to design a CoffeeShop application. One of the simplest design would be as below: Beverage abstract class and specific coffee classes extending from that abstract class Each coffee can be decorated with extra milk or soy or mocha etc
- 14. Slide 14Slide 14Slide 14 www.edureka.co/design-patterns DarkRoast DarkRoastWithMocha DarkRoastWithMilk DarkRoastWithSoy Espresso EspressoWithSoy EspressoWithMilk EspressoWithMocha Cappuccino CappuccinoWithMocha CappuccinoWithMilk CappuccinoWithSoy This approach is bad as you have to create a separate concrete class for each Coffee and decorator combination And as milk prices changes you have to change the cost of each Coffee that is decorated with Milk Understanding Decorator Pattern (Contd.) This design is static as it does not reuse the decorators(milk, soy, mocha) and will result in a large number of subclasses
- 15. Slide 15Slide 15Slide 15 www.edureka.co/design-patterns Understanding Decorator Pattern This design can decorate a beverage with milk, soy and mocha dynamically Beverage CappuccinoEspressoDarkRoast Decorator MochaSoyMilk
- 16. Slide 16Slide 16Slide 16 www.edureka.co/design-patterns Implementing Decorator Pattern
- 17. Slide 17 www.edureka.co/design-patternsSlide 17Slide 17Slide 17 Implementing Decorator Pattern (Contd.)
- 18. Slide 18Slide 18Slide 18 www.edureka.co/design-patterns Testing Decorator Pattern Output No decoration Decoration with Soy and Milk Decoration with Soy, Milk and Mocha
- 19. Slide 19Slide 19Slide 19 www.edureka.co/design-patterns Understanding Decorator Pattern java.io package makes extensive use of Decorator pattern. Each decorator adds new functionality to the underlying class to which it is applied OutputStream have similar API as InputStream InputStream ByteArrayInputStream ObjectInputStream FileInputStream FilterInputStream LineNumberInputStreamDataInputStreamBufferedInputStream
- 20. Slide 20Slide 20Slide 20 www.edureka.co/design-patterns Writing a Java IO Decorator Below class decorate the input stream, such that each character read from input stream will be return in uppercase
- 21. Slide 21Slide 21Slide 21 www.edureka.co/design-patterns Testing our Java IO Decorator FileInputStream is decorated with UpperCaseInputStream which will return each character read from inventory.txt in upper case
- 22. Slide 22Slide 22Slide 22 www.edureka.co/design-patterns Chain Of Responsibility pattern gives more than one object a chance to handle the request Sender of the request does not know which object in the chain will serve its request In Chain Of Responsibility pattern a chain of request handlers is maintained, a handler decides whether it can handle the request or not, if not then it passes the request to next handler Chain of Responsibility (COR) Receiver 1 Receiver 2 Receiver 3 Request Request Request Receiver N Request Reference to Receiver 2 Reference to Receiver 3 Chain of Receiver Reference to Receiver 4 Cannot handle
- 23. Slide 23Slide 23Slide 23 www.edureka.co/design-patterns 1. Handler - defines an interface for handling requests 2. ConcreteHandler - handles the requests it is responsible for .If it can handle the request it does so, otherwise it sends the request to its successor 3. Client - sends commands to the first object in the chain that may handle the command Handler +HandleRequest() ConcreteHandler1 +HandleRequest() ConcreteHandler2 +HandleRequest() Client Chain of Responsibility - UML Diagram
- 24. Slide 24Slide 24Slide 24 www.edureka.co/design-patterns Problem Statement Customer support system is one of the implementation of this pattern, where users calls the help desk (L1 support) and tell their problem L1 Support L2 Support Cannot handle Problem Statement Resolved Resolved YES NO YES NO Request goes through multiple objects (handlers)
- 25. Slide 25Slide 25Slide 25 www.edureka.co/design-patterns Solution Using Chain of responsibility simplifies the request object because it does not have to know the chain’s structure and keep direct references to its members In this case, user simply interact with help desk and the request internally goes through multiple handlers User does not need to know about the different handlers
- 26. Slide 26Slide 26Slide 26 www.edureka.co/design-patterns Implementing Chain of Responsibility Client (user) will generate a SupportRequest (a ticket) All support levels will have to inherit the support class and implement the handleRequest()
- 27. Slide 27Slide 27Slide 27 www.edureka.co/design-patterns Implementing Chain of Responsibility (Contd.)
- 28. Slide 28Slide 28Slide 28 www.edureka.co/design-patterns Implementing Chain of Responsibility (Contd.)
- 29. Slide 29Slide 29Slide 29 www.edureka.co/design-patterns Implementing Chain of Responsibility (Contd.) Here we are creating chain of responsible objects for handling the support request according to user query All the support requests will first go to L1 support Output
- 30. Slide 30Slide 30Slide 30 www.edureka.co/design-patterns Other Uses Of Chain of Responsibility One of the most important use of Chain Of Responsibility pattern is to implement filter mechanism Here one filter process the request and then passes on to next filter in the chain, similarly next filter processes the request and then passes onto next filter in chain JavaEE API uses Chain Of Responsibility pattern to implement filter mechanism using the following doFilter() method javax.servlet.Filter#doFilter(ServletRequest request, ServletResponse response, FilterChain chain) Request Logging Filter Authentication Filter Servlet JAX-WS also uses Chain Of Responsibility pattern to implement JWS Handler Framework, which allows manipulation of SOAP messages
- 31. Slide 31Slide 31Slide 31 www.edureka.co/design-patterns Mediator Pattern The mediator pattern promotes loose coupling of objects by removing the need for classes to communicate with each other directly Instead, mediator objects are used to encapsulate and centralize the interactions between classes Mediator pattern simplifies communication in general when a program contains large number of classes that interact Each class only needs to know how to pass messages to its mediator, rather than to numerous colleagues
- 32. Slide 32Slide 32Slide 32 www.edureka.co/design-patterns Mediator Pattern – UML Diagram Mediator - defines an interface for communicating with Colleague objects ConcreteMediator - knows the colleague classes and keep a reference to the colleague objects Colleague classes - keep a reference to its Mediator object Mediator ConcreteMediator ConcreteColleagueA ConcreteColleagueB Colleague
- 33. Slide 33Slide 33Slide 33 www.edureka.co/design-patterns Problem Statement Suppose you have to create a chat application where multiple users can chat together Rather than each user sending the message directly to other users, we can use mediator pattern to implement this design
- 34. Slide 34Slide 34Slide 34 www.edureka.co/design-patterns Implementing Mediator Pattern ChatMediator keeps the reference of all the users
- 35. Slide 35Slide 35Slide 35 www.edureka.co/design-patterns Implementing Mediator Pattern (Contd.) A User doesn’t have any reference to other users
- 36. Slide 36Slide 36Slide 36 www.edureka.co/design-patterns Output Implementing Mediator Pattern (Contd.)
- 37. Slide 37Slide 37Slide 37 www.edureka.co/design-patterns ContactSelectorPanel ContactDisplayPanel ContactEditorPanel 1. All GUI applications consists of small components like Windows, Panel etc. 2. Each Panel contains a group of GUI element 3. These panels have to co-ordinate among themselves 4. As in this application, whenever a contact is selected from the drop down box, its details should be updated in the ContactDisplayPanel and ContactEditorPanel 5. Rather then one panel having reference of all other panels, we can use Mediator Pattern to simplify the communication between panel objects Implementing Mediator Pattern (Contd.)
- 38. Slide 38 www.edureka.co/design-patterns Conclusion Similarly there are other design patterns to solve majority of the problems that software designers encounter during their day to day activities Design patterns compliments ones experience and helps them deliver wonderful and successful software designs They serve as common nomenclature or jargon that architects can easily communicate with others in software industry Software design is no more an art. It’s a skill one can learn. And thanks to design patterns
- 39. Slide 39 www.edureka.co/design-patterns Module 1 » Introduction to Design Patterns Module 2 » Creational Design Patterns Module 3 » Structural Design Patterns Module 4 » Behavioral Patterns Module 5 » Concurrency Design Patterns Module 6 » Anti Patterns Module 7 » Refactoring Module 8 » Project and Retrospection Course Topics
- 40. Slide 40 LIVE Online Class Class Recording in LMS 24/7 Post Class Support Module Wise Quiz Project Work Verifiable Certificate www.edureka.co/design-patterns How it Works?