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

Tìm kiếm

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

Lập trình hướng đối tượng: abstract class, interface và thứ tự khởi tạo

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

Khi code phụ thuộc vào “làm được gì” thay vì “ai làm”, ta thay được phần cài đặt mà không đụng tới phía gọi: đó là tính trừu tượng, nền tảng của dependency injection và của mock khi test. Đọc xong, bạn chọn đúng giữa abstract class và interface, xử lý được xung đột default method, và đoán đúng “đoạn code này in ra gì” khi hỏi về thứ tự khởi tạo. Nên đọc phần 1 (class, constructor, static) và phần 3 (kế thừa, đa hình) trước.

1. Trừu tượng (abstraction)

Ý chính: trừu tượng là chỉ giữ lại hành vi cốt lõi mà phía gọi cần và giấu chi tiết cài đặt. Java có hai công cụ: abstract class cho một họ lớp chia sẻ code, interface cho một khả năng mà nhiều class không liên quan cùng có.

Abstract class chứa được cả method abstract (chưa có thân) lẫn method đã cài đặt, có field và constructor. Không new trực tiếp được, và lớp con cụ thể phải cài đặt mọi method abstract. Constructor của nó vẫn chạy khi tạo lớp con, qua chuỗi gọi super(...) (constructor chaining: constructor con gọi constructor cha trước).

public abstract class Employee {
    private final String id;
    protected Employee(String id) { this.id = id; }   // chạy khi tạo lớp con

    public String id() { return id; }
    public abstract BigDecimal monthlySalary();       // lớp con bắt buộc cài đặt

    public final String payslip() {                   // Template Method: khung cố định
        return id + ": " + monthlySalary();
    }
}

payslip() ở trên là Template Method: lớp cha giữ khung thuật toán cố định (final), lớp con chỉ điền bước còn thiếu. Vài quy tắc hay bị hỏi:

  • Class có ít nhất một method abstract thì bắt buộc khai báo abstract. Chiều ngược lại không bắt buộc: abstract class có thể không có method abstract nào, chỉ để cấm new trực tiếp.
  • Method abstract không có thân (kết thúc bằng ;) và không được là private, static hay final, vì cả ba đều khiến lớp con không override được.
  • Lớp con không cài đặt hết các method abstract thì chính nó cũng phải là abstract.

Interface là hợp đồng mô tả “làm được gì”, và một class cài đặt được nhiều interface. Nó hợp để định nghĩa một kiểu chung cho những class không liên quan với nhau (Comparable, AutoCloseable, Runnable).

public interface Notifier {
    int MAX_RETRY = 3;                         // ngầm định là public static final
    void send(String to, String message);      // ngầm định là public abstract

    default void sendAll(List<String> to, String message) {   // Java 8+: method có thân
        to.forEach(t -> send(t, message));
    }
    static Notifier noop() { return (to, msg) -> { }; }       // Java 8+: static method
}

Trong backend, interface phổ biến hơn hẳn. Code phụ thuộc vào interface (PaymentGateway) thay vì class cụ thể (StripeGateway), nên dễ thay cài đặt và dễ mock khi test. Đây là nền tảng của Dependency Injection.

Java 17 có thêm sealed interface/class: chỉ những class liệt kê trong permits mới được cài đặt. Nhờ vậy compiler biết hết các trường hợp và kiểm tra switch đã xử lý đủ chưa (exhaustive):

public sealed interface PaymentResult permits Success, Failure { }
public record Success(String txId) implements PaymentResult { }
public record Failure(String reason) implements PaymentResult { }

String message = switch (result) {      // compiler biết đã xử lý đủ trường hợp, không cần default
    case Success s -> "OK " + s.txId();
    case Failure f -> "Lỗi: " + f.reason();
};

2. Thứ tự khởi tạo

Ý chính: static trước instance, cha trước con, initializer trước thân constructor. Phần static chỉ chạy một lần, khi class được nạp lần đầu.

Khi chạy new Child() lần đầu tiên, Java làm theo thứ tự sau:

  1. Nạp và khởi tạo class (chỉ một lần cho mỗi class): khởi tạo lớp cha trước, nên chạy các khối static { } và gán field static của Parent, rồi tới của Child, theo thứ tự xuất hiện trong code.
  2. Cấp phát object: mọi field có giá trị mặc định (0, false, null).
  3. Constructor của Child gọi super(...) (tường minh hoặc ngầm định), nên phần của Parent chạy trước: các initializer của field và khối { } của Parent theo thứ tự trong code, rồi tới thân constructor của Parent.
  4. Quay lại Child: initializer của field và khối { } của Child, rồi thân constructor của Child.
class Parent {
    static { System.out.println("1. Parent static"); }
    { System.out.println("3. Parent instance init"); }
    Parent() { System.out.println("4. Parent constructor"); }
}
class Child extends Parent {
    static { System.out.println("2. Child static"); }
    { System.out.println("5. Child instance init"); }
    Child() { System.out.println("6. Child constructor"); }
}

new Child();   // in 1 → 6
new Child();   // lần hai chỉ in 3 → 6: phần static đã chạy rồi

Giống xây nhà: móng chung của cả khu (static) đổ một lần, rồi mỗi căn xây tầng dưới (cha) trước tầng trên (con).

Bài tập

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

1. Hệ thống quản lý khách sạn (chỉ có trong bản slide thứ hai)

Yêu cầu: các đối tượng gồm lễ tân, lao công, quản lý, khách sạn, phòng…; dùng ít nhất 1 abstract class, ít nhất 2 interface, có override và overload ít nhất 1 method; tính năng gồm cấu hình phòng, cấu hình nhân viên, gán phòng cho nhân viên phụ trách, xem danh sách phòng của một nhân viên, tính lương dựa trên số phòng phụ trách và trọng số.

classDiagram
  class Payable {
    <<interface>>
    +monthlySalary() BigDecimal
  }
  class RoomAssignable {
    <<interface>>
    +assign(Room room)
    +rooms() List~Room~
  }
  class Employee {
    <<abstract>>
    -String id
    -String name
    #BigDecimal baseSalary
    +monthlySalary()* BigDecimal
  }
  class Housekeeper
  class Receptionist
  class Manager
  class Hotel {
    -Map rooms
    -Map staff
    +addRoom(Room)
    +hire(Employee)
    +assign(String employeeId, String roomNumber)
  }
  class Room {
    <<record>>
    +String number
    +RoomType type
  }
  Payable <|.. Employee
  RoomAssignable <|.. Housekeeper
  Employee <|-- Housekeeper
  Employee <|-- Receptionist
  Employee <|-- Manager
  Hotel o-- Employee
  Hotel *-- Room
Lời giải Bài 1: code Java đầy đủ và ví dụ tính lương
interface Payable { BigDecimal monthlySalary(); }

interface RoomAssignable {
    void assign(Room room);
    List<Room> rooms();
}

enum RoomType {
    STANDARD(1.0), DELUXE(1.5), SUITE(2.0);          // trọng số công việc theo loại phòng
    final double weight;
    RoomType(double weight) { this.weight = weight; }
}

record Room(String number, RoomType type) { }

abstract class Employee implements Payable {
    private final String id;
    private final String name;
    protected final BigDecimal baseSalary;

    protected Employee(String id, String name, BigDecimal baseSalary) {
        this.id = id; this.name = name; this.baseSalary = baseSalary;
    }
    public String id() { return id; }
    public String name() { return name; }
    @Override public String toString() { return getClass().getSimpleName() + "(" + id + ", " + name + ")"; }
}

class Housekeeper extends Employee implements RoomAssignable {
    private static final BigDecimal PER_WEIGHT = new BigDecimal("500000");
    private final List<Room> rooms = new ArrayList<>();

    Housekeeper(String id, String name, BigDecimal base) { super(id, name, base); }

    @Override public void assign(Room room) { rooms.add(room); }
    public void assign(Room... many) { for (Room r : many) assign(r); }     // overload
    @Override public List<Room> rooms() { return List.copyOf(rooms); }      // không lộ list bên trong

    @Override public BigDecimal monthlySalary() {                           // override
        double totalWeight = rooms.stream().mapToDouble(r -> r.type().weight).sum();
        return baseSalary.add(PER_WEIGHT.multiply(BigDecimal.valueOf(totalWeight)))
                         .setScale(0, RoundingMode.HALF_UP);
    }
}

class Receptionist extends Employee {
    Receptionist(String id, String name, BigDecimal base) { super(id, name, base); }
    @Override public BigDecimal monthlySalary() { return baseSalary; }
}

class Manager extends Employee {
    Manager(String id, String name, BigDecimal base) { super(id, name, base); }
    @Override public BigDecimal monthlySalary() { return baseSalary.multiply(new BigDecimal("1.5")); }
}

class Hotel {
    private final Map<String, Room> rooms = new LinkedHashMap<>();
    private final Map<String, Employee> staff = new LinkedHashMap<>();

    void addRoom(Room room) { rooms.put(room.number(), room); }           // cấu hình phòng
    void hire(Employee e) { staff.put(e.id(), e); }                       // cấu hình nhân viên

    void assign(String employeeId, String roomNumber) {                   // gán phòng cho nhân viên
        Room room = Optional.ofNullable(rooms.get(roomNumber))
                .orElseThrow(() -> new NoSuchElementException("Không có phòng " + roomNumber));
        if (!(staff.get(employeeId) instanceof RoomAssignable worker))
            throw new IllegalArgumentException(employeeId + " không phụ trách phòng được");
        worker.assign(room);
    }

    List<Room> roomsOf(String employeeId) {                               // xem phòng của một nhân viên
        return staff.get(employeeId) instanceof RoomAssignable w ? w.rooms() : List.of();
    }

    BigDecimal payroll() {                                                // đa hình: không cần biết loại nhân viên
        return staff.values().stream().map(Payable::monthlySalary).reduce(BigDecimal.ZERO, BigDecimal::add);
    }
}

Ví dụ: lao công lương cơ bản 6 000 000, phụ trách một phòng STANDARD (trọng số 1) và một phòng SUITE (trọng số 2), sẽ có lương 6 000 000 + 500 000 × 3 = 7 500 000.

Điểm thiết kế đáng nói khi phỏng vấn:

  • Hotel.payroll() không có dòng if nào theo loại nhân viên, nhờ đa hình. Thêm loại nhân viên mới chỉ cần thêm class mới.
  • Chỉ nhân viên cài đặt RoomAssignable mới được gán phòng, nên Receptionist không phải mang một method assign vô nghĩa. Đây là Interface Segregation Principle (không bắt class phụ thuộc vào method nó không dùng).
  • Tiền dùng BigDecimal. Trong hệ thống thật, quy tắc tính lương nên tách ra một SalaryPolicy riêng để đổi quy tắc mà không sửa class nhân viên.

2. Lab 06: abstract class Person và interface Trainable

Đề (diễn giải): abstract class Person có tên, tuổi, constructor, getter/setter, một method tự giới thiệu (“My name is …, I am … years old.”) và một method work() abstract. Interface Trainable có method tham gia đào tạo theo chủ đề và một default method gửi lời cảm ơn sau buổi đào tạo. Hai lớp con: kỹ sư (có chuyên môn) và quản lý (có quy mô nhóm), cả hai cài đặt Trainable và tự in câu mô tả công việc, câu tham gia đào tạo riêng. Trong main, tạo mảng Person[] chứa cả hai loại, duyệt mảng gọi giới thiệu và work(), rồi nếu phần tử là Trainable thì ép kiểu và gọi phần đào tạo cùng lời cảm ơn.

Lời giải Lab 06: code, output và những điểm cần thấy
import java.util.List;
import java.util.Objects;

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

        protected Person(String name, int age) {               // abstract class vẫn có constructor
            this.name = Objects.requireNonNull(name, "name");
            if (age < 0) throw new IllegalArgumentException("age must be >= 0");
            this.age = age;
        }

        public String getName() { return name; }
        public int getAge() { return age; }

        public void introduce() {
            System.out.printf("My name is %s, I am %d years old.%n", name, age);
        }

        public abstract void work();                           // lớp con cụ thể bắt buộc cài đặt
    }

    interface Trainable {
        void attendTraining(String topic);

        default void feedback() {                              // Java 8+: method có thân trong interface
            System.out.println("Thanks for the training session.");
        }
    }

    static final class Engineer extends Person implements Trainable {
        private final String specialty;

        Engineer(String name, int age, String specialty) {
            super(name, age);
            this.specialty = specialty;
        }

        @Override public void work() {
            System.out.printf("Engineer %s is working on %s project.%n", getName(), specialty);
        }

        @Override public void attendTraining(String topic) {
            System.out.printf("Engineer %s is attending training on %s.%n", getName(), topic);
        }
    }

    static final class Manager extends Person implements Trainable {
        private final int teamSize;

        Manager(String name, int age, int teamSize) {
            super(name, age);
            this.teamSize = teamSize;
        }

        @Override public void work() {
            System.out.printf("Manager %s is managing a team of %d people.%n", getName(), teamSize);
        }

        @Override public void attendTraining(String topic) {
            System.out.printf("Manager %s is attending management training on %s.%n", getName(), topic);
        }
    }

    static final class Intern extends Person {                 // không Trainable: để thấy nhánh instanceof false
        Intern(String name, int age) { super(name, age); }
        @Override public void work() { System.out.println("Intern " + getName() + " is shadowing the team."); }
    }

    public static void main(String[] args) {
        Person[] people = {                                    // upcast: mảng kiểu cha chứa object lớp con
            new Engineer("Lan", 25, "AI"),
            new Manager("Minh", 40, 10),
            new Intern("Hoa", 20)
        };
        String[] topics = {"Cloud Computing", "Leadership", "Git"};

        for (int i = 0; i < people.length; i++) {
            Person p = people[i];
            p.introduce();                                     // method chung của lớp cha
            p.work();                                          // dynamic dispatch theo kiểu thật
            if (p instanceof Trainable t) {                    // kiểm tra + ép kiểu một bước (Java 16+)
                t.attendTraining(topics[i]);
                t.feedback();
            }
        }
    }
}
My name is Lan, I am 25 years old.
Engineer Lan is working on AI project.
Engineer Lan is attending training on Cloud Computing.
Thanks for the training session.
My name is Minh, I am 40 years old.
Manager Minh is managing a team of 10 people.
Manager Minh is attending management training on Leadership.
Thanks for the training session.
My name is Hoa, I am 20 years old.
Intern Hoa is shadowing the team.

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

  • Person là abstract vì không có “một người chung chung” nào để new. Constructor protected của nó vẫn chạy qua super(...) của lớp con.
  • work() abstract buộc mọi lớp con cụ thể phải cài đặt; introduce() là code dùng chung nằm ở lớp cha.
  • Trainable là một khả năng không gắn với cây kế thừa: thực tập sinh Intern (mình thêm vào để thấy nhánh false) là Person nhưng không Trainable. feedback() là default method nên mọi class cài đặt đều có sẵn.
  • Trong vòng lặp, introduce()/work() là đa hình động; p instanceof Trainable t (Java 16) gộp kiểm tra và ép kiểu, thay cho if (p instanceof Trainable) { Trainable t = (Trainable) p; ... }.

Góp ý của một senior cho lời giải trên:

  • instanceof rồi downcast (ép xuống kiểu con) ở đây là yêu cầu của đề để luyện cú pháp. Code thật nên nhận thẳng List<Trainable>, hoặc lọc một lần ở biên: people.stream().filter(Trainable.class::isInstance).map(Trainable.class::cast). Downcast rải rác là dấu hiệu thiếu đa hình (xem phần 3).
  • Ghép chủ đề theo chỉ số của một mảng song song (topics[i]) rất dễ lệch; gom vào một record TrainingPlan(Person person, String topic).
  • Default method là công cụ để tiến hoá một interface đã public mà không làm vỡ class cài đặt cũ; Java 8 thêm nó để Collection có stream() mà không phá mọi implementation có sẵn.

Ghi nhớ

  • Giải thích được khi nào chọn abstract class, khi nào chọn interface, và vì sao backend dùng interface nhiều hơn.
  • Biết interface có những loại method nào từ Java 8/9, và cái gì interface vẫn không có.
  • Xử lý được khi hai interface mang cùng default method, và nêu được quy tắc “class wins”.
  • Viết lại được thứ tự in ra của static block, instance block và constructor khi new Child() hai lần.
  • Giải thích được vì sao không gọi method có thể override trong constructor, và cách thay thế.

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

Junior

Abstract class có constructor không? Có bắt buộc phải có method abstract không?

Có constructor, và không bắt buộc có method abstract.

Constructor không gọi trực tiếp bằng new được, nhưng chạy khi tạo object lớp con qua super(...), để khởi tạo trạng thái chung và kiểm tra dữ liệu. Abstract class có thể không có method abstract nào, chỉ để cấm tạo instance trực tiếp. Ngược lại, class có method abstract thì bắt buộc phải là abstract, và lớp con không cài đặt hết method abstract cũng phải là abstract.

Mid

Abstract class và interface khác nhau thế nào? Khi nào dùng cái nào?

Abstract class có trạng thái, có constructor, chỉ được kế thừa một. Interface không có trạng thái instance, một class cài đặt được nhiều.

Từ Java 8 interface có thêm default/static method. Dùng abstract class khi các lớp con cùng họ cần chia sẻ code và trạng thái (ví dụ Template Method). Dùng interface để định nghĩa hợp đồng hoặc khả năng, và để làm điểm nối cho dependency injection.

Khi new Child() lần đầu, các khối static, khối instance và constructor chạy theo thứ tự nào?

Static trước instance, cha trước con, initializer trước thân constructor.

Cụ thể: static của Parent, static của Child (chỉ lần đầu nạp class), rồi field initializer và khối { } của Parent, constructor Parent, field initializer và khối { } của Child, constructor Child. Lần new thứ hai không chạy lại phần static.

Một class implement hai interface có cùng default method thì sao?

Nếu không bên nào “cụ thể hơn”, compiler báo lỗi và buộc class override; trong bản override gọi lại được A.super.hello() hoặc B.super.hello().

Nếu lớp cha của class đã có method đó thì method của class thắng, không cần làm gì (quy tắc “class wins”). Nếu một interface kế thừa interface kia thì bản của interface con thắng. Đây là cách Java cho đa kế thừa hành vi qua interface mà vẫn tránh được vấn đề kim cương về trạng thái.

Senior

Sealed interface (Java 17) giúp gì cho việc mô hình hoá domain?

Nó giới hạn tập class được cài đặt, nên mô hình hoá được kiểu “một trong các trường hợp sau” (sum type) và compiler kiểm tra switch đủ trường hợp.

Ví dụ PaymentResult = Success | Failure. Kết hợp với record và switch pattern matching, compiler sẽ kiểm tra đã xử lý đủ trường hợp chưa. Thêm một trường hợp mới thì mọi chỗ switch chưa xử lý đều bị lỗi biên dịch, thay vì lọt xuống default lúc chạy.

Vì sao gọi method có thể override từ constructor là nguy hiểm?

Constructor của lớp cha chạy trước khi field của lớp con được khởi tạo, nhưng dynamic dispatch vẫn gọi bản override của lớp con.

Bản đó đọc field còn là null/0, dẫn tới NullPointerException hoặc trạng thái sai rất khó tìm. Cách tránh: trong constructor chỉ gọi method private/static/final, dùng factory method cho bước khởi tạo phụ thuộc lớp con, và không để this lộ ra ngoài (listener, thread) trước khi constructor xong.

Từ vựng tiếng Anh

Term Phát âm Nghĩa Ví dụ câu dùng khi phỏng vấn
abstraction /æbˈstrækʃn/ trừu tượng “The service depends on an abstraction, not a concrete client.”
sealed type /siːld/ kiểu bị giới hạn lớp con “Sealed types make switch expressions exhaustive.”
initialization order /ɪˌnɪʃələˈzeɪʃn/ thứ tự khởi tạo “Static initializers run first, then the parent’s constructor, then the child’s.”
abstract method /ˈæbstrækt ˈmeθəd/ method chưa có thân “Every concrete subclass must implement the abstract method.”
default method /dɪˈfɔːlt ˈmeθəd/ method có thân trong interface “Default methods let us evolve an interface without breaking implementations.”
template method /ˈtemplət ˈmeθəd/ khung thuật toán cố định ở lớp cha “The base class defines a final template method and leaves one step abstract.”
diamond problem /ˈdaɪəmənd ˈprɑːbləm/ xung đột khi kế thừa từ hai nhánh “Java avoids the diamond problem for state by allowing only single class inheritance.”
instance initializer /ˈɪnstəns ɪˈnɪʃəlaɪzər/ khối khởi tạo instance { } “Instance initializers run after the parent constructor and before the constructor body.”

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.