Object-oriented design with UML

UML (Unified Modeling Language) is the standard language for drawing software before writing code. In this course you learn the most used part of UML, the class diagram. In the exam it comes in two directions: “translate this diagram into Java” and “derive a class diagram from this requirement”. If you do not mix up the arrows and the markers, it is easy points.

Golden rules:

1. Visibility markers: + public, - private, # protected, ~ package.
2. In UML the type is written at the end: - name : String → private String name;.
3. A hollow triangle is “is-a”: a solid line is extends, a dashed line is implements.
4. A diamond is “has-a”: a hollow diamond is aggregation, a filled diamond is composition. The diamond is on the whole side.
5. The “many” side of a multiplicity becomes a collection field.

The class box

A class is a rectangle with three compartments: the name at the top, the fields (attributes) in the middle, the operations at the bottom.

+----------------------------------------------+
|                   Account                    |   name (italic if abstract)
+----------------------------------------------+
| - owner : String                             |   fields
| - balance : double = 0.0                     |
| - count : int                  (underlined)  |   static
+----------------------------------------------+
| + Account(owner : String)                    |   constructor
| + deposit(amount : double) : void            |   operations
| + getBalance() : double                      |
| + getCount() : int             (underlined)  |   static
| # audit() : boolean                          |   protected
+----------------------------------------------+

PITFALL · where the type goes. In UML it is getBalance() : double, in Java it is double getBalance(). In a translation question, whoever forgets to swap the types writes a broken signature.

Relationships

The lines between classes and the shapes at their ends tell the type of the relationship.

         Person (italic: abstract)            <<interface>>
            ^                                    Payable
            |  solid line + hollow triangle         ^
            |                                      :  dashed + hollow triangle
          Staff ...................................:

   Library ◆---------- 0..*  Loan          (composition)
   Team    ◇---------- 0..*  Player        (aggregation)
   Member  1 ---------- 0..3 Loan          (association + multiplicity)
   Order - - - - - - - -> Printer          (dependency)

interface Payable { double amount(); }

abstract class Person {
    protected String name;
    Person(String n) { name = n; }
    abstract String role();
}
class Staff extends Person implements Payable {
    private final double salary;
    Staff(String n, double s) { super(n); salary = s; }
    String role() { return "staff"; }
    public double amount() { return salary; }
}

Person s = new Staff("Ayse", 4200);
System.out.println(s.role() + " " + ((Payable) s).amount() + " " + (s instanceof Payable));

staff 4200.0 true

Aggregation and composition

Both are “part-whole” (has-a) relationships. The difference is the life of the part:

• Composition (filled diamond): the part is born and dies together with the whole, and is not shared with another whole. A house and its rooms, a car and its engine. In code, the whole usually creates the part with new in its own constructor and does not hand it out.
• Aggregation (hollow diamond): the part lives independently and can belong to more than one whole. A team and its players, a course and its students. In code the part comes from outside (add(Player p)).

class Engine { final int hp; Engine(int hp) { this.hp = hp; } }
class Car {
    private final Engine engine;                 // composition
    Car(int hp) { engine = new Engine(hp); }
    int power() { return engine.hp; }
}

class Player { final String name; Player(String n) { name = n; } }
class Team {
    private final List<Player> players = new ArrayList<>();   // aggregation
    void add(Player p) { players.add(p); }
    int size() { return players.size(); }
}

Car car = new Car(120);
System.out.println(car.power());
Player p = new Player("Arda");
Team t1 = new Team(), t2 = new Team();
t1.add(p); t2.add(p);         // the same player on two teams
t1 = null;                    // the team is gone, the player remains
System.out.println(t2.size() + " " + p.name);

120
1 Arda

TIP · if you are not sure, association. Instructors often do not ask for the exact difference between aggregation and a plain association. They do want composition, though: if you answer “no” to the question “can the part exist without the whole?”, use the filled diamond.

Multiplicity

The numbers written at the ends of the line say how many objects on this side a single object on the opposite side is related to.

Member 1 ---- 0..3 Loan is read like this: a Member has between 0 and 3 Loans; each Loan has exactly 1 Member.

From requirements to classes: a library example

The requirements document:

The campus library has books and members. Each book has an ISBN and a title. A member can borrow at most three books at a time. A book that is on loan cannot be given to anyone else until it is returned. The library records, for each loan, which member it was made to, for which book, and for how many days.

Step 1: extract the nouns (noun extraction). library, book, member, ISBN, title, loan, day. Those that have their own data and behavior are classes: Library, Book, Member, Loan. Those that are a property of something are fields: isbn, title, days.

Step 2: extract the verbs. to borrow, to return, to record → lend, giveBack. The rules “cannot be given” and “at most three” become checks inside these methods.

Step 3: draw the relationships and multiplicity.

 Library ◇------------ 0..*  Book
 Library ◆------------ 0..*  Loan
 Member  1 ----------- 0..3  Loan
 Loan    0..1 -------- 1     Book     (a book has at most 1 active loan at a time)

Step 4: translate to code.

class Loan {
    private final Book book;
    private final Member member;
    private final int days;
    Loan(Book b, Member m, int days) { book = b; member = m; this.days = days; }
    Book getBook() { return book; }
    Member getMember() { return member; }
    public String toString() { return member.getName() + " -> " + book + " for " + days + " days"; }
}

class Library {
    private final List<Book> books = new ArrayList<>();
    private final List<Loan> loans = new ArrayList<>();

    void addBook(Book b) { books.add(b); }

    Loan lend(Book b, Member m, int days) {
        if (!b.isAvailable()) { System.out.println("Not available: " + b); return null; }
        if (!m.canBorrow())   { System.out.println("Limit reached: " + m.getName()); return null; }
        Loan l = new Loan(b, m, days);          // Library creates the Loan: composition
        b.setAvailable(false);
        m.addLoan(l);
        loans.add(l);
        return l;
    }
    void giveBack(Loan l) {
        l.getBook().setAvailable(true);
        l.getMember().removeLoan(l);
        loans.remove(l);
    }
    int activeLoans() { return loans.size(); }
}

Member has List<Loan> loans and canBorrow() → loans.size() < 3. The scenario:

Loan l1 = lib.lend(b1, ece, 14);
System.out.println(l1);
lib.lend(b1, mert, 7);      // b1 is on loan
lib.lend(b2, ece, 7);
lib.lend(b3, ece, 7);
lib.lend(b4, ece, 7);       // Ece has 3 loans
System.out.println(ece.loanCount() + " " + lib.activeLoans());
lib.giveBack(l1);
System.out.println(b1 + " | " + ece.loanCount() + " " + lib.activeLoans());
System.out.println(Book.getCreated());

Ece -> Clean Code (on loan) for 14 days
Not available: Clean Code (on loan)
Limit reached: Ece
3 3
Clean Code | 2 2
4

Note the design decisions: the information “is the book on loan” is kept by Book (available), the information “how many books does the member have” is kept by Member, and Library combines the rules. Each class is responsible for its own data; this is the design-level counterpart of encapsulation.

Common mistakes

class Car {
    private final Engine engine;
    Car(int hp) { engine = new Engine(hp); }
}
class Team {
    private final List<Player> players = new ArrayList<>();
    void add(Player p) { players.add(p); }
}

// Library.lend(b, m, days): prints "Not available: <book>" if the book is on loan,
// "Limit reached: <name>" if the member already has 3 loans, otherwise creates a Loan.
// Book.toString(): title + (available ? "" : " (on loan)")
Loan l1 = lib.lend(b1, ece, 14);
System.out.println(l1);
lib.lend(b1, mert, 7);
lib.lend(b2, ece, 7);
lib.lend(b3, ece, 7);
lib.lend(b4, ece, 7);
System.out.println(ece.loanCount() + " " + lib.activeLoans());
lib.giveBack(l1);
System.out.println(b1 + " | " + ece.loanCount() + " " + lib.activeLoans());

+-------------------------------------------+
|                  Book                     |
+-------------------------------------------+
| - isbn : String  {readOnly}               |
| - title : String                          |
| - available : boolean = true              |
| - created : int          (underlined)     |
+-------------------------------------------+
| + Book(isbn : String, title : String)     |
| + getIsbn() : String                      |
| + isAvailable() : boolean                 |
| ~ setAvailable(a : boolean) : void        |
| + getCreated() : int     (underlined)     |
+-------------------------------------------+

public class Book {
    private final String isbn;
    private String title;
    private boolean available = true;
    private static int created = 0;

    public Book(String isbn, String title) {
        this.isbn = isbn;
        this.title = title;
        created++;
    }
    public String getIsbn() { return isbn; }
    public boolean isAvailable() { return available; }
    void setAvailable(boolean a) { available = a; }
    public static int getCreated() { return created; }
}

import java.util.ArrayList;
import java.util.List;

public class Course {
    private final String code;
    private final int capacity;
    private final List<Student> students = new ArrayList<>();

    public Course(String code, int capacity) {
        this.code = code;
        this.capacity = capacity;
    }
    public boolean enroll(Student s) {
        if (students.size() >= capacity || students.contains(s)) return false;
        students.add(s);
        return true;
    }
    public int getEnrolledCount() { return students.size(); }
    public String getCode() { return code; }
}