CSC307 Lecture 07

Introduction to Software Engineering
Design Patterns
(202407)

This lecture explores the use of design patterns, emphasizing their definitions and the importance of reusable designs in real-world applications, particularly those from the Gang of Four (GoF) patterns. We will focus on the observer, singleton, decorator, and composite patterns. Diverse practical examples and code references are provided.

Transcript

1. Dr. Javier Gonzalez-Sanchez javiergs@calpoly.edu www.javiergs.info office: 14 -227 CSC 307 Introduction to Software Engineering Lecture 07. Patterns
2. Homework 1. Due Monday: Quiz 2
3. Homework Due Monday: Paint-App 2.0
4. Thread, Runnable, and Timer 4 https:/ /github.com/CSC3100/Pacman
5. Previously
6. Relationships 6 Association Directed Association Reflexive Association Multiplicity Aggregation Composition Generalization Realization
7. Good Code vs Bad Code 7
8. Not Everything that Can be … Should be … 8
9. Not Everything that Can be … Should be … 9
10. Not Everything that Can be … Should be … 10
11. Patterns
12. Definition • Design patterns are solutions to software design problems you find again and again in real-world application development. • Patterns are about reusable designs and interactions between objects. • The 23 Gang of Four (GoF) patterns are generally considered the foundation for all other patterns (Gamma, Helm, Johnson, and Vlissides). 12
13. Timeline 13 1989 Beck OO Thinking 1993 Gamma et al. GoF Patterns
14. GoF Patterns 14
15. Observer
16. Observer 16
17. Classroom | Initial Version 17 https://github.com/CSC3100/Patterns
18. Student | Initial Version 18 https://github.com/CSC3100/Patterns
19. Teacher | Initial Version 19 https://github.com/CSC3100/Patterns
20. Observer 20
21. Observer 21 https://github.com/CSC3100/Patterns
22. Observable 22 https://github.com/CSC3100/Patterns
23. Classroom | New Version 23 https://github.com/CSC3100/Patterns
24. Student | New Version 24 https://github.com/CSC3100/Patterns
25. Teacher | New Version 25 https://github.com/CSC3100/Patterns
26. Important 26 Do not reinvent the wheel! (Do not make another implementation for classes Observer or Observable -they already exist in libraries!)
27. Important 27 Depreciated java.util.Observer java.util.Observable The implementation of these packages That is NOT about the Observer pattern being depreciated.
28. Important 28 Use java.beans.PropertyChangeListener java.beans.PropertyChangeSupport
29. Classroom | Listener Version 29 https://github.com/CSC3100/Patterns
30. Student | Listener Version 30 https://github.com/CSC3100/Patterns
31. Teacher | Listener Version 31 https://github.com/CSC3100/Patterns
32. Thoughts? 32
33. Test Yourselves
34. Problem • Imagine a class Teacher running in its own execution thread, forever grading—recording grades as a collection of numerical values. • A panel (PrinterPanel) would like to show the grades as they are generated. • Another panel (StatisticalPanel) would like to show real-time statistics about the grades (how many pass and how many fail). 34
35. Homework 35 Reading https://medium.com/swlh/software-design-patterns-why-what-and-an-example-8d4c0934a6ca
36. Singleton
37. Singleton 37
38. Singleton 38 https://github.com/CSC3100/Patterns
39. Singleton 39 https://github.com/CSC3100/Patterns
40. Warning 40 Do not Abuse of the Singleton You are transforming OOP into Structural Programming!! !
41. Note 41 Do you remember our class Officer
42. Homework 42 Reading https://medium.com/javarevisited/design-patterns-101-hello-singleton-2d3f227c7729
43. Decorator Composite
44. Decorator | Composite 44
45. Decorator | Composite 45
46. Decorator | Composite 46
47. Decorator 47
48. Composite 48
49. Example 49
50. Component 50 https://github.com/CSC3100/Patterns
51. ConcreteComponent | Ball 51 https://github.com/CSC3100/Patterns
52. Decorator 52 https://github.com/CSC3100/Patterns
53. ConcreteDecoratorOne | Bag 53 https://github.com/CSC3100/Patterns
54. ConcreteDecoratorTwo | Box 54 https://github.com/CSC3100/Patterns
55. Main 55 draw draw draw https://github.com/CSC3100/Patterns
56. Composite | Example 56 draw
57. Decorator vs Inheritance • Both allow you to change how an object behaves. • The decorator pattern allows you to extend (decorate) the functionality of an object at runtime. • Inheritance adds behavior at compilation time. 57
58. Homework 58 Reading https://medium.com/javarevisited/software-design-patterns-decorator-in-a-nutshell-eefd2025ea3c
59. Questions 59
60. Lab 07. Astah
61. Help me with the Class Diagram in Astah 62 https:/ /github.com/CSC3100/Pacman
62. Let’s Work 63
63. CSC 307 Introduction to Software Engineering Javier Gonzalez-Sanchez, Ph.D. javiergs@calpoly.edu Summer 2024 Copyright. These slides can only be used as study material for the class CSC307 at Cal Poly. They cannot be distributed or used for another purpose.