Java4 dạng theo lý thuyết — thực tế chỉ 3 vì Java không cho multiple class inheritance.
1. SINGLE — A → B
2. MULTI-LEVEL — A → B → C
3. HIERARCHICAL — A có nhiều con: B, C
4. MULTIPLE — Java CẤM với class; mô phỏng qua interfaceclass Animal { void eat() {} }
class Mammal extends Animal { void breastfeed() {} } // multi-level
class Dog extends Mammal { void bark() {} }
interface Swimmer { void swim(); }
interface Flyer { void fly(); }
class Duck extends Animal implements Swimmer, Flyer {} // "multiple" qua interfaceVì sao cấm multiple class inheritance? Diamond problem — nếu D extends B, C mà cả 2 đều có method m(), không rõ gọi version nào. C++ cho phép với virtual phức tạp; Java cấm để tránh.
Java 8 default method tái xuất diamond → bắt subclass override tường minh:
class C implements A, B {
@Override public void m() { A.super.m(); } // bắt buộc nếu A, B trùng default
}Lưu ý:
- Constructor không kế thừa.
- final class chống extends; sealed class (Java 17+) giới hạn subclass cụ thể.
Best practice: Favor composition over inheritance — composition (has-a) linh hoạt hơn is-a.
4 textbook types — really 3 because Java does not allow multiple class inheritance.
1. SINGLE — A → B
2. MULTI-LEVEL — A → B → C
3. HIERARCHICAL — A has many children: B, C
4. MULTIPLE — Java FORBIDS for classes; simulated via interfacesclass Animal { void eat() {} }
class Mammal extends Animal { void breastfeed() {} } // multi-level
class Dog extends Mammal { void bark() {} }
interface Swimmer { void swim(); }
interface Flyer { void fly(); }
class Duck extends Animal implements Swimmer, Flyer {} // "multiple" via interfacesWhy forbid multiple class inheritance? Diamond problem — if D extends B, C and both have m(), which one wins? C++ allows it with complex virtual rules; Java forbids it for simplicity.
Java 8 default methods reintroduce the diamond → force the subclass to override explicitly:
class C implements A, B {
@Override public void m() { A.super.m(); } // required if A, B share default
}Notes:
- Constructors are not inherited.
- final class blocks extension; sealed class (Java 17+) restricts to specific subclasses.
Best practice: Favor composition over inheritance — composition (has-a) is more flexible than is-a.