· Milav

Lecture 22: UML Class Diagrams

Unit 3: Requirement Analysis and Design (4353202)

Lecture Agenda

Recap of Use Case Diagrams
What is a Class Diagram?
Components of a Class Diagram (Classes, Attributes, Operations)
Relationships in Class Diagrams (Association, Generalization, Aggregation, Composition)
Example: Library Management System Class Diagram
Advantages of Class Diagrams
Key Takeaways

Recap of Use Case Diagrams

Use Case Diagrams describe the functionality of a system from the user's perspective, showing actors and the use cases they perform. They are excellent for defining system scope and communicating with stakeholders.

What is a Class Diagram?

A Class Diagram is a structural UML diagram that describes the static structure of a system by showing the system's classes, their attributes, operations (or methods), and the relationships among objects.

It is the most common diagram in object-oriented modeling and is used for conceptual modeling of the system's structure.

Components of a Class Diagram: Classes

A class is a blueprint for creating objects (a particular data structure), providing initial values for state (member variables or attributes), and implementations of behavior (member functions or methods).

classDiagram class ClassName { +attribute1: Type -attribute2: Type +operation1() -operation2() }

Class Name: The name of the class.
Attributes: The properties or data fields of the class. (e.g., +name: String, -balance: Double)
Operations (Methods): The functions or behaviors that the class can perform. (e.g., +deposit(amount: Double))

Relationships in Class Diagrams: Association

An Association represents a relationship between two or more classes. It shows that objects of one class are connected to objects of another class.

classDiagram Customer "1" -- "*" Order

Multiplicity: Indicates how many instances of one class are related to instances of another class (e.g., 1, *, 0..1, 1..*).
Navigability: Indicates the direction of the relationship (e.g., one-way or two-way).

Relationships in Class Diagrams: Generalization

Generalization represents an inheritance relationship, where a subclass inherits properties and behaviors from a superclass. It is an "is-a" relationship.

classDiagram Animal <|-- Dog Animal <|-- Cat

Dog is an Animal, Cat is an Animal.

Relationships in Class Diagrams: Aggregation & Composition

Both represent a "has-a" relationship, but with different strengths of ownership.

Aggregation (Weak "has-a"): Represents a whole-part relationship where the parts can exist independently of the whole. (Hollow diamond)
Composition (Strong "has-a"): Represents a whole-part relationship where the parts cannot exist independently of the whole. If the whole is destroyed, the parts are also destroyed. (Solid diamond)

classDiagram Car o-- Wheel : Aggregation House *-- Room : Composition

Example: Library Management System Class Diagram

classDiagram class Library { +name: String +address: String +addBook() +removeBook() +searchBook() } class Book { +bookId: String +title: String +author: String +ISBN: String +isAvailable: Boolean +getDetails() } class Member { +memberId: String +name: String +email: String +phone: String +issueBook() +returnBook() } class Transaction { +transactionId: String +issueDate: Date +returnDate: Date +fine: Double +calculateFine() } Library "1" o-- "many" Book Member "1" o-- "many" Transaction Book "1" o-- "many" Transaction

Advantages of Class Diagrams

Visual Representation: Provides a clear, static view of the system's structure.
Detailed Design: Helps in designing the database schema and object-oriented code.
Communication: Facilitates communication among developers and stakeholders about the system's components.
Maintainability: A well-designed class diagram makes the system easier to understand and maintain.
Reusability: Promotes the identification of reusable components.

Key Takeaways

**Class Diagrams** show the static structure of a system.
They consist of **classes, attributes, and operations**.
Key relationships include **association, generalization, aggregation, and composition**.
They are essential for **object-oriented design** and **database modeling**.

Next Lecture

Topic: UML Sequence Diagrams

Q & A

Questions & Discussion