UML and Software Modeling

# CHAPTER 4

UML and Software Modeling #

1. Introduction #

2. Learning Objectives #

• Define the purpose of the Unified Modeling Language (UML) in software engineering.

• Read and draw a standard UML Class Diagram (Attributes, Methods, Visibility).

• Differentiate between structural relationships: Association, Aggregation, and Composition.

• Understand inheritance and realization (interfaces) in UML.

• Read and interpret a basic Sequence Diagram mapping object interactions over time.

3. What is UML? #

• The Purpose: It provides a standard way to visualize the design of a system.

• The Types: There are many types of UML diagrams, but for Design Patterns, we only care about two:

1. 1. Class Diagrams (Static): Shows the structure. What classes exist, what they hold, and how they connect.

1. 2. Sequence Diagrams (Dynamic): Shows the behavior. How objects talk to each other step-by-step over time.

4. The Class Diagram #

1. 1. Top: The Class Name (e.g., User)

1. 2. Middle: The Attributes/Properties (e.g., - email: String)

1. 3. Bottom: The Operations/Methods (e.g., + login(password): Boolean)

*Visibility Symbols:*

• + Public

• - Private

• # Protected

5. Relationships and Arrows #

• Inheritance (Generalization): A solid line with a hollow, unfilled arrow head pointing from the Child to the Parent. (Dog inherits from Animal).

• Realization (Implements Interface): A dashed line with a hollow, unfilled arrow head pointing from the Class to the Interface. (CreditCard implements PaymentMethod).

• Association (Uses): A simple solid line. Object A knows about Object B.

• Aggregation (Has-A, Weak): A solid line with a hollow diamond. A Classroom has Students. If the Classroom is destroyed, the Students still exist independently.

• Composition (Has-A, Strong): A solid line with a filled/black diamond. A House has Rooms. If the House is destroyed, the Rooms are destroyed with it. The child cannot exist without the parent.

6. Sequence Diagrams #

• Actors/Objects: Represented as boxes at the very top.

• Lifelines: Dashed lines dropping straight down from the objects, representing time flowing downward.

• Messages: Solid arrows pointing horizontally from one lifeline to another, indicating an object calling a method on another object. (e.g., Client points to AuthService with the message login(credentials)).

• Return Messages: Dashed arrows pointing back, indicating the result (e.g., return true).

7. Diagrams/Visual Suggestions #

[ <<Interface>> ]
[ PaymentMethod ]
-----------------
+ pay(amount: Float): void
       ^
       | (Dashed Line, Hollow Arrow)
       |
[ CreditCard ]
-----------------
- cardNumber: String
-----------------
+ pay(amount: Float): void

8. Best Practices #

• Keep it Abstract: Do not try to draw every single getter, setter, and helper variable in a UML diagram. The diagram will become an unreadable mess. A good UML diagram only shows the *architecturally significant* methods and properties necessary to understand the pattern.

9. Common Mistakes #

• Confusing Composition and Aggregation: In an interview, drawing a filled diamond (Composition) when you meant a hollow diamond (Aggregation) changes the entire memory management architecture of the system. Remember: Filled diamond = Death. If the parent dies, the child dies.

10. Mini Project: Model a Library System #

1. 1. The Core: A Library class.

1. 2. Composition (Filled Diamond): The Library has Rooms. (If the library burns down, the rooms are gone).

1. 3. Aggregation (Hollow Diamond): The Library has Books. (If the library closes, the books can be moved elsewhere).

1. 4. Inheritance (Hollow Arrow): We have DigitalBook and PhysicalBook which both inherit from an abstract Book class.

1. 5. Association (Solid Line): A Member class checks out a Book.

11. Practice Exercises #

1. 1. Draw a basic class diagram box for a User class. Give it a private password property and a public updatePassword() method using proper UML visibility symbols (+/-).

1. 2. Explain the difference between Composition and Aggregation. Provide a real-world software example of each.

12. MCQs with Answers #

13. Interview Questions #

• Q: On a whiteboard, draw the UML Class Diagram for the standard Model-View-Controller (MVC) architecture, showing the directional dependencies between the three components.

• Q: Explain the visual difference in UML between a class implementing an Interface versus a class inheriting from a Parent Class.

• Q: Read this diagram (Interviewer points to a Composition relationship). Explain the lifecycle and memory implications of the child object when the parent object is destroyed.

14. FAQs #

15. Summary #

16. Next Chapter Recommendation #