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

Tìm kiếm

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

Lập trình hướng đối tượng: kế thừa, đóng gói và đa hình

Ôn 19 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

Kế thừa giúp tái dùng code, đa hình giúp thêm loại mới mà không sửa code cũ, đóng gói giữ object luôn hợp lệ; dùng sai thì cây kế thừa sâu dễ vỡ và logic nghiệp vụ rơi vãi khắp nơi. Đọc xong, bạn giải thích được extends/super/@Override, cách JVM chọn method lúc chạy và các bẫy phỏng vấn hay gặp. Nên đọc phần 1 trước (class, constructor, access modifier); trừu tượng và thứ tự khởi tạo object nằm ở phần 4.

1. Bốn tính chất của OOP

Ý chính: OOP có bốn tính chất: đóng gói, kế thừa, đa hình và trừu tượng. Bài này nói ba cái đầu; trừu tượng (abstract class, interface) ở phần 4.

flowchart LR
  OOP((OOP)) --> E[Đóng gói<br/>giấu trạng thái, lộ hành vi]
  OOP --> I[Kế thừa<br/>tái sử dụng, quan hệ is-a]
  OOP --> P[Đa hình<br/>một lời gọi, nhiều cách thực thi]
  OOP --> A[Trừu tượng<br/>chỉ lộ cái cần thiết]

2. Kế thừa (inheritance)

Ý chính: subclass (lớp con) tạo ra bằng cách mở rộng một superclass (lớp cha) có sẵn, theo quan hệ “is-a”: Dog là một Animal. Java chỉ cho kế thừa một class, và kế thừa nên dùng dè dặt.

class Animal {
    private final String name;
    protected Animal(String name) { this.name = name; }
    public String name() { return name; }
    public String sound() { return "..."; }
}

class Dog extends Animal {
    private final String breed;

    Dog(String name, String breed) {
        super(name);                 // phải là lệnh đầu tiên của constructor
        this.breed = breed;
    }

    @Override
    public String sound() { return "Gâu"; }

    public String describe() {
        return name() + " (" + breed + ") kêu " + sound() + ", lớp cha thì kêu " + super.sound();
    }
}
Quy tắc Chi tiết
super(...) / super.method() Gọi constructor / phiên bản method của lớp cha. Không viết thì compiler chèn super() không tham số; lớp cha không có constructor đó thì lỗi biên dịch.
this Trỏ tới object hiện tại.
Field private của lớp cha Vẫn tồn tại trong object lớp con, nhưng lớp con không truy cập trực tiếp được; phải qua method public/protected.
Đơn kế thừa Một class chỉ extends một class (tránh “vấn đề kim cương”), nhưng implements được nhiều interface. Mọi class ngầm kế thừa java.lang.Object.
Constructor Không được kế thừa: lớp con tự khai báo và gọi super(...) phù hợp.
Thành viên static Được kế thừa (gọi qua tên lớp con) nhưng không có đa hình.
final final class (ví dụ String) không ai kế thừa được; final method không override được.

Từ Java 25 (JEP 513), được đặt một số lệnh trước super(...), ví dụ kiểm tra tham số, miễn là không đụng tới this.

Slide khuyên “đừng kế thừa tuỳ tiện” là đúng. Lý do:

Ví dụ: cây tứ giác và giới hạn của “is-a”

Ý chính: cây hình học đúng về toán, nhưng “is-a” trong toán chưa đủ cho một cây class an toàn. Toán nói về tính chất của hình; class còn mang hành vi, nhất là hành vi thay đổi trạng thái.

Slide vẽ: tứ giác là gốc; hình bình hành là tứ giác; hình chữ nhật và hình thoi là hình bình hành; hình vuông là hình chữ nhật. Vẽ lại bằng UML class diagram:

classDiagram
  direction BT
  class Quadrilateral
  class Parallelogram
  class Rectangle
  class Rhombus
  class Square
  Quadrilateral <|-- Parallelogram
  Parallelogram <|-- Rectangle
  Parallelogram <|-- Rhombus
  Rectangle <|-- Square

Mũi tên đi từ lớp con lên lớp cha, tam giác rỗng chạm lớp cha: lớp con biết lớp cha, lớp cha không biết lớp con.

Phiên bản an toàn: sealed interface và record (đã chạy trên JDK 21)
sealed interface Shape permits Rect, Sq { double area(); }

record Rect(double width, double height) implements Shape {
    public double area() { return width * height; }
    Rect withWidth(double w) { return new Rect(w, height); }   // trả về object mới
}

record Sq(double side) implements Shape {
    public double area() { return side * side; }
    Rect asRect() { return new Rect(side, side); }             // cần "kéo dãn" thì chuyển sang Rect
}

Sq sq = new Sq(3);
Rect wider = sq.asRect().withWidth(5);
System.out.println(sq.area() + " " + wider.area());          // 9.0 15.0, sq không bị đổi

3. Đóng gói (encapsulation)

Ý chính: đóng gói là giấu trạng thái bên trong, chỉ cho bên ngoài tác động qua method có kiểm soát. Nhờ vậy object luôn giữ được invariant (các ràng buộc luôn đúng, ví dụ “số dư không âm”).

Ví dụ trong slide: mỗi hình tính diện tích một kiểu, nên logic đó phải thuộc về chính class của hình, không nằm trong chuỗi if (shape is Circle) ... else if (shape is Square) ... bên ngoài. Điều này dẫn thẳng sang đa hình.

4. Đa hình (polymorphism)

Ý chính: cùng một lời gọi method, hành vi khác nhau tuỳ đối tượng, nên một đoạn code dùng chung được cho nhiều loại object. Có hai dạng: overloading (chọn lúc biên dịch) và overriding (chọn lúc chạy).

Overloading (nạp chồng) Overriding (ghi đè)
Loại đa hình Lúc biên dịch (static) Lúc chạy (dynamic dispatch)
Vị trí Cùng class, hoặc lớp con thêm phiên bản mới Lớp con định nghĩa lại method của lớp cha hoặc interface
Signature Cùng tên, khác danh sách tham số Cùng tên và cùng tham số; kiểu trả về giống hoặc là kiểu con (covariant)
Chọn phiên bản dựa vào Kiểu khai báo của các đối số Kiểu thực tế của object lúc chạy
static/private/final Overload được Không override được

Compile-time là lúc javac (và IDE khi gạch đỏ) kiểm tra kiểu; runtime là lúc JVM chạy bytecode. Chọn overload, gọi method không tồn tại hay gán sai kiểu bị chặn khi biên dịch; downcast sai hay null chỉ lộ ra lúc chạy (xem ba loại lỗi ở Java cơ bản).

abstract class Shape {
    abstract double area();
}
class Circle extends Shape {
    private final double r;
    Circle(double r) { this.r = r; }
    @Override double area() { return Math.PI * r * r; }
}
class Rect extends Shape {
    private final double w, h;
    Rect(double w, double h) { this.w = w; this.h = h; }
    @Override double area() { return w * h; }
}

List<Shape> shapes = List.of(new Circle(1), new Rect(2, 3));
double total = 0;
for (Shape s : shapes) total += s.area();   // JVM chọn đúng area() theo kiểu thật của từng object

Thêm Triangle thì vòng lặp không cần sửa. Đó là Open/Closed Principle: mở để mở rộng, đóng với việc sửa đổi.

Quy tắc override cần nhớ (có chỗ slide nói chưa chuẩn):

  • Signature theo đặc tả Java chỉ gồm tên và danh sách kiểu tham số. Kiểu trả về không thuộc signature, nhưng khi override phải giống hoặc là kiểu con (covariant return).
  • Không được thu hẹp access (cha public thì con không được protected), không được ném thêm checked exception rộng hơn.
  • Luôn ghi @Override: gõ sai tên hay tham số thì compiler báo lỗi, thay vì âm thầm tạo một overload.
  • Method private không override được, vì lớp con không nhìn thấy nó.
Quy tắc chọn overload và bên dưới dynamic dispatch

Upcasting, downcasting và instanceof

Ý chính: kiểu khai báo (bên trái dấu =) quyết định bạn được gọi method nào; kiểu thật (class của object trên heap) quyết định phiên bản nào chạy. Upcast luôn an toàn; downcast sai thì ném ClassCastException lúc chạy.

class Animal {
    String sound() { return "..."; }
}
class Dog extends Animal {
    @Override String sound() { return "Gâu"; }
    void wagTail() { System.out.println("vẫy đuôi"); }
}
class Cat extends Animal { }

Animal a = new Dog();     // upcast: luôn an toàn, không cần ép kiểu
a.sound();                // "Gâu": kiểu thật quyết định phiên bản
// a.wagTail();           // lỗi biên dịch: kiểu khai báo Animal không có wagTail

Dog d = (Dog) a;          // downcast: phải ép tường minh, compiler tin bạn
d.wagTail();              // OK vì object thật sự là Dog

Animal c = new Cat();
Dog x = (Dog) c;          // biên dịch được, nhưng lúc chạy ném ClassCastException
  • Upcast (con → cha) luôn hợp lệ, nhờ đó List<Shape> chứa được mọi hình.
  • Downcast (cha → con) chỉ đúng khi object thật sự là lớp con đó. Ép null sang kiểu nào cũng không lỗi, kết quả vẫn là null.
  • Ép giữa hai class khác nhánh ((String) dog) thì compiler chặn ngay.
  • x instanceof T trả về false khi x là null, không cần kiểm tra null riêng.

Từ Java 16 (JEP 394), instanceof có pattern matching: kiểm tra và ép kiểu trong một bước, biến chỉ tồn tại nơi điều kiện chắc chắn đúng.

if (a instanceof Dog dog) {           // không cần dòng Dog dog = (Dog) a;
    dog.wagTail();
}
if (!(o instanceof String s)) return; // phủ định: từ đây trở xuống s đã dùng được
if (o instanceof String s && s.length() > 3) { ... }   // dùng được ngay trong điều kiện &&
Field không có đa hình: ví dụ che field

Bài tập

Đề đã viết lại ngắn gọn. Code đã chạy thử trên JDK 21.

1. Lab 05: Person → Employee → Manager

Đề (diễn giải): ba lớp xếp tầng.

  • Person: tên, tuổi, constructor, getter/setter, method tự giới thiệu.
  • Employee kế thừa Person: thêm mã nhân viên và lương; constructor gọi super(name, age); override phần giới thiệu để in thêm mã và lương; hai phiên bản tính lương: không tham số trả về lương, có tham số thưởng trả về lương cộng thưởng.
  • Manager kế thừa Employee: thêm phòng ban, override phần giới thiệu nhưng tái dùng bản của lớp cha.
  • main: tạo quản lý 25 tuổi, mã M001, lương 2000, phòng Sales; gọi phần giới thiệu và cả hai phiên bản tính lương (thưởng 500).
Lời giải Lab 05 và nhận xét của senior
import java.math.BigDecimal;
import java.util.Objects;

public class Lab05 {
    static class Person {
        private final String name;
        private int age;

        Person(String name, int age) {
            this.name = Objects.requireNonNull(name, "name");
            setAge(age);
        }

        public String getName() { return name; }
        public int getAge() { return age; }
        public void setAge(int age) {
            if (age < 0) throw new IllegalArgumentException("age must be >= 0");
            this.age = age;
        }

        public void introduce() {
            System.out.println("Name: " + name);
            System.out.println("Age: " + age);
        }
    }

    static class Employee extends Person {
        private final String employeeId;
        private final BigDecimal salary;

        Employee(String name, int age, String employeeId, BigDecimal salary) {
            super(name, age);                                  // phải là lệnh đầu tiên
            this.employeeId = Objects.requireNonNull(employeeId, "employeeId");
            if (salary.signum() < 0) throw new IllegalArgumentException("salary must be >= 0");
            this.salary = salary;
        }

        public String getEmployeeId() { return employeeId; }

        @Override
        public void introduce() {
            super.introduce();                                 // tái dùng phần in của Person
            System.out.println("Employee ID: " + employeeId);
            System.out.println("Salary: " + salary);
        }

        public BigDecimal calculateSalary() {                  // overload 1
            return salary;
        }

        public BigDecimal calculateSalary(BigDecimal bonus) {  // overload 2: khác danh sách tham số
            if (bonus.signum() < 0) throw new IllegalArgumentException("bonus must be >= 0");
            return calculateSalary().add(bonus);               // gọi bản không tham số: lớp con override thì vẫn đúng
        }
    }

    static class Manager extends Employee {
        private final String department;

        Manager(String name, int age, String employeeId, BigDecimal salary, String department) {
            super(name, age, employeeId, salary);
            this.department = department;
        }

        @Override
        public void introduce() {
            super.introduce();                                 // Employee.introduce -> Person.introduce
            System.out.println("Department: " + department);
        }
    }

    public static void main(String[] args) {
        Manager m = new Manager("Lan", 25, "M001", new BigDecimal("2000"), "Sales");
        m.introduce();
        System.out.println("Base salary: " + m.calculateSalary());
        System.out.println("Salary with bonus: " + m.calculateSalary(new BigDecimal("500")));

        Person p = m;                                          // upcast
        p.introduce();                                         // vẫn chạy bản của Manager
    }
}
Name: Lan
Age: 25
Employee ID: M001
Salary: 2000
Department: Sales
Base salary: 2000
Salary with bonus: 2500
(p.introduce() in lại đúng năm dòng đầu)

Những điểm cần thấy:

  • super(name, age) phải là lệnh đầu tiên. Person không có constructor không tham số, nên thiếu dòng này là lỗi biên dịch (compiler chỉ chèn ngầm super() không tham số).
  • super.introduce() tạo chuỗi Manager → Employee → Person: mỗi tầng chỉ in phần của mình, không chép code.
  • Hai calculateSalary là overload (khác tham số, chọn lúc biên dịch). introduce là override (chọn lúc chạy), nên Person p = m; p.introduce() vẫn in phòng ban.
  • calculateSalary(bonus) gọi calculateSalary() thay vì đọc thẳng field salary. Nếu lớp con override lương cơ bản (ví dụ quản lý nhận 110% như một bài tập override khác trong tài liệu), bản có thưởng tự đúng theo.

Góp ý của senior:

  • Person → Employee → Manager là ví dụ kinh điển nhưng hay sai ngoài đời. “Quản lý” là vai trò có thể đổi (thăng chức), không phải kiểu cố định. Java không đổi được class của object đang sống, nên thăng chức nghĩa là tạo object mới và mất identity.
  • Thiết kế bền hơn: Employee giữ một field Position hoặc Role (composition, xem phần 5).
  • introduce() in thẳng ra console là trộn logic với trình bày; trả về String hoặc override toString() thì mới test được.
  • Lương dùng BigDecimal, thưởng âm bị chặn.

Ghi nhớ

  • Giải thích được vì sao nên ưu tiên composition, kèm ví dụ InstrumentedSet và Stack extends Vector.
  • Giải thích được vì sao Square extends Rectangle vi phạm Liskov, và khi nào nó lại chấp nhận được.
  • Phân biệt được overload và override: chọn lúc nào, dựa vào kiểu nào; và vì sao static, field chỉ bị che.
  • Biết kiểu khai báo và kiểu thật mỗi cái quyết định gì, khi nào downcast an toàn.
  • Biết thứ tự compiler chọn overload (widening → boxing → varargs) và bẫy list.remove(1).

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

Junior

Bốn tính chất của OOP là gì? Mỗi tính chất cho một ví dụ.

Đóng gói, kế thừa, đa hình và trừu tượng.

  • Đóng gói: Account.withdraw() tự kiểm tra số dư.
  • Kế thừa: Dog extends Animal.
  • Đa hình: shape.area() chạy đúng phiên bản theo kiểu thật của object.
  • Trừu tượng: code phụ thuộc interface PaymentGateway mà không cần biết bên dưới là Stripe hay VNPay.
Java có đa kế thừa không? super dùng để làm gì?

Không với class: một class chỉ extends một class, nhưng implements được nhiều interface. super gọi constructor hoặc method của lớp cha.

Đơn kế thừa tránh “vấn đề kim cương” khi hai lớp cha có trạng thái hoặc cài đặt trùng nhau. super(...) phải là lệnh đầu tiên trong constructor; không viết thì compiler chèn super() không tham số. super.method() gọi bản của lớp cha từ trong bản override. Constructor không được kế thừa, nên lớp con luôn tự khai báo constructor.

Mid

Overloading và overriding khác nhau thế nào? Method static có override được không?

Overload chọn lúc biên dịch theo kiểu khai báo của đối số; override chọn lúc chạy theo kiểu thật của object. Static không override được, chỉ bị che.

Overloading là cùng tên khác tham số. Overriding là lớp con định nghĩa lại method cùng signature. Với static (hiding), bản nào được gọi phụ thuộc kiểu khai báo của biến.

Animal a = new Dog(); thì a gọi được những method nào? Downcast khi nào an toàn?

Kiểu khai báo Animal quyết định gọi được gì, kiểu thật Dog quyết định bản nào chạy. Downcast chỉ an toàn khi object thật sự là kiểu đích.

a không gọi được wagTail() riêng của Dog, nhưng a.sound() chạy bản của Dog. Field không đa hình: a.name đọc field khai báo trong Animal. Downcast sai thì ClassCastException; kiểm tra bằng instanceof, từ Java 16 viết gọn if (a instanceof Dog d). instanceof với null trả về false.

Khi nhiều overload cùng khớp với một lời gọi, compiler chọn bản nào?

Ba bước: khớp chính xác hoặc widening, rồi boxing/unboxing, cuối cùng varargs; trong một bước chọn bản cụ thể nhất.

  • m(long) và m(Integer): m(5) gọi m(long).
  • n(Object) và n(String): n(null) gọi n(String).
  • p(String) và p(Integer): p(null) là lỗi ambiguous.

Tất cả dựa trên kiểu khai báo của đối số, không phải kiểu thật lúc chạy, và không overload được chỉ bằng kiểu trả về.

Senior

“Favor composition over inheritance” nghĩa là gì? Cho ví dụ kế thừa gây hại.

Kế thừa buộc lớp con phụ thuộc chi tiết cài đặt của lớp cha (fragile base class); composition chỉ phụ thuộc API public nên linh hoạt hơn.

  • Class đếm phần tử kế thừa HashSet bị đếm trùng, vì addAll gọi add bên trong.
  • Stack extends Vector lộ ra method phá vỡ LIFO.

Composition (bọc object bên trong và uỷ quyền) còn đổi được lúc chạy. Chỉ kế thừa khi thật sự là is-a và tuân thủ Liskov Substitution Principle.

Dynamic dispatch hoạt động thế nào trong JVM? Có tốn chi phí không?

JVM tra vtable/itable theo class thật của object; JIT inline các chỗ gọi ít kiểu, nên chi phí hiếm khi là nút thắt.

Lời gọi instance dùng invokevirtual/invokeinterface. JIT theo dõi từng chỗ gọi: chỉ gặp một kiểu (monomorphic) hoặc hai kiểu (bimorphic) thì inline kèm một bước kiểm tra kiểu nhỏ. Chỗ gặp nhiều kiểu (megamorphic) mới phải tra bảng thật sự.

Hình vuông là hình chữ nhật trong toán. Vậy Square extends Rectangle sai ở đâu, và khi nào nó lại chấp nhận được?

Sai vì LSP đòi lớp con giữ mọi hợp đồng hành vi của lớp cha, mà Square không giữ được hợp đồng “đổi rộng, cao độc lập”. Chấp nhận được khi hình bất biến.

Đổi chiều cao của Square thì chiều rộng cũng đổi, nên code dùng Rectangle cho kết quả sai. Nếu hình bất biến (không setter, thay đổi trả về object mới), hợp đồng chỉ còn các phép đọc như area(), và hình vuông thoả hết. Thực tế mình thường chọn sealed interface Shape với các record ngang hàng: đơn giản hơn và switch kiểm tra được đủ trường hợp.

Từ vựng tiếng Anh

Term Phát âm Nghĩa Ví dụ câu dùng khi phỏng vấn
encapsulation /ɪnˌkæpsjuˈleɪʃn/ đóng gói “Encapsulation is about protecting invariants, not just adding getters and setters.”
inheritance /ɪnˈherɪtəns/ kế thừa “I use inheritance only for true is-a relationships.”
polymorphism /ˌpɑːliˈmɔːrfɪzəm/ đa hình “Polymorphism lets me add a new shape without touching the calling code.”
override / overload /ˌoʊvərˈraɪd/ /ˌoʊvərˈloʊd/ ghi đè / nạp chồng “Overloading is resolved at compile time; overriding at runtime.”
dynamic dispatch /daɪˈnæmɪk dɪˈspætʃ/ chọn method lúc chạy “Dynamic dispatch picks the implementation based on the runtime type.”
method hiding che method static “Static methods are hidden, not overridden.”
fragile base class /ˈfrædʒl/ lớp cha “mong manh” “Deep hierarchies suffer from the fragile base class problem.”
Liskov substitution /ˈlɪskɒf/ nguyên tắc thay thế Liskov “Square extending Rectangle violates Liskov substitution.”
generalization /ˌdʒenrələˈzeɪʃn/ tổng quát hoá (mũi tên kế thừa trong UML) “The generalization arrow points from the subclass to the superclass.”
upcast / downcast /ˈʌpkæst/ /ˈdaʊnkæst/ ép kiểu lên / ép kiểu xuống “An upcast is always safe; a downcast can throw ClassCastException.”
field hiding field lớp con che field lớp cha “Fields aren’t polymorphic; a field with the same name just hides the parent’s.”

Ghi chép dựa trên khoá Fundamentals of Backend (Ronin Engineer) và tài liệu Java Core của Hỏi Dân IT, cộng thêm kiến thức tự tìm hiểu, viết lại theo cách hiểu của mình.