UML

An example class diagram:

A Table class shown in UML notation:

class Table{

    Integer number;
    Chair[] chairs = null;
    
    Integer getNumber(){
        //...
    }

    void setNumber(Integer n){
        //...
    }
}

class Table:

  def __init__(self):
    self.number = 0
    self.chairs = []

  def get_number(self):
    # ...

  def set_number(self, n):
    # ...

Table class with visibilities shown:

This example shows an association between the Admin class and the Student class:

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

class Logic{
    Minefield minefield;
}

class Minefield{
    ...
}

class Logic:
  
  def __init__(self, minefield):
    self.minefield = minefield
    
  # ...


class Minefield:
  # ...

Here is an example of a bidirectional navigability; each class is aware of the other.

According to this object diagram the given Logic object is associated with and aware of two MineField objects.

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;
}

class Man:
  def __init__(self):
    self.wife = None # a Woman object

class Woman:
   def __init__(self):
     self.husband = None # a Man object

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

class Admin{
    List<Student> charges;
}

class Admin:
  def __init__(self):
    self.charges = [] # list of Student objects

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.

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.

Two examples of dependencies:

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 Squares can be shown in either of these two ways:

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

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

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

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

Example:

Aggregation vs Composition

The distinction between composition (◆) and aggregation (◇) is rather blurred. Martin Fowler’s famous book UML Distilled advocates omitting the aggregation symbol altogether because using it adds more confusion than clarity.

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

The AcademicStaff and the AdminStaff classes implement the SalariedStaff interface.

Example: