UML ile nesne yönelimli tasarım

UML (Unified Modeling Language), yazılımı kod yazmadan önce çizmenin standart dilidir. Bu derste UML’in en çok kullanılan parçası olan sınıf diyagramını (class diagram) öğreniyorsun. Sınavda iki yönde gelir: “bu diyagramı Java’ya çevir” ve “bu gereksinimden sınıf diyagramı çıkar”. Okları ve işaretleri karıştırmazsan kolay puandır.

Altın kurallar:

1. Görünürlük işaretleri: + public, - private, # protected, ~ package.
2. UML’de tip sonda yazılır: - name : String → private String name;.
3. Boş üçgen “is-a”: düz çizgi extends, kesikli çizgi implements.
4. Elmas “has-a”: boş elmas aggregation, dolu elmas composition. Elmas bütün tarafında.
5. Çokluğun “çok” tarafı koleksiyon alanı olur.

Sınıf kutusu

Bir sınıf üç bölmeli bir dikdörtgendir: en üstte ad, ortada alanlar (attributes), altta işlemler (operations).

+----------------------------------------------+
|                   Account                    |   ad (abstract ise italik)
+----------------------------------------------+
| - owner : String                             |   alanlar
| - balance : double = 0.0                     |
| - count : int                  (altı çizili) |   static
+----------------------------------------------+
| + Account(owner : String)                    |   constructor
| + deposit(amount : double) : void            |   işlemler
| + getBalance() : double                      |
| + getCount() : int             (altı çizili) |   static
| # audit() : boolean                          |   protected
+----------------------------------------------+

TUZAK · tipin yeri. UML’de getBalance() : double, Java’da double getBalance(). Çeviri sorusunda tipleri yer değiştirmeyi unutan, imzayı bozuk yazar.

İlişkiler

Sınıflar arasındaki çizgiler ve uçlarındaki şekiller ilişkinin türünü söyler.

         Person (italik: abstract)            <<interface>>
            ^                                    Payable
            |  düz çizgi + boş üçgen               ^
            |                                      :  kesikli + boş üçgen
          Staff ...................................:

   Library ◆---------- 0..*  Loan          (composition)
   Team    ◇---------- 0..*  Player        (aggregation)
   Member  1 ---------- 0..3 Loan          (association + çokluk)
   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 ve composition

İkisi de “parça-bütün” (has-a) ilişkisidir. Fark parçanın ömrü:

• Composition (dolu elmas): parça bütünle birlikte doğar ve ölür, başka bütünle paylaşılmaz. Ev ve odaları, araba ve motoru. Kodda genelde bütün, parçayı kendi constructor’ında new ile yaratır ve dışarı vermez.
• Aggregation (boş elmas): parça bağımsız yaşar, birden fazla bütüne ait olabilir. Takım ve oyuncular, ders ve öğrenciler. Kodda parça dışarıdan gelir (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);         // aynı oyuncu iki takımda
t1 = null;                    // takım gitti, oyuncu duruyor
System.out.println(t2.size() + " " + p.name);

120
1 Arda

İPUCU · emin değilsen association. Hocalar aggregation ile düz association arasındaki farkı çoğu zaman kesin sormaz. Composition’ı ise ister: “parça bütünsüz var olabilir mi?” sorusuna “hayır” diyorsan dolu elmas.

Çokluk (multiplicity)

Çizginin uçlarına yazılan sayılar, karşı taraftaki bir nesnenin bu taraftan kaç nesneyle ilişkili olduğunu söyler.

Member 1 ---- 0..3 Loan şöyle okunur: bir Member’ın 0 ile 3 arası Loan’ı var; her Loan’ın tam 1 Member’ı var.

Gereksinimden sınıflara: bir kütüphane örneği

Gereksinim metni (requirements document):

Kampüs kütüphanesinde kitaplar ve üyeler vardır. Her kitabın ISBN’i ve adı bulunur. Bir üye aynı anda en fazla üç kitap ödünç alabilir. Ödünç verilen kitap iade edilene kadar başkasına verilemez. Kütüphane, her ödünç işleminin hangi üyeye, hangi kitap için, kaç günlüğüne yapıldığını kaydeder.

Adım 1: isimleri ayıkla (noun extraction). kütüphane, kitap, üye, ISBN, ad, ödünç işlemi, gün. Kendi verisi ve davranışı olanlar sınıf: Library, Book, Member, Loan. Bir şeyin özelliği olanlar alan: isbn, title, days.

Adım 2: fiilleri ayıkla. ödünç almak, iade etmek, kaydetmek → lend, giveBack. “ödünç verilemez” ve “en fazla üç” kuralları bu metotların içindeki kontroller olur.

Adım 3: ilişkileri ve çokluğu çiz.

 Library ◇------------ 0..*  Book
 Library ◆------------ 0..*  Loan
 Member  1 ----------- 0..3  Loan
 Loan    0..1 -------- 1     Book     (bir kitabın aynı anda en fazla 1 aktif ödüncü)

Adım 4: koda çevir.

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);          // Loan'ı Library yaratır: 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 içinde List<Loan> loans ve canBorrow() → loans.size() < 3 var. Senaryo:

Loan l1 = lib.lend(b1, ece, 14);
System.out.println(l1);
lib.lend(b1, mert, 7);      // b1 ödünçte
lib.lend(b2, ece, 7);
lib.lend(b3, ece, 7);
lib.lend(b4, ece, 7);       // Ece'nin 3 ödüncü var
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

Tasarım kararlarına dikkat: “kitap ödünçte mi” bilgisini Book tutuyor (available), “kaç kitabı var” bilgisini Member tutuyor, kuralları birleştiren Library. Her sınıf kendi verisinden sorumlu; bu, kapsüllemenin tasarım düzeyindeki karşılığı.

Sık yapılan hatalar

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