UML Class Diagrams

Before we start

Why this matters

Outline · Labs IX–X

Topics in this chapter

Select a topic to jump to the slide that explains it.

1. Class diagram basics
2. Relationships
3. Extended class diagrams
4. Worked diagrams
5. Designing your own
6. Common mistakes

Concept 1 of 15

UML and the class diagram

Class diagram basics

Anatomy of a class

Class diagram basics

Anatomy of a class (cont.)

• Name: centred, bold, starts with a capital letter, singular noun (Account, not Accounts).
• Attributes: left-aligned, first letter lowercase, one per line: visibility name : type = default, e.g. - balance : double = 0.
• Operations: visibility name(parameter : type) : returnType, e.g. + withdraw(amount : double) : boolean.
• The attribute and operation compartments are optional; an empty box with only a name is fine in an overview diagram.

Class diagram basics

Visibility and other markers

Class diagram basics

Visibility and other markers (cont.)

Concept 4 of 15

Relationships at a glance

Concept 4 of 15

Relationships at a glance (cont.)

The lab manual’s Table X.1, in words.

Relationships

Association and multiplicity

• An association is a lasting structural link: objects of one class hold references to objects of the other.
• Bidirectional (plain line): both classes know each other. Unidirectional (open arrow): only the source knows the target.
• Label it with a name (a verb: owns) and optionally role names at the ends.
• Multiplicity at each end says how many objects take part: 1, 0..1, *, 1..*, 2..4.
• Read multiplicity from the far end: “one Company employs 1..* Employees; each Employee works for 1 Company.”

Relationships

Association and multiplicity (cont.)

Interactive

Reading multiplicity

Relationships

Aggregation, composition and dependency

Relationships

Aggregation, composition and dependency (cont.)

class House {                       // composition
    private List<Room> rooms = new ArrayList<>();
    House() { rooms.add(new Room("Kitchen")); }   // parts created inside
}
class Department {                  // aggregation
    private List<Teacher> teachers;
    void add(Teacher t) { teachers.add(t); }       // parts come from outside
}

Concept 8 of 15

Generalization and abstract classes

Concept 8 of 15

Generalization and abstract classes (cont.)

abstract class Person {
    private String name, address;
    abstract void printInfo();
}
class Employee extends Person { ... }

• Generalization is inheritance: the child is a kind of the parent and inherits its attributes and operations. Draw a solid line with a hollow triangle pointing to the parent.
• An abstract class cannot be instantiated; its name is written in italics (or marked {abstract}).
• An abstract operation has no body; it is also italic, and each concrete subclass must implement it.
• Draw one triangle and merge the lines when several classes share a parent.

Extended class diagrams

Interfaces and realization

Extended class diagrams

Interfaces and realization (cont.)

interface Payable {
    boolean pay(double amount);
    void refund(String id);
}
class DebitCard implements Payable { ... }

• An interface is a named set of operations with no implementation — a contract. Show it as a class box with «interface» above the name.
• Realization (implementation): a dashed line with a hollow triangle from the class to the interface. The class promises to implement every operation.
• A class can realize many interfaces but (in Java) extend only one class.
• Example from the manual: an Owner interface with acquire(property) and dispose(property), realized by both Person and Corporation — in very different ways.

Interactive

Name the relationship

Concept 11 of 15

Example: a telephone

Concept 11 of 15

Example: a telephone (cont.)

• A Telephone aggregates a Ringer, a CallerId and an AnsweringMachine (hollow diamonds at Telephone).
• The AnsweringMachine is composed of its recorded Messages (filled diamond): delete the machine and the messages go with it.
• A Line connects 0..* telephones; each telephone is on 0..1 line.
• Every attribute is private (-) with public operations (+).

Worked diagrams

Example: the ATM system

Worked diagrams

Example: the ATM system (cont.)

Redrawn from the manual’s Figure X.6. The two inheritance trees (accounts and transactions) and the multiplicities are the parts examiners check first.

Concept 13 of 15

How to design a class diagram

1. Identify the classes. Underline the nouns in the SRS and use case descriptions; keep the ones the system must remember (Account, Card), drop synonyms, attributes (balance) and actors that are outside the system.
2. Add attributes — facts about each class (name, address, dob).
3. Add operations — the verbs, and every message from your sequence diagrams.
4. Find relationships: “has / owns” → association or aggregation/composition; “is a kind of” → generalization; “implements” → realization; “uses briefly” → dependency.

Concept 13 of 15

How to design a class diagram (cont.)

5. Add multiplicities at both ends of every association.
6. Review against the use cases: can every scenario be carried out with these classes?

Concept 14 of 15

Common mistakes

Your turn

Your turn: the lab tasks

Worked example 1 of 3

Worked example 1

Worked example 2 of 3

Worked example 2

Worked example 3 of 3

Worked example 3

Practice

Practice (1 of 2)

Try each one on paper first, then check your answer.

Practice

Practice (2 of 2)

Try each one on paper first, then check your answer.

Check yourself

Quiz

Resources

Further learning

Hand-picked material to go deeper. Links open in a new tab.

Resources

Further learning (cont.)

Summary

Summary

• A class box has name, attributes (visibility name : type) and operations (visibility name(params) : type).
• Visibility: + public, - private, # protected, ~ package; underline = static, italic = abstract.
• Association (with multiplicity) < aggregation (◇, independent parts) < composition (◆, parts die with the whole); dependency is a short “uses”.
• Generalization (hollow triangle to the parent) = inheritance; realization (dashed) = implementing an interface.
• Find classes from nouns, operations from verbs and sequence-diagram messages.
• Check the class diagram against the use cases and sequence diagrams.