UML and Patterns

1

• Chapter 12
• UML and Patterns

2
Introduction to UML and Patterns

• UML and patterns are two software design tools
  that can be used within the context of any OOP
  (Object-Oriented programming) language.
• UML (Unified Modeling Language) is a graphical
  language used for designing and documenting OOP
  software.
• A pattern in programming is a kind of template or
  outline of a software task.
• A pattern can be realized as different code in
  different, but similar, applications.

3
UML

• Pseudocode is a way of representing a program in
  a linear and algebraic manner.
• It simplifies design by eliminating the details
  of programming language syntax.
• Graphical representation systems for program
  design have also been used
• Flowcharts and structure diagrams for example.
• Unified Modeling Language (UML) is yet another
  graphical representation formalism.
• UML is designed to reflect and be used with the
  OOP philosophy.

4
UML Class Diagram

• Classes are central to OOP, and the class diagram
  is the easiest of the UML graphical
  representations to understand and use.
• A class diagram is divided up into three
  sections
• The top section contains the class name.
• The middle section contains the data
  specification for the class.
• The bottom section contains the actions or
  methods of the class.

5
UML Class Diagram

• The data specification for each piece of data in
  a UML diagram consists of its name, followed by
  a colon, followed by its type.
• Each name is preceded by a character that
  specifies its access type
• A minus sign (-) indicates private access
• A plus sign () indicates public access
• A sharp () indicates protected access
• A tilde () indicates package access

6
UML Class Diagram

• Each method in a UML diagram is indicated by the
  name of the method, followed by its parameter
  list, a colon (), and its returned type.
• The access type of each method is indicated in
  the same way as for data.
• A class diagram need not give a complete
  description of the class.
• If a given analysis does not require that all the
  class members be represented, then those members
  are not listed in the class diagram.
• Missing members are indicated with an ellipsis
  (three dots).

7
Example (UML Class Diagram)
Square
- Side double - xCoordinate double - yCoordinate double
resize (double newSide) void move (double newx , double newy ) void erase ( ) void
8
Class Interactions

• Rather than show just the interface of a class,
  class diagrams are primarily designed to show the
  interactions among classes.
• UML has various ways to indicate the information
  flow from one class object to another using
  different sorts of annotated arrows.
• UML has annotations for class groupings into
  packages, for inheritance, and for other
  interactions.
• In addition to these established annotations, UML
  is extensible.

9
Inheritance Diagrams

• An inheritance diagram shows the relationship
  between a base class and its derived class(es).
• Normally, only as much of the class diagram is
  shown as is needed.
• Note that each derived class may serve as the
  base class of its derived class(es).
• Each base class is drawn above its derived
  class(es)
• An upward pointing arrow is drawn between them to
  indicate the inheritance relationship.

10
A Class Hierarchy in UML Notation
Arrows go from a derived class to its base class.
11
Inheritance Diagrams

• The arrows also help in locating method
  definitions.
• To look for a method definition for a class
• Examine the class definition first.
• If the method is not found, the path of
  connecting arrows will show the order and
  direction in which to search.
• Examine the parent class indicated by the
  connecting arrow.
• If the method is still not found, then examine
  this parent's parent class indicated by the
  connecting arrow.
• Continue until the method is found, or until the
  top base class is reached.

12
Some Details of a Class Hierarchy
13
Patterns

• Patterns are design outlines that apply across a
  variety of software applications.
• To be useful, a pattern must apply across a
  variety of situations.
• To be substantive, a pattern must make some
  hypotheses about the domain of applications to
  which it applies.
• One well-known pattern is the Container-Iterator
  pattern.

14
Container-Iterator Pattern

• A container is a class or other construct whose
  objects hold multiple pieces of data.
• An array is a container.
• Vectors and linked lists are containers.
• A String value can be viewed as a container that
  contains the characters in the string.
• Any construct that can be used to cycle through
  all the items in a container is an iterator.
• An array index is an iterator for an array
• The Container-Iterator pattern describes how an
  iterator is used on a container.

15
Adaptor Pattern

• The Adaptor pattern transforms one class into a
  different class without changing the underlying
  class, but by simply adding a new interface.
• For example, one way to create a stack data
  structure is to start with an array, then add the
  stack interface.
• The adopter pattern says start with a container,
  like an array, and add an interface, like the
  stack interface.

16
The Model-View-Controller Pattern

• The Model-View-Controller pattern is a way of
  separating the I/O task of an application from
  the rest of the application.
• The Model part of the pattern performs the heart
  of the application.
• The View part is the output part it displays a
  picture of the Model's state.
• The Controller is the input part it relays
  commands from the user to the Model.
• Each of the three interacting parts is normally
  realized as an object with responsibilities for
  its own tasks.
• The Model-View-Controller pattern is an example
  of a divide-and-conquer strategy.
• One big task is divided into three smaller tasks
  with well-defined responsibilities.

17
Example (The Model-View-Controller Pattern)

• The Model might be a container class, such as an
  array.
• The View might display one element of the array.
• The Controller would give commands to display the
  element at a specified index.
• The Model would notify the View to display a new
  element whenever the array contents changed or a
  different index location was given.

18
The Model-View-Controller Pattern
19
A Sorting Pattern

• The most efficient sorting algorithms all seem to
  follow a divide-and-conquer strategy.
• Given an array a, and using the lt operator, these
  sorting algorithms
• Divide the list of elements to be sorted into two
  smaller lists (split).
• Recursively sort the two smaller lists (sort).
• Then recombine the two sorted lists (join) to
  obtain the final sorted list.

20
A Sorting Pattern

• The method split rearranges the elements in the
  interval abegin through aend and divides the
  rearranged interval at splitPoint.
• The two smaller intervals are then sorted by a
  recursive call to the method sort.
• After the two smaller intervals are sorted, the
  method join combines them to obtain the final
  sorted version of the entire larger interval.
• Note that the pattern does not say exactly how
  the methods split and join are defined.
• Different definitions of split and join will
  yield different sorting algorithms.

21
Divide-and-Conquer Sorting Pattern
22
Merge Sort

• The simplest realization of this sorting pattern
  is the merge sort.
• The definition of split is very simple it
  divides the array into two intervals without
  rearranging the elements.
• The merging starts by comparing the smallest
  elements in each smaller sorted interval.
• The smaller of these two elements is the smallest
  of all the elements in either subinterval.
• The method join makes use of a temporary array,
  and it is to this array that the smaller element
  is moved.
• The process is repeated with the remaining
  elements in the two smaller sorted intervals to
  find the next smallest element, and so forth.

23
Quick Sort

• In the quick sort realization of the sorting
  pattern, the definition of split is quite
  sophisticated, while join is utterly simple
• An arbitrary value called the splitting value is
  chosen.
• The elements in the array are rearranged
• All elements less than or equal to the splitting
  value are placed at the front of the array.
• All elements greater than the splitting value are
  placed at the back of the array.
• The splitting value is placed in between the two.
• The smaller elements are then sorted by a
  recursive call, as are the larger elements.
• These two sorted segments are combined.
• The join method actually does nothing.

24
Restrictions on the Sorting Pattern

• Like all patterns, the sorting pattern has some
  restrictions on where it applies
• It applies only to types for which the lt operator
  is defined.
• It applies only to sorting into increasing order.
• The pattern can be made more general, however
• The lt operator can be replaced with a boolean
  valued method called compare.
• The compare method would take two arguments of
  the base type of the array, and return true or
  false based on the comparison criteria.

25
Efficiency of the Sorting Pattern

• The most efficient implementations of the sorting
  pattern are those for which the split method
  divides the array into two large parts.
• The merge sort split divides the array into two
  roughly equal parts, and is very efficient.
• The quick sort split may or may not divide the
  array into two roughly equal parts.

26
Pragmatics and Patterns

• Patterns are guides, not requirements.
• It is not necessary to follow all the fine
  details.
• For example, quick sort was described by
  following the sorting pattern exactly.
• Notice that, despite the fact that method calls
  incur overhead, the quick sort join method does
  nothing.
• In practice we would simply eliminate the calls
  to join.
• Other optimizations can also be done once the
  general pattern of an algorithm is clear.