This document provides an overview of UML (Unified Modeling Language) diagrams for modeling software systems. It discusses the main diagram types including class, object, sequence, state, use case, and activity diagrams. For each diagram type, it explains the key elements such as classes, objects, messages, states, transitions, and how they are used to model different aspects of a system. It uses a TreeMap example to illustrate how UML can represent the key abstractions in code including classes, objects, relationships, lifecycles, and interactions between components. The document concludes that the diagrams presented provide sufficient information for most programming tasks and that additional UML knowledge may not be required for many practitioners.

1. UML for Java
Programmers
Object Mentor, Inc.
Or
How Uncle Bob us e s
UML.
www.objectmentor.com
fitnesse.org
www.xprogramming
www.junit.org
Copyright © 1998-2001 by Object Mentor, Inc
All Rights Reserved

2. The three modes of UML
Conceptual
Tied to human language.
Specification
A description of source code yet to be written.
Implementation
A description of source code that already exists.
2

3. Conceptual
Tied to human language:
Animal
“An Anima l ISA Dog”
Dog
3

4. Hmmm…
4

5. Tied to human language
A n im a l
Lounge
C h a ir
Led
Z e p p lin
5
« S it s I n A »
« D r in k s A »
Dog
« G ro o ve s T o »
M a r tin i
«S m okesA »
C ig a r
{W a yL o u d }

6. Models of the “Real World”
Do not relate to software structure.
Now it’s time for: Uncle Bob’s rant….
Human language is not the best foundation
for software structure.
A Circle ISA Ellipse.
6

7. A Circle ISA Ellipse
User
E llip s e
C ir c le
7

8. Specification and Implementation
Are tied to code.
Follow the same rules.
Differ only in detail.
Sometimes.
8

9. Example:
public class TreeMap {
TreeMapNode topNode = null;
public void add(Comparable key, Object value) {…}
public Object get(Comparable key) {…}
}
class TreeMapNode {
private Comparable itsKey;
private Object itsValue;
private TreeMapNode nodes[] = new TreeMapNode[2];
public TreeMapNode(Comparable key, Object value) {…}
public Object find(Comparable key) {…}
public void add(Comparable key, Object value) {…}
}
9

10. Here’s some UML for that.
2
TreeMap
+ add(key, value)
+ get(key)
topNode
nodes
TreeMapNode
+ add(key, value)
+ find(key)
itsKey
«interface»
Comparable
itsValue
Object
10

11. Classes and Relationships.
Rectangles represent classes, and arrows represent relationships.
2
TreeMap
+ add(key, value)
+ get(key)
topNode
nodes
TreeMapNode
+ add(key, value)
+ find(key)
itsKey
itsValue
11
«interface»
Comparable
Object

12. Associations.
In this diagram all the relationships are associations. Associations are
simple data relationships in which one object holds a reference to, and
invokes methods upon, the other.
2
TreeMap
+ add(key, value)
+ get(key)
topNode
nodes
TreeMapNode
+ add(key, value)
+ find(key)
itsKey
itsValue
12
«interface»
Comparable
Object

13. Relationship Names.
The name on an association maps to the name of the
variable that holds the reference.
public class TreeMap {
TreeMapNode topNode = null;
}
2
TreeMap
+ add(key, value)
+ get(key)
topNode
nodes
TreeMapNode
+ add(key, value)
+ find(key)
itsKey
itsValue
13
«interface»
Comparable
Object

14. Multiplicity.
A number next to an arrowhead typically shows the number of
instances held by the relationship. If that number is greater than
one then some kind of container, like an array, is implied.
class TreeMapNode {
private TreeMapNode nodes[] = new TreeMapNode[2];
}
2
TreeMap
+ add(key, value)
+ get(key)
topNode
nodes
TreeMapNode
+ add(key, value)
+ find(key)
itsKey
itsValue
14
«interface»
Comparable
Object

15. Class Icons.
Class icons can have more than one compartment. The top compartment
always holds the name of the class. The other compartments describe
functions and variables.
2
TreeMap
+ add(key, value)
+ get(key)
topNode
nodes
TreeMapNode
+ add(key, value)
+ find(key)
itsKey
itsValue
15
«interface»
Comparable
Object

16. Interface.
The «interface» notation means that Comparable is an interface.
2
TreeMap
+ add(key, value)
+ get(key)
topNode
nodes
TreeMapNode
+ add(key, value)
+ find(key)
itsKey
itsValue
16
«interface»
Comparable
Object

17. Optional.
Most of the notations shown are optional
Uncle Bob is going to ra nt a ga in…
2
TreeMap
+ add(key, value)
+ get(key)
topNode
nodes
TreeMapNode
+ add(key, value)
+ find(key)
itsKey
itsValue
17
«interface»
Comparable
Object

18. <<Grimace>>.
But Uncle Bob, you didn’t ta lk a bout
Aggre ga tion or Compos ition.
Ra nt….
C ar
E n g in e
18
S te e r in g
W heel

19. Object Diagrams.
:TreeMap
topNode
:TreeMapNode
- itsKey = "Martin"
nodes[LESS]
nodes[GREATER]
:TreeMapNode
:TreeMapNode
- itsKey = "Bob"
- itsKey = "Robin"
nodes[LESS]
nodes[LESS]
:TreeMapNode
:TreeMapNode
:TreeMapNode
:TreeMapNode
- itsKey = "Alan"
19
nodes[GREATER]
- itsKey = "Don"
- itsKey = "Paul"
- itsKey = "Sam"
nodes[GREATER]

20. Freeze Frame.
It shows a set of objects and relationships at a particular moment in the
execution of the system. You can view it as a snapshot of memory.
:TreeMap
topNode
:TreeMapNode
- itsKey = "Martin"
nodes[LESS]
nodes[GREATER]
:TreeMapNode
:TreeMapNode
- itsKey = "Bob"
- itsKey = "Robin"
nodes[LESS]
nodes[LESS]
:TreeMapNode
:TreeMapNode
:TreeMapNode
:TreeMapNode
- itsKey = "Alan"
20
nodes[GREATER]
- itsKey = "Don"
- itsKey = "Paul"
- itsKey = "Sam"
nodes[GREATER]

21. Object Names are Underlined.
the rectangle icons represent objects. You can tell that they are
objects because their names are underlined.
:TreeMap
topNode
:TreeMapNode
- itsKey = "Martin"
nodes[LESS]
nodes[GREATER]
:TreeMapNode
:TreeMapNode
- itsKey = "Bob"
- itsKey = "Robin"
nodes[LESS]
nodes[LESS]
:TreeMapNode
:TreeMapNode
:TreeMapNode
:TreeMapNode
- itsKey = "Alan"
21
nodes[GREATER]
- itsKey = "Don"
- itsKey = "Paul"
- itsKey = "Sam"
nodes[GREATER]

22. Object : Class
The name after the colon is the name of the
class that the object belongs to.
:TreeMap
topNode
:TreeMapNode
- itsKey = "Martin"
nodes[LESS]
nodes[GREATER]
:TreeMapNode
:TreeMapNode
- itsKey = "Bob"
- itsKey = "Robin"
nodes[LESS]
nodes[LESS]
:TreeMapNode
:TreeMapNode
:TreeMapNode
:TreeMapNode
- itsKey = "Alan"
22
nodes[GREATER]
- itsKey = "Don"
- itsKey = "Paul"
- itsKey = "Sam"
nodes[GREATER]

23. Values.
Note that the lower compartment of each object
shows the value of that object’s itsKey variable.
:TreeMap
topNode
:TreeMapNode
- itsKey = "Martin"
nodes[LESS]
nodes[GREATER]
:TreeMapNode
:TreeMapNode
- itsKey = "Bob"
- itsKey = "Robin"
nodes[LESS]
nodes[LESS]
:TreeMapNode
:TreeMapNode
:TreeMapNode
:TreeMapNode
- itsKey = "Alan"
23
nodes[GREATER]
- itsKey = "Don"
- itsKey = "Paul"
- itsKey = "Sam"
nodes[GREATER]

24. Links.
The relationships between the objects are called
links, and are derived from the associations.
:TreeMap
2
TreeMap
+ add(key, value)
+ get(key)
topNode
topNode
nodes
TreeMapNode
:TreeMapNode
+ add(key, value)
+ find(key)
- itsKey = "Martin"
itsKey
«interface»
Comparable
nodes[LESS]
itsValue
Object
nodes[GREATER]
:TreeMapNode
:TreeMapNode
- itsKey = "Bob"
- itsKey = "Robin"
nodes[LESS]
nodes[LESS]
:TreeMapNode
24
nodes[GREATER]
:TreeMapNode
:TreeMapNode
:TreeMapNode
- itsKey = "Alan"
- itsKey = "Don"
- itsKey = "Paul"
- itsKey = "Sam"
nodes[GREATER]

25. Sequence Diagrams.
public void add(Comparable key,Object value){
if (topNode == null)
topNode = new TreeMapNode(key, value);
else
topNode.add(key, value);
}
:TreeMap
add(key, value)
value
key
[topNode == null]
topNode:
TreeMapNode
add(key, value)
25
[topNode != null]

26. Actor.
The stick figure (actor) represents an
unknown caller.
:TreeMap
add(key, value)
value
key
[topNode == null]
topNode:
TreeMapNode
add(key, value)
26
[topNode != null]

27. Lifelines.
The dashed lines are lifelines, they
show the lifetime of the objects they
descend from.
:TreeMap
add(key, value)
value
key
[topNode == null]
topNode:
TreeMapNode
add(key, value)
27
[topNode != null]

28. Messages.
The long arrows are messages sent
between the objects.
:TreeMap
add(key, value)
value
key
[topNode == null]
topNode:
TreeMapNode
add(key, value)
28
[topNode != null]

29. Guards.
The boolean expressions inside square brackets are
called guards. They show which path is taken.
:TreeMap
add(key, value)
value
key
[topNode == null]
topNode:
TreeMapNode
add(key, value)
29
[topNode != null]

30. Construction.
The message arrow that terminates on the
TreeMapNode icon represents construction.
:TreeMap
add(key, value)
value
key
[topNode == null]
topNode:
TreeMapNode
add(key, value)
30
[topNode != null]

31. Data Tokens
The little arrows with circles are called data tokens.
They show any arguments or return values.
:TreeMap
add(key, value)
value
key
[topNode == null]
topNode:
TreeMapNode
add(key, value)
31
[topNode != null]

32. Activations.
The skinny rectangle below TreeMap is called
an activation. It depicts how much time the add
method executes.
:TreeMap
add(key, value)
value
key
[topNode == null]
topNode:
TreeMapNode
add(key, value)
32
[topNode != null]

33. Collaboration Diagrams.
1: add(key, value)
:TreeMap
[topNode != null]
1.1:add(key, value)
topNode
:TreeMapNode
33

34. Same data as Sequence Diagrams.
Collaboration diagrams make the
relationships between the objects clear.
1: add(key, value)
:TreeMap
[topNode != null]
1.1:add(key, value)
topNode
:TreeMapNode
34

35. Links (again).
The objects are connected by relationships called
links. A link exists wherever one object can send a
message to another.
1: add(key, value)
:TreeMap
[topNode != null]
1.1:add(key, value)
topNode
:TreeMapNode
35

36. Messages.
Traveling over those links are the messages
themselves. They are depicted as the smaller arrows.
1: add(key, value)
:TreeMap
[topNode != null]
1.1:add(key, value)
topNode
:TreeMapNode
36

37. Message Labels.
The messages are labeled with the name of
the message, its sequence number, and any
guards that apply.
1: add(key, value)
:TreeMap
[topNode != null]
1.1:add(key, value)
topNode
:TreeMapNode
37

38. Sequence Numbers.
The dot structure of the sequence number
shows the calling hierarchy.
1: add(key, value)
:TreeMap
[topNode != null]
1.1:add(key, value)
topNode
:TreeMapNode
38

39. State Diagrams.
A Subway Turnstile.
coin / Unlock
pass / Alarm
Locked
pass / Lock
39
Unlocked
coin / Thankyou

40. States.
There are two states named
Locked and Unlocked.
coin / Unlock
pass / Alarm
Locked
pass / Lock
40
Unlocked
coin / Thankyou

41. Events.
Two events may be sent to the machine.
The coin event means that the user has dropped a
coin into the turnstile.
The pass event means that the user has passed
through the turnstile.
coin / Unlock
pass / Alarm
Locked
pass / Lock
41
Unlocked
coin / Thankyou

42. Transitions.
The arrows are called transitions. They are labeled with
the event that triggers the transition and the action that
the transition performs.
coin / Unlock
pass / Alarm
Locked
pass / Lock
42
Unlocked
coin / Thankyou

43. Interpretation.
If we are in the Locked state and we get a coin event, then we transition to
the Unlocked state and we invoke the Unlock function.
If we are in the Unlocked state and we get a pass event, then we transition
to the Locked state and we invoke the Lock function.
If we are in the Unlocked state and we get a coin event, then we stay in the
Unlocked state and we call the Thankyou function.
If we are in the Locked state and we get a pass event, then we stay in the
Locked state and we call the Alarm function.
pass / Alarm
Locked
coin / Unlock
pass / Lock
43
Unlocked
coin / Thankyou

44. Sufficiency.
The diagrams shown in this chapter are enough
for most purposes.
Most programmers could live without any more
knowledge of UML that what is shown here.
44

45. Tools.
Now ask me what I think about tools…..
45

46. Documentation.
46

47. Where to get this presentation.
47