Đến nội dung chính
notes.vinhnq.com

Tìm kiếm

OOP & Thiết kếMid17 phút đọc

Lập trình hướng đối tượng: UML class diagram và 6 quan hệ giữa các class

Ôn 13 thẻ
Trong bài này

Cụm bài Lập trình hướng đối tượng: 1. Class, object, access modifier · 2. Bất biến, equals/hashCode, final · 3. Kế thừa, đóng gói, đa hình · 4. Abstract class, interface · 5. UML, quan hệ giữa class · 6. Wrapper, BigDecimal, String

Biết cú pháp class và object, bất biến và equals/hashCode, kế thừa hay interface chưa đủ: khi có vài chục class, câu hỏi khó là các class quan hệ với nhau thế nào (ai giữ ai, ai tạo ai, xoá cái này cái kia có mất theo không). Bài này giúp bạn đọc và vẽ UML class diagram, nhận ra 6 quan hệ giữa class và viết chúng bằng code. Các class “nền” (wrapper, BigInteger/BigDecimal, String, StringBuilder) nằm ở phần 6.

1. UML class diagram

Ý chính: UML class diagram vẽ mỗi class thành một hộp 3 ngăn (tên, thuộc tính, method) cùng ký hiệu phạm vi truy cập. Nó dùng để giao tiếp thiết kế, không phải để sinh code.

UML (Unified Modeling Language) là ngôn ngữ mô hình hoá chuẩn để cả team nhìn chung một bản thiết kế trước khi code. Class diagram là loại sơ đồ UML dân backend dùng nhiều nhất: trong design doc và trong vòng phỏng vấn thiết kế hướng đối tượng (low-level design).

classDiagram
  class BankAccount {
    -String number
    -BigDecimal balance
    #String ownerName
    ~int branchCode
    +int MAX_DAILY_WITHDRAWALS$
    /BigDecimal availableBalance
    +BankAccount(String number, String ownerName)
    +deposit(BigDecimal amount) void
    +withdraw(BigDecimal amount) void
    +balance() BigDecimal
    +generateNumber()$ String
  }
Ký hiệu Ý nghĩa
+ public
- private
# protected
~ default (package-private)
gạch chân (Mermaid dùng $) thành viên static
in nghiêng (Mermaid dùng *) method abstract
/ thuộc tính dẫn xuất: tính từ giá trị khác, không lưu (ví dụ availableBalance = balance − số tiền đang bị giữ)
«interface», «abstract», «enum» stereotype (nhãn loại), ghi trên tên
  • Cú pháp: visibility name : Type cho thuộc tính, visibility name(param : Type) : ReturnType cho method. Mermaid viết kiểu trước tên (giống Java); cả hai cách đều được hiểu.
  • Chỉ vẽ class và quan hệ quan trọng cho điều đang muốn nói. Sơ đồ 60 class không ai đọc nổi.

2. Sáu quan hệ giữa các class

Ý chính: có 6 quan hệ, xếp từ gắn chặt tới lỏng: kế thừa ≈ triển khai > composition > aggregation > association > dependency. Mỗi quan hệ nhận ra bằng một câu hỏi và có một dạng code riêng.

classDiagram
  direction LR
  Animal <|-- Dog : kế thừa
  Comparable <|.. Money : triển khai
  Order *-- OrderLine : thành phần
  Team o-- Player : tập hợp
  Driver --> Car : liên kết
  ReportService ..> PdfRenderer : phụ thuộc
Quan hệ Ký hiệu UML Câu hỏi để nhận ra Trong code
Kế thừa (generalization) nét liền, tam giác rỗng chỉ vào lớp cha “A là một B?” class A extends B
Triển khai (realization) nét đứt, tam giác rỗng chỉ vào interface “A cam kết làm được những gì B mô tả?” class A implements B
Thành phần (composition) thoi đặc ở phía tổng thể “Phần không thể sống khi tổng thể mất?” Tổng thể tự tạo và sở hữu phần
Tập hợp (aggregation) thoi rỗng ở phía tổng thể “Có chứa nhưng phần sống độc lập?” Phần tạo ở ngoài rồi truyền vào
Liên kết (association) nét liền (có thể có mũi tên chỉ chiều) “A biết tới B lâu dài, chưa rõ sở hữu?” Field tham chiếu
Phụ thuộc (dependency) mũi tên nét đứt “A chỉ dùng tạm B?” Tham số, biến cục bộ, gọi static

2.1. Kế thừa

Dog là một Animal, SavingsAccount là một BankAccount: lớp con nhận thuộc tính và method của lớp cha (xem phần 3).

abstract class BankAccount {
    protected BigDecimal balance = BigDecimal.ZERO;
    abstract BigDecimal monthlyFee();
}

class SavingsAccount extends BankAccount {
    @Override BigDecimal monthlyFee() { return BigDecimal.ZERO; }
}
Vẽ nhiều lớp con: separate target và shared target

Khi nhiều lớp con cùng kế thừa một lớp cha (ví dụ Shape có Polygon, Ellipse, Spline), UML cho hai cách vẽ:

  • Separate target: mỗi lớp con một mũi tên, mỗi mũi tên có tam giác riêng chạm vào lớp cha.
  • Shared target: gộp các đường thành một cây, chỉ dùng một tam giác chung ở lớp cha.

Hai cách cùng ý nghĩa; cách gộp gọn hơn khi có nhiều lớp con.

2.2. Triển khai (realization)

Quan hệ giữa interface và class cài đặt nó.

interface Notifier { void send(String to, String message); }

class EmailNotifier implements Notifier {
    @Override public void send(String to, String message) { /* gọi SMTP */ }
}

Slide (ví dụ Vehicle có Car, Ship cài đặt) ghi thuộc tính là + $name, kiểu viết biến của PHP. UML cho Java viết +name: String.

2.3. Thành phần (composition): “sống cùng, chết cùng”

Tổng thể sở hữu phần: phần được tạo bên trong tổng thể, không chia sẻ cho object khác, và vô nghĩa khi tổng thể mất. Ví dụ Order và OrderLine: xoá đơn thì các dòng mất theo, một dòng không thể nằm ở hai đơn.

public class Order {
    private final List<OrderLine> lines = new ArrayList<>();   // do Order tự tạo và quản lý

    public void addItem(String sku, int qty, BigDecimal unitPrice) {
        lines.add(new OrderLine(sku, qty, unitPrice));          // phần được tạo BÊN TRONG tổng thể
    }

    public List<OrderLine> lines() { return List.copyOf(lines); }   // không lộ list gốc ra ngoài

    public BigDecimal total() {
        return lines.stream().map(OrderLine::subtotal).reduce(BigDecimal.ZERO, BigDecimal::add);
    }
}

record OrderLine(String sku, int qty, BigDecimal unitPrice) {
    BigDecimal subtotal() { return unitPrice.multiply(BigDecimal.valueOf(qty)); }
}

Trong JPA, composition tương ứng @OneToMany(cascade = ALL, orphanRemoval = true) hoặc @Embedded. Trong Domain-Driven Design (DDD), đây là aggregate: Order là aggregate root (cửa duy nhất để sửa), mọi thay đổi OrderLine phải đi qua Order để giữ invariant (quy tắc luôn đúng, ví dụ tổng tiền không vượt hạn mức).

Ví dụ Human/Head/Body của slide: có setter là aggregation

2.4. Tập hợp (aggregation): “có nhau nhưng không phụ thuộc”

Tổng thể chứa phần nhưng không sở hữu vòng đời của nó: phần được tạo ở ngoài, truyền vào, và có thể thuộc nhiều tổng thể. Ví dụ Team và Player: đội giải thể thì cầu thủ vẫn còn và chuyển được sang đội khác.

public class Team {
    private final String name;
    private final List<Player> players = new ArrayList<>();

    public Team(String name) { this.name = name; }

    public void add(Player player) {                // phần được tạo BÊN NGOÀI rồi truyền vào
        players.add(Objects.requireNonNull(player));
    }
}

Player messi = new Player("Messi");
Team miami = new Team("Inter Miami");
miami.add(messi);   // messi vẫn tồn tại độc lập với miami

2.5. Liên kết (association)

Hai class biết nhau lâu dài (thường qua field) nhưng chưa nói rõ có sở hữu không. Ví dụ Driver giữ tham chiếu tới Car đang lái, Student liên kết với Course. Association có chiều (một hay hai chiều) và bội số (multiplicity, mỗi bên có bao nhiêu object): 1, 0..1, *, 1..*.

classDiagram
  Student "*" -- "*" Course : đăng ký
  Customer "1" --> "0..*" Order : đặt

Slide khuyên (và đúng): dùng association ở giai đoạn phân tích, khi chưa rõ bản chất quan hệ; sang thiết kế thì làm rõ nó là composition, aggregation hay chỉ là dependency.

2.6. Phụ thuộc (dependency)

A dùng B tạm thời: B là tham số, biến cục bộ, kiểu trả về, hoặc A gọi method static của B. A không giữ B lâu dài.

public class ReportService {
    public byte[] export(Report report, PdfRenderer renderer) {   // PdfRenderer chỉ là tham số
        return renderer.render(report);
    }
}

Spring constructor injection biến dependency thành field (về hình thức là association), nhưng kiểu field là interface: đó là Dependency Inversion Principle, hai bên cùng phụ thuộc abstraction (xem IoC và Dependency Injection). Áp ở tầng cả codebase (repository interface trong domain, implementation JPA ở rìa) chính là kiến trúc hexagonal và clean, xem Kiến trúc codebase.

Composition hơn inheritance: ví dụ cụ thể

Ví dụ lớn hơn trên code nghiệp vụ: bài Template Method hay composition refactor luồng đặt phòng từ v0 lên v2 bằng Template Method (kế thừa), rồi viết lại bằng composition (danh sách rule và listener ghép theo loại). Kế thừa vỡ khi các biến thể cần kết hợp (“căn hộ + khách doanh nghiệp + đặt dài ngày”), vì mỗi lớp con chỉ có một lớp cha; kèm bẫy override quên gọi super hay gọi method override được trong constructor.

Bài tập

Code đã chạy thử trên JDK 21.

1. Vẽ UML class diagram cho class phân số ở buổi trước

Class Fraction (lời giải đầy đủ ở phần 2) có tử số và mẫu số private, constructor, method rút gọn, method chuyển sang chuỗi, và 4 phép toán trả về phân số mới.

Lời giải Bài 1: sơ đồ Fraction và cách đọc
classDiagram
  class Fraction {
    <<final>>
    -long numerator
    -long denominator
    +Fraction(long numerator, long denominator)
    +reduce() Fraction
    +add(Fraction other) Fraction
    +subtract(Fraction other) Fraction
    +multiply(Fraction other) Fraction
    +divide(Fraction other) Fraction
    +toString() String
    +equals(Object o) boolean
    +hashCode() int
    -gcd(long a, long b)$ long
  }
  class Object
  Object <|-- Fraction
  Fraction ..> ArithmeticException : ném khi mẫu số = 0
  • Hai field là - (private) để bảo vệ invariant mẫu số khác 0.
  • gcd là private static (dấu $, gạch chân trong UML chuẩn) vì không phụ thuộc trạng thái object.
  • Các phép toán nhận và trả về Fraction vì class bất biến.
  • toString, equals, hashCode override method của Object.
  • Fraction phụ thuộc ArithmeticException (nét đứt), vì chỉ dùng tạm khi ném lỗi.

2. Viết code minh hoạ các quan hệ trong class diagram

Viết một ví dụ thương mại điện tử nhỏ gom đủ 6 quan hệ.

Lời giải Bài 2: ví dụ thương mại điện tử đủ 6 quan hệ
// Triển khai
interface PaymentMethod { boolean pay(BigDecimal amount); }
class CardPayment implements PaymentMethod {
    @Override public boolean pay(BigDecimal amount) { return amount.signum() > 0; }
}

// Kế thừa
abstract class User {
    protected final String id;
    User(String id) { this.id = id; }
}
class Customer extends User {
    private final List<Order> orders = new ArrayList<>();          // Liên kết 1 - * với Order
    Customer(String id) { super(id); }
    Order placeOrder() { Order o = new Order(this); orders.add(o); return o; }
}

// Thành phần: Order tạo ra và sở hữu OrderLine
class Order {
    private final Customer customer;                                // Liên kết ngược về Customer
    private final List<OrderLine> lines = new ArrayList<>();
    Order(Customer customer) { this.customer = customer; }
    void addLine(Product product, int qty) { lines.add(new OrderLine(product, qty)); }
    BigDecimal total() {
        return lines.stream().map(OrderLine::subtotal).reduce(BigDecimal.ZERO, BigDecimal::add);
    }
    // Phụ thuộc: PaymentMethod chỉ là tham số
    boolean checkout(PaymentMethod method) { return method.pay(total()); }
}

record OrderLine(Product product, int qty) {
    BigDecimal subtotal() { return product.price().multiply(BigDecimal.valueOf(qty)); }
}

// Tập hợp: Product tồn tại độc lập, Category chỉ gom chúng lại
record Product(String sku, BigDecimal price) { }
class Category {
    private final List<Product> products = new ArrayList<>();
    void add(Product p) { products.add(p); }                        // Product được tạo ở bên ngoài
}

// Chạy thử
Product book = new Product("BOOK-1", new BigDecimal("120000"));
Category books = new Category();
books.add(book);
Customer c = new Customer("C1");
Order order = c.placeOrder();
order.addLine(book, 2);
System.out.println(order.total() + " " + order.checkout(new CardPayment()));   // 240000 true

Xoá Order thì các OrderLine mất theo (composition). Xoá Category thì Product vẫn còn (aggregation). Order chỉ dùng PaymentMethod trong lúc checkout (dependency).

Ghi nhớ

  • Đọc được một hộp class: ký hiệu + - # ~, gạch chân, in nghiêng, /.
  • Kể được 6 quan hệ theo thứ tự gắn kết, ký hiệu UML và dạng code của mỗi cái.
  • Giải thích được composition khác aggregation ở đâu trong code (ai gọi new) và ở database (cascade, orphan removal).
  • Biết vì sao có setter nhận phần từ ngoài thì không còn là composition.
  • Nói đúng chiều dependency: A phụ thuộc B khi B đổi có thể buộc A đổi.

Câu hỏi phỏng vấn

Junior

Các ký hiệu +, -, #, ~ trong UML class diagram nghĩa là gì?

Lần lượt là public, private, protected, package-private.

Thành viên static được gạch chân, method abstract viết nghiêng, / đánh dấu thuộc tính dẫn xuất (tính từ dữ liệu khác).

Trong UML, kế thừa và triển khai interface được vẽ khác nhau thế nào?

Cả hai dùng tam giác rỗng; kế thừa là nét liền, triển khai là nét đứt.

Kế thừa (generalization) đi từ lớp con tới lớp cha; triển khai (realization) đi từ class tới interface. Nhiều lớp con có thể vẽ mỗi lớp một mũi tên, hoặc gộp chung một tam giác ở lớp cha; hai cách cùng ý nghĩa.

Mid

Composition và aggregation khác nhau thế nào? Biểu hiện trong code ra sao?

Composition: tổng thể tạo và sở hữu phần, phần mất theo. Aggregation: phần tạo ở ngoài, truyền vào, sống độc lập.

Ví dụ Order và OrderLine (composition), Team và Player (aggregation, có thể chia sẻ). Trong code, khác nhau ở chỗ ai gọi new và ai chịu trách nhiệm vòng đời. Ở database, nó thể hiện qua cascade delete và orphan removal.

Association và dependency khác nhau thế nào khi nhìn vào code?

Association giữ tham chiếu lâu dài (field); dependency chỉ dùng tạm (tham số, biến cục bộ, kiểu trả về, gọi static).

Ví dụ Driver có field Car; ReportService.export(report, renderer) chỉ nhận renderer qua tham số. Chiều của dependency: A phụ thuộc B khi thay đổi ở B có thể buộc A thay đổi theo, mũi tên nét đứt đi từ A tới B.

Car có setEngine(Engine) public. Quan hệ Car–Engine có phải composition không?

Không hẳn: engine tạo ở ngoài rồi gắn vào, tráo đổi hay dùng chung được, thì Car không quyết định vòng đời của nó, đó là aggregation.

Muốn là composition, Car phải tự tạo Engine (trong constructor hoặc factory của chính nó), không lộ setter nhận engine từ ngoài, và engine mất theo khi car mất. Ở tầng persistence, điều đó tương ứng cascade và orphan removal.

Senior

Bạn quyết định một quan hệ là composition hay aggregation dựa trên tiêu chí gì, và nó ảnh hưởng gì tới thiết kế persistence?

Dựa vào vòng đời và ranh giới nhất quán (consistency boundary): phần chỉ có nghĩa trong tổng thể thì là composition (aggregate trong DDD); phần sống độc lập thì tham chiếu bằng ID.

  • Composition: invariant được kiểm tra cùng nhau; lưu và xoá cùng nhau, cascade, chỉ sửa qua aggregate root, trong một transaction.
  • Phần sống độc lập, nhiều nơi tham chiếu: giữ ID thay vì object, không cascade, để aggregate không phình và không khoá quá nhiều bản ghi.
Ngoài phỏng vấn, khi nào bạn vẽ UML class diagram và vẽ chi tiết tới mức nào?

Khi thiết kế module mới có nhiều class tương tác hoặc review thay đổi lớn, và chỉ vẽ phần quan trọng cho quyết định đang bàn.

  • Ví dụ module: domain model, aggregate, các strategy. Bỏ getter/setter và field phụ.
  • Viết sơ đồ dạng code (Mermaid, PlantUML) trong repo để review cùng code; sơ đồ lệch khỏi code còn tệ hơn không có.
  • Ở mức hệ thống (service, database, queue) dùng sơ đồ kiến trúc như C4 thay vì class diagram.

Từ vựng tiếng Anh

Term Phát âm Nghĩa Ví dụ câu dùng khi phỏng vấn
class diagram /ˈdaɪəɡræm/ sơ đồ lớp “I sketched a class diagram before writing the payment module.”
visibility /ˌvɪzəˈbɪləti/ phạm vi truy cập (trong UML) “The minus sign marks private visibility.”
derived attribute /dɪˈraɪvd/ thuộc tính dẫn xuất “Total price is a derived attribute, so we don’t store it.”
generalization /ˌdʒenrələˈzeɪʃn/ tổng quát hoá (kế thừa) “Generalization is drawn with a hollow triangle.”
composition /ˌkɑːmpəˈzɪʃn/ quan hệ thành phần “Order lines are in a composition with the order; they share its lifecycle.”
aggregation /ˌæɡrɪˈɡeɪʃn/ quan hệ tập hợp “A team aggregates players, but players can exist on their own.”
association /əˌsoʊsiˈeɪʃn/ quan hệ liên kết “Customer has a one-to-many association with Order.”
dependency /dɪˈpendənsi/ quan hệ phụ thuộc “The service has a dependency on the renderer only through a method parameter.”
multiplicity /ˌmʌltɪˈplɪsəti/ bội số của quan hệ “The multiplicity on that side is zero or more.”
lifecycle /ˈlaɪfsaɪkl/ vòng đời “Whoever creates the object owns its lifecycle.”
aggregate root /ˈæɡrɪɡət ruːt/ gốc của aggregate (DDD) “All changes to order lines go through the aggregate root.”

Ghi chép dựa trên khoá Fundamentals of Backend (Ronin Engineer), viết lại theo cách hiểu của mình. Sách tham khảo của slide: Y. Daniel Liang, Introduction to Java Programming and Data Structures (bản 11), nhiều sơ đồ trong slide lấy từ sách này.