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
publicthì con không đượcprotected), 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
privatekhô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
nullsang 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 Ttrả vềfalsekhixlà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.Employeekế thừaPerson: thêm mã nhân viên và lương; constructor gọisuper(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.Managerkế thừaEmployee: 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.Personkhô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ầmsuper()không tham số).super.introduce()tạo chuỗiManager→Employee→Person: mỗi tầng chỉ in phần của mình, không chép code.- Hai
calculateSalarylà overload (khác tham số, chọn lúc biên dịch).introducelà override (chọn lúc chạy), nênPerson p = m; p.introduce()vẫn in phòng ban. calculateSalary(bonus)gọicalculateSalary()thay vì đọc thẳng fieldsalary. 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 → Managerlà 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:
Employeegiữ một fieldPositionhoặcRole(composition, xem phần 5). introduce()in thẳng ra console là trộn logic với trình bày; trả vềStringhoặc overridetoString()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ụ
InstrumentedSetvàStack extends Vector. - Giải thích được vì sao
Square extends Rectanglevi 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
PaymentGatewaymà 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ọim(long).n(Object)vàn(String):n(null)gọin(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
HashSetbị đếm trùng, vìaddAllgọiaddbên trong. Stack extends Vectorlộ 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.