UML

What

UML class diagrams describe the structure (but not the behavior) of an OOP solution. These are possibly the most often used diagrams in the industry and an indispensable tool for an OO programmer.

📦 An example class diagram:

What

The basic UML notations used to represent a class:

📦 A Table class shown in UML notation:

class Table{
    
    Integer number;
    Chair[] chairs = null;
    
    Integer getNumber(){
        ...
    }
    
    void setNumber(Integer n){
        ...
    }
}

The 'Operations' compartment and/or the 'Attributes' compartment may be omitted if such details are not important for the task at hand. 'Attributes' always appear above the 'Operations' compartment. All operations should be in one compartment rather than each operation in a separate compartment. Same goes for attributes.

The visibility of attributes and operations is used to indicate the level of access allowed for each attribute or operation. The types of visibility and their exact meanings depend on the programming language used. Here are some common visibilities and how they are indicated in a class diagram:

• + : public
• - : private
• # : protected
• ~ : package private

📦 Table class with visibilities shown:

Basic

We use a solid line to show an association between two classes.

Navigability

We use arrow heads to indication the navigability of an association.

📦 Logic is aware of Minefield, but Minefield is not aware of Logic

class Logic{
    Minefield minefield;
}

class Minefield{
    ...
}

Navigability can be shown in class diagrams as well as object diagrams.

Roles

Association Role labels are used to indicate the role played by the classes in the association.

📦 This association represents a marriage between a Man object and a Woman object. The respective roles played by objects of these two classes are husband and wife.

Note how the variable names match closely with the association roles.

class Man{
    Woman wife;
}

class Woman{
    Man husband;
}

📦 The role of Student objects in this association is charges(i.e. Admin is in charge of students)

class Admin{
    List<Student> charges;
}

Labels

Association labels describe the meaning of the association. The arrow head indicates the direction in which the label is to be read.

📦 In this example, the same association is described using two different labels.

• Diagram on the left: Admin class is associated with Student class because an Admin object uses a Student object.
• Diagram on the right: Admin class is associated with Student class because a Student object is used by an Admin object.

Multiplicity

Commonly used multiplicities:

• 0..1 : optional, can be linked to 0 or 1 objects
• 1 : compulsory, must be linked to one object at all times.
• * : can be linked to 0 or more objects.
• n..m : the number of linked objects must be n to m inclusive

📦 In the diagram below, an Admin object administers (in charge of) any number of students but a Student object must always be under the charge of exactly one Admin object

📦 In the diagram below,

• Each student must be supervised by exactly one professor. i.e. There cannot be a student who doesn't have a supervisor or has multiple supervisors.
• A professor cannot supervise more than 5 students but can have no students to supervise.
• An admin can handle any number of professors and any number of students, including none.
• A professor/student can be handled by any number of admins, including none.

Associations as Attributes

An association can be shown as an attribute instead of a line.

Association multiplicities and the default value too can be shown as part of the attribute using the following notation. Both are optional.

name: type [multiplicity] = default value

📦 The diagram below depicts a multi-player Square Game being played on a board comprising of 100 squares. Each of the squares may be occupied with any number of pieces, each belonging to a certain player.

A Piece may or may not be on a Square. Note how that association can be replaced by an isOn attribute of the Piece class. The isOn attribute can either be null or hold a reference to a Square object, matching the 0..1 multiplicity of the association it replaces. The default value is null.

The association that a Board has 100 Sqaures can be shown in either of these two ways:

What

Notation:

📦 In the class diagram below, there are two enumerations in use:

Class-Level Members

In UML class diagrams, underlines denote class-level attributes and variables.

📦 In the class below, totalStudents attribute and the getTotalStudents method are class-level.

Association Classes

Association classes are denoted as a connection to an association link using a dashed line as shown below.

📦 In this example Loan is an association class because it stores information about the borrows association between the User and the Book.

Composition

UML uses a solid diamond symbol to denote composition.

Notation:

📦 A Book consists of Chapter objects. When the Book object is destroyed, its Chapter objects are destroyed too.

Aggregation

UML uses a hollow diamond is used to indicate an aggregation.

📦 Example:

Inheritance

You can use a triangle and a solid line (not to be confused with an arrow) to indicate class inheritance.

Notation:

📦 Examples: The Car class inherits from the Vehicle class. The Cat and Dog classes inherit from the Pet class.

Interfaces

An interface is shown similar to a class with an additional keyword << interface >>. When a class implements an interface, it is shown similar to class inheritance except a dashed line is used instead of a solid line.

📦 The AcademicStaff and the AdminStaff classes implement the SalariedStaff interface.

What

We can use italics or {abstract} keyword to denote abstract classes/methods.

Example:

Introduction

A UML sequence diagram captures the interactions between multiple objects for a given scenario.

📦 Some exmaple sequence diagrams:

Basic

Notation:

📦 This sequence diagram shows some interactions between a human user and the Text UI of a CLI Minesweeper game.

The player runs the newgame action on the TextUi object which results in the TextUi showing the minefield to the player. Then, the player runs the clear x y command; in response, the TextUi object shows the updated minefield.

The :TextUi in the above example denotes an unnamed instance of the class TextUi. If there were two instances of TextUi in the diagram, they can be distinguished by naming them e.g. TextUi1:TextUi and TextUi2:TextUi.

Arrows representing method calls should be solid arrows while those representing method returns should be dashed arrows.

Note that unlike in Object Diagrams, the class/object name is not underlined in sequence diagrams.

❌ [Common notation error] Activation bar too long: The activation bar of a method cannot start before the method call arrives and a method cannot remain active after the method had returned.  In the two sequence diagrams below, the one on the left commits this error because the activation bar starts before the method Foo#xyz() is called and remains active after the method returns.

❌ [Common notation error] Broken activation bar: The activation bar should remain unbroken from the point the method is called until the method returns.  In the two sequence diagrams below, the one on the left commits this error because the activation bar for the method Foo#abc() is not contiguous, but appears as two pieces instead.

Object Creation

Notation:

• The arrow that represents the constructor arrives at the side of the box representing the instance.
• The activation bar represents the period the constructor is active.

📦 The Logic object creates a Minefield object.

Object Deletion

UML uses an X at the end of the lifeline of an object to show it's deletion.

Notation:

📦 Note how the diagrams shows the deletion of the Minefield object

Loops

Notation:

📦 The Player calls the mark x,y command or clear x y command repeatedly until the game is won or lost.

Self Invocation

UML can show a method of an object calling another of its own methods.

Notation:

📦 The markCellAt(...) method of a Logic object is calling its own updateState(...) method.

📦 In this variation, the Book#write() method is calling the Chapter#getText() method which in turn does a call back by calling the getAuthor() method of the calling object.

Alternative Paths

UML uses alt frames to indicate alternative paths.

Notation:

📦 Minefield calls the Cell#setMine if the cell is supposed to be a mined cell, and calls the Cell:setMineCount(...) method otherwise.

Optional Paths

UML uses opt frames to indicate optional paths.

Notation:

📦 Logic#markCellAt(...) calls Timer#start() only if it is the first move of the player.

Parallel Paths

UML uses par frames to indicate parallel paths.

Notation:

📦 Logic is calling methods CloudServer#poll() and LocalServer#poll() in parallel.

💡 If you show parallel paths in a sequence diagram, the corresponding Java implementation is likely to be multi-threaded  because a normal Java program cannot do multiple things at the same time.

Reference Frames

UML uses ref frame to allow a segment of the interaction to be omitted and shown as a separate sequence diagram. Reference frames help us to break complicated sequence diagrams into multiple parts or simply to omit details we are not interested in showing.

Notation:

📦 The details of the get minefield appearance interactions have been omitted from the diagram.

Those details are shown in a separate sequence diagram given below.

Minimal Notation

To reduce clutter, activation bars and return arrows may be omitted if they do not result in ambiguities or loss of information. Informal operation descriptions such as those given in the example below can be used, if more precise details are not required for the task at hand.

📦 A minimal sequence diagram

Introduction

An object diagram shows an object structure at a given point of time.

Objects

Notation:

Notes:

• The class name and object name e.g. car1:Car are underlined.
• objectName:ClassName is meant to say 'an instance of ClassName identified as objectName'.
• Unlike classes, there is no compartment for methods.
• Attributes compartment can be omitted if it is not relevant to the task at hand.
• Object name can be omitted too e.g. :Car which is meant to say 'an unnamed instance of a Car object'.

📦 Some example objects:

Object Structures

Notation:

📦 An example object diagram:

Introduction

A UML Activity diagram (AD) can model workflows.

Workflows define the flow or a connected sequence of steps in which a process or a set of tasks is executed. Understanding the workflow of the problem domain is important if the problem that is to be solved is connected to the workflow.

Linear Paths

An activity diagram (AD) consists of a sequence of actions and control flows.

• An action is a single step in an activity. It is shown as a rectangle with rounded edges.
• A control flow shows the flow of control from one action to the next. It is shown by drawing a line with an arrow-head to show the direction of the flow.

Alternate Paths

Branch nodes and merge nodes have the same notation: a diamond shape. They are used to show alternative (not parallel) paths through the AD. Each control flow exiting a branch node has a guard condition which : a boolean condition that should be true for execution to take that path. only one of the alternative paths can be taken at any time.

📦 The activity diagram for the Minesweeper (MS) that shows actions done by the player and the game (MS).

Parallel Paths

Forks and joins have the same notation: a bar. They indicate the start and end of concurrent flows of control. In a set of parallel paths, execution along all parallel paths should be complete before the execution can start on the outgoing control flow of the join.

📦 The following diagram shows an example of their use.

Rakes

The rake notation is used to indicate that a part of the activity is given as a separate diagram.

📦 Here is the AD for a game of ‘Snakes and Ladders’.

The rake symbol (in the Move piece action above) is used to show that the action is described in another subsidiary activity diagram elsewhere. That diagram is given below.

Swimlanes

It is possible to partition an activity diagram to show who is doing which action. Such partitioned activity diagrams are sometime called swimlane diagrams.

📦 A simple example of a swimlane diagram:

Notes

UML notes can augment UML diagrams with additional information. These notes can be shown connected to a particular element in the diagram or can be shown without a connection. The diagram below shows examples of both.

📦 Example:

Constraints

A constraint can be given inside a note, within curly braces. Natural language or a formal notation such as OCL (Object Constraint Language) may be used to specify constraints.

📦 Example:

Object vs Class Diagrams

Compared to the notation for a class diagrams, object diagrams differ in the following ways:

• Instance name may be shown
• There is a : before the class name
• Instance and class names are underlined
• Methods are omitted
• Multiplicities are omitted

Both object diagrams are derived from the same class diagram shown earlier. In other words, each of these object diagrams shows ‘an instance of’ the same class diagram.

Examples: