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

Tìm kiếm

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

Lập trình hướng đối tượng: class, object, constructor, static và access modifier

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

Backend thật có hàng trăm khái niệm nghiệp vụ (đơn hàng, khách hàng, thanh toán…); dữ liệu và logic rải rác thì sửa một chỗ hỏng ba chỗ. Lập trình hướng đối tượng (OOP) gom dữ liệu và hành vi liên quan vào một object và đặt ranh giới rõ giữa các phần. Bài này là phần nền: class, object, constructor, static, package và access modifier; chỉ cần biết cú pháp ở Java cơ bản.

Các phần sau của cụm: object bất biến, equals/hashCode và final ở phần 2; kế thừa, đóng gói, đa hình ở phần 3; trừu tượng và thứ tự khởi tạo ở phần 4; UML và quan hệ giữa class ở phần 5; wrapper, BigDecimal, String ở phần 6.

1. Object và class

Ý chính: class là bản thiết kế (field + method), object là một thực thể cụ thể tạo từ class bằng new. Mỗi object là một instance của class.

Object có ba thứ:

  • Trạng thái (state): field. Ví dụ con vật có tên, tuổi, cân nặng.
  • Hành vi (behavior): method. Ví dụ con vật biết ăn, kêu, ngủ.
  • Định danh (identity): hai con chó cùng tên, cùng tuổi vẫn là hai object khác nhau. Slide không nhắc ý này, nhưng đây chính là lý do == khác equals.

Một khuôn bánh đúc ra hàng triệu cái bánh; một class tạo ra bao nhiêu object cũng được.

class Animal {
    String name;          // field: trạng thái
    int age;

    void eat() {          // method: hành vi
        System.out.println(name + " đang ăn");
    }
}

Slide viết “mọi thứ trong Java đều nằm trong class”. Chính xác hơn: mọi code nằm trong một kiểu (type): class, interface, enum, record. Từ Java 25, compact source file cho viết void main() không cần khai báo class, nhưng compiler vẫn ngầm tạo một class.

Constructor

Ý chính: constructor là “hàm” đặc biệt chỉ để khởi tạo object: trùng tên class, không có kiểu trả về, chỉ chạy qua new. Việc của nó là làm object hợp lệ ngay từ khi sinh ra.

  • Không có kiểu trả về, kể cả void. Viết void Animal() là ra một method thường, không phải constructor, bug khá khó thấy.
  • Chỉ được gọi qua new, hoặc this(...)/super(...) từ constructor khác.
class Animal {
    private final String name;
    private int age;

    Animal(String name) {             // overload constructor
        this(name, 0);                // gọi constructor khác: constructor chaining
    }

    Animal(String name, int age) {
        if (age < 0) throw new IllegalArgumentException("age must be >= 0");
        this.name = name;             // this.name là field, name là tham số
        this.age = age;
    }

    void showInfo() {
        System.out.printf("Tên: %s - Tuổi: %d%n", name, age);
    }
}

Animal dog = new Animal("Mực", 2);    // khai báo + tạo
Animal cat;                           // chỉ khai báo, cat chưa trỏ vào đâu
cat = new Animal("Mướp");             // tạo sau
dog.showInfo();                       // truy cập qua dấu chấm
  • this phân biệt field với tham số trùng tên.
  • Một class có thể có nhiều constructor khác danh sách tham số. Constructor gọi constructor khác qua this(...) gọi là constructor chaining: kiểm tra dữ liệu chỉ viết một chỗ.
  • Không viết constructor nào thì compiler tự thêm default constructor không tham số. Viết một constructor bất kỳ là nó biến mất, lỗi hay gặp khi JPA, Jackson cần constructor không tham số.
  • Invariant là ràng buộc luôn phải đúng (ví dụ tuổi ≥ 0). Constructor kiểm tra nó, đừng để object nửa vời rồi trông chờ ai đó gọi setter cho đủ.

new làm theo thứ tự: cấp phát vùng nhớ trên heap (vùng nhớ chứa object), gán giá trị mặc định cho field, chạy khối khởi tạo và super(...), chạy thân constructor, rồi trả về tham chiếu.

2. static: thuộc về class, không thuộc về object

Ý chính: thành viên static chỉ có một bản, dùng chung cho mọi instance, và không có this. Dùng khi giá trị hay hành vi không phụ thuộc trạng thái của từng object.

flowchart TB
  C["class Animal<br/>static int count = 3"]
  A1["dog1<br/>name=Mực"]
  A2["dog2<br/>name=Vàng"]
  A3["dog3<br/>name=Đốm"]
  A1 -. chung .-> C
  A2 -. chung .-> C
  A3 -. chung .-> C
  • Biến static truy cập qua ClassName.variable; method static gọi qua ClassName.method().
  • Method static không truy cập được field của instance.
  • Thành viên static cũng có access modifier như mọi thành viên khác.

Slide tăng Animal.count++ ở bên ngoài sau mỗi lần new: dễ quên và lộ chi tiết nội bộ. Nên để class tự đếm trong constructor:

class Animal {
    private static int count = 0;
    private final String name;

    Animal(String name) {
        this.name = name;
        count++;                      // chưa thread-safe; xem phần senior bên dưới
    }

    static int count() { return count; }
}

Slide lấy ví dụ static double chuVi(Circle c) nhận vào một hình tròn. Chạy được, nhưng hướng đối tượng hơn là để hình tròn tự tính: circle.perimeter(), đúng ý đóng gói ở phần 3. Và dùng Math.PI thay cho 3.14.

3. Package và import

Ý chính: package là thư mục nhóm các class liên quan và tạo namespace (không gian tên), để hai class cùng tên ở hai package không đụng nhau (java.util.Date và java.sql.Date). Dùng class ở package khác thì phải import.

// File: src/main/java/com/vinhnq/shape/Circle.java
package com.vinhnq.shape;

public class Circle { ... }
// File ở package khác
package com.vinhnq.app;

import com.vinhnq.shape.Circle;       // import một class
import java.util.*;                   // import cả package (không gồm package con)

public class App {
    Circle c = new Circle(2);
}
  • Class cùng package dùng lẫn nhau không cần import. java.lang (String, Math…) luôn được import sẵn.
  • Tên package: chữ thường, tên miền đảo ngược (com.company.project.module). Slide dùng Shape viết hoa, sai quy ước.
Quy tắc file và import static
  • Lệnh package phải là lệnh đầu tiên của file (chỉ comment được đứng trước). Mỗi file thuộc đúng một package.
  • Thư mục phải khớp tên package: com.vinhnq.shape.Circle nằm ở .../com/vinhnq/shape/Circle.java. Compiler và IDE dựa vào quy ước này để tìm class.
  • import static nhập thành viên static để gọi không cần tên class: import static java.lang.Math.PI; rồi viết PI * r * r. Hợp với hằng và assertion trong test (assertThat(...)); lạm dụng thì người đọc không biết method đến từ đâu.

4. Access modifier

Ý chính: access modifier quy định ai thấy được một field, method, constructor. Bắt đầu từ mức hẹp nhất (private) và chỉ mở khi thật cần, vì thứ gì đã public là thành hợp đồng với bên ngoài.

Modifier Trong class Cùng package Subclass ở package khác Mọi nơi
private ✓
(default, package-private) ✓ ✓
protected ✓ ✓ ✓
public ✓ ✓ ✓ ✓
  • Class top-level chỉ được là public hoặc default; nested class (class lồng trong class khác) dùng được cả bốn.
  • Method private chỉ gọi được từ trong class khai báo nó. (Slide về method ghi “class định nghĩa thuộc tính”, lỗi chép từ slide về thuộc tính.)
  • Đổi thứ đã public là phải lo tương thích ngược.
  • Từ Java 9, module system (module-info.java) thêm một tầng: package public mà không được exports thì module khác vẫn không dùng được.

Bài tập

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

1. Class Circle: bán kính, chu vi, diện tích

public final class Circle {
    private final double radius;

    public Circle(double radius) {
        if (radius < 0) throw new IllegalArgumentException("radius must be >= 0");
        this.radius = radius;
    }

    public double perimeter() { return 2 * Math.PI * radius; }
    public double area() { return Math.PI * radius * radius; }

    public static void main(String[] args) {
        Circle c = new Circle(5.5);
        System.out.printf("Chu vi: %.2f, diện tích: %.2f%n", c.perimeter(), c.area()); // 34.56, 95.03
    }
}

Hành vi nằm trong object (đóng gói), object bất biến, dữ liệu kiểm tra ngay trong constructor.

2. Class Student

Yêu cầu: sinh viên có họ tên, địa chỉ, email, số điện thoại, mã sinh viên (gồm chữ và số); có các hành động đi học, làm bài tập, nộp học phí, làm bài kiểm tra, in thông tin; có constructor có và không có tham số, getter và setter; tạo vài sinh viên rồi gọi các hành động.

Lời giải Bài 2: class Student
public class Student {
    private static final Pattern CODE = Pattern.compile("[A-Z]\\d{2}[A-Z]{4}\\d{3}");   // ví dụ B22DCCN175
    private static final Pattern EMAIL = Pattern.compile("^[^@\\s]+@[^@\\s]+\\.[^@\\s]+$");

    private String code;
    private String fullName;
    private String address;
    private String email;
    private String phone;
    private boolean tuitionPaid;

    public Student() { }    // đề yêu cầu có; framework như Jackson/JPA cũng cần constructor này

    public Student(String code, String fullName, String address, String email, String phone) {
        setCode(code);
        setFullName(fullName);
        this.address = address;
        setEmail(email);
        this.phone = phone;
    }

    public void attendClass(String subject) { System.out.println(fullName + " đi học môn " + subject); }
    public void doHomework(String title)    { System.out.println(fullName + " làm bài: " + title); }
    public void takeExam(String subject)    { System.out.println(fullName + " kiểm tra môn " + subject); }

    public void payTuition(BigDecimal amount) {
        if (amount.signum() <= 0) throw new IllegalArgumentException("Số tiền phải > 0");
        tuitionPaid = true;
        System.out.println(fullName + " đã nộp " + amount);
    }

    public String getCode() { return code; }
    public void setCode(String code) {
        if (code == null || !CODE.matcher(code).matches())
            throw new IllegalArgumentException("Mã sinh viên không hợp lệ: " + code);
        this.code = code;
    }
    public String getFullName() { return fullName; }
    public void setFullName(String fullName) {
        if (fullName == null || fullName.isBlank()) throw new IllegalArgumentException("Thiếu họ tên");
        this.fullName = fullName.strip();
    }
    public String getEmail() { return email; }
    public void setEmail(String email) {
        if (email == null || !EMAIL.matcher(email).matches())
            throw new IllegalArgumentException("Email không hợp lệ: " + email);
        this.email = email;
    }
    public String getAddress() { return address; }
    public void setAddress(String address) { this.address = address; }
    public String getPhone() { return phone; }
    public void setPhone(String phone) { this.phone = phone; }
    public boolean isTuitionPaid() { return tuitionPaid; }   // không có setter: chỉ đổi qua payTuition

    @Override public String toString() {
        return "Student[%s, %s, %s, %s, %s, đã nộp học phí=%b]"
                .formatted(code, fullName, address, email, phone, tuitionPaid);
    }

    public static void main(String[] args) {
        Student s = new Student("B22DCCN175", "Nguyễn Văn A", "Hà Nội", "a@example.com", "0900000000");
        s.attendClass("Java");
        s.doHomework("OOP");
        s.payTuition(new BigDecimal("15000000"));
        s.takeExam("Java");
        System.out.println(s);
    }
}

Đề bắt có setter cho mọi field, nhưng mình vẫn đặt kiểm tra dữ liệu trong setter. tuitionPaid không cho đặt từ ngoài, vì trạng thái đó chỉ đổi qua hành vi payTuition. Đó là đóng gói thật sự, không chỉ là getter/setter.

3. Lab 04: class Employee đóng gói trong package model

Đề (diễn giải): tạo package lab04 với hai package con: model chứa class Employee, package còn lại chứa main. Employee có các field private: tên, tuổi, phòng ban, lương, công ty; một constructor nhận 4 tham số (không có công ty), getter/setter, một method in thông tin và một method tăng lương 15% khi đầu vào hợp lệ. Trong main, tạo hai nhân viên, in thông tin, tăng lương rồi in lại. Kèm bài thử access modifier: từ một package khác, truy cập lần lượt field private, default, protected, public để xem dòng nào biên dịch được.

Kết quả bài thử access modifier, từ class Main ở package lab04.app (khác package, không phải lớp con) truy cập field của một Employee khai báo đủ bốn mức:

Field Biên dịch được? Thông báo của javac
private String name Không name has private access in Employee
int age (default) Không age is not public in Employee; cannot be accessed from outside package
protected String department Không department has protected access in Employee
public double salary Có
Lời giải Lab 04: Employee, Main và output

Hai file, biên dịch bằng javac -d out $(find src -name '*.java') rồi chạy java -cp out lab04.app.Main.

// src/lab04/model/Employee.java
package lab04.model;

import java.math.BigDecimal;
import java.math.RoundingMode;
import java.util.Objects;

public final class Employee {
    public static final String DEFAULT_COMPANY = "ABC Corporation";
    private static final BigDecimal HUNDRED = BigDecimal.valueOf(100);

    private String name;
    private int age;
    private String department;
    private BigDecimal salary;
    private String company;

    public Employee(String name, int age, String department, BigDecimal salary) {
        this(name, age, department, salary, DEFAULT_COMPANY);
    }

    public Employee(String name, int age, String department, BigDecimal salary, String company) {
        setName(name);
        setAge(age);
        setDepartment(department);
        if (salary == null || salary.signum() < 0) throw new IllegalArgumentException("salary must be >= 0");
        this.salary = salary;
        setCompany(company);
    }

    /** Tăng lương theo phần trăm, ví dụ raiseSalary(15) là +15%. */
    public void raiseSalary(double percent) {
        if (percent <= 0) throw new IllegalArgumentException("percent must be > 0, got " + percent);
        BigDecimal factor = BigDecimal.ONE.add(BigDecimal.valueOf(percent).divide(HUNDRED));
        salary = salary.multiply(factor).setScale(2, RoundingMode.HALF_UP);
    }

    public void showInfo() {
        System.out.printf("Name: %s%nAge: %d%nDepartment: %s%nSalary: %s%nCompany: %s%n-------------------------%n",
                name, age, department, salary.toPlainString(), company);
    }

    public String getName() { return name; }
    public void setName(String name) {
        if (name == null || name.isBlank()) throw new IllegalArgumentException("name is required");
        this.name = name.strip();
    }
    public int getAge() { return age; }
    public void setAge(int age) {
        if (age < 18 || age > 70) throw new IllegalArgumentException("age out of range: " + age);
        this.age = age;
    }
    public String getDepartment() { return department; }
    public void setDepartment(String department) { this.department = Objects.requireNonNull(department, "department"); }
    public BigDecimal getSalary() { return salary; }   // không có setSalary: lương chỉ đổi qua raiseSalary
    public String getCompany() { return company; }
    public void setCompany(String company) { this.company = Objects.requireNonNull(company, "company"); }
}
// src/lab04/app/Main.java
package lab04.app;

import java.math.BigDecimal;
import java.util.List;
import lab04.model.Employee;

public class Main {
    public static void main(String[] args) {
        List<Employee> staff = List.of(
                new Employee("Lan", 25, "Sales", new BigDecimal("8000")),
                new Employee("Minh", 30, "IT", new BigDecimal("10000")));

        System.out.println("== BEFORE RAISE ==");
        staff.forEach(Employee::showInfo);

        staff.forEach(e -> e.raiseSalary(15));

        System.out.println("== AFTER RAISE ==");
        staff.forEach(Employee::showInfo);

        try {
            staff.get(0).raiseSalary(-5);
        } catch (IllegalArgumentException ex) {
            System.out.println("Rejected: " + ex.getMessage());
        }
        // staff.get(0).name;     // lỗi biên dịch: name has private access in lab04.model.Employee
        // staff.get(0).salary;   // lỗi biên dịch tương tự
    }
}
== BEFORE RAISE ==
Name: Lan
Age: 25
Department: Sales
Salary: 8000
Company: ABC Corporation
-------------------------
Name: Minh
Age: 30
Department: IT
Salary: 10000
Company: ABC Corporation
-------------------------
== AFTER RAISE ==
Name: Lan
...
Salary: 9200.00
...
Name: Minh
...
Salary: 11500.00
...
Rejected: percent must be > 0, got -5.0

Vì sao viết vậy:

  • Constructor chaining cho công ty mặc định: đề cho constructor 4 tham số nhưng class có 5 field, output mẫu cho mọi người ở “ABC Corporation”. Constructor 4 tham số gọi this(..., DEFAULT_COMPANY). Nếu giá trị luôn giống nhau cho mọi object thì nên là hằng static final; ở đây công ty có thể khác sau này, nên vẫn là field instance có giá trị mặc định.
  • Đổi tên tham số: đề đặt raiseSalary(double amount) nhưng lại “tăng 15%”, tên nói một đằng, hành vi một nẻo. Mình đổi thành raiseSalary(double percent) và gọi với 15. Tên tham số là một phần của API.
  • Đầu vào sai thì ném lỗi: IllegalArgumentException thay vì lặng lẽ bỏ qua, người gọi biết ngay.
  • Không có setSalary: lương chỉ đổi qua raiseSalary, đó mới là đóng gói (xem phần 3). Tiền dùng BigDecimal, làm tròn 2 chữ số.
  • Constructor gọi setter để dùng chung kiểm tra: chỉ an toàn vì class là final. Nếu lớp con override được setter, constructor sẽ gọi bản của lớp con khi lớp con chưa khởi tạo xong (xem phần 4).
Một senior sẽ sửa thêm gì ở Lab 04
  • Tuổi nên tính từ LocalDate birthDate: lưu số tuổi thì sang năm là sai.
  • Công ty nên là tham chiếu tới entity Company, không phải chuỗi.
  • Tăng lương là nghiệp vụ cần audit (ai duyệt, khi nào, mức cũ và mới): thuộc về một service và lưu lịch sử, không chỉ ghi đè một field.
  • showInfo() in thẳng ra console nên đổi thành toString() hoặc trả về DTO để test được.

Ghi nhớ

  • Phân biệt được class, object, instance, và giải thích vì sao định danh làm == khác equals.
  • Biết khi nào default constructor biến mất và vì sao JPA/Jackson cần constructor không tham số.
  • Giải thích được khi nào nên dùng static và vì sao static mutable state nguy hiểm trong Spring.
  • Vẽ lại được bảng bốn access modifier, và nói được hai bẫy của protected (mở cả package; ở package khác chỉ qua tham chiếu kiểu lớp con).
  • Biết vì sao constructor gọi setter chỉ an toàn khi class là final.

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

Junior

Class và object khác nhau thế nào?

Class là bản thiết kế, object là một instance cụ thể tạo từ class bằng new.

Class định nghĩa field và method. Object có trạng thái riêng nằm trên heap. Một class tạo ra được nhiều object.

Constructor khác method thường ở những điểm nào? Default constructor xuất hiện khi nào?

Constructor trùng tên class, không có kiểu trả về, chỉ chạy khi tạo object. Default constructor chỉ được sinh khi class không khai báo constructor nào.

Đã viết một constructor có tham số mà vẫn cần constructor không tham số thì phải tự viết thêm.

Bốn access modifier trong Java là gì?

private (trong class), default/package-private (cùng package), protected (cùng package và lớp con), public (mọi nơi).

Class top-level chỉ được là public hoặc default.

Method static gọi trực tiếp được method instance không? Vì sao main là static?

Không: method static không gắn với object nên không có this; muốn gọi method instance phải có object (new App().run()). main là static vì JVM gọi nó khi chưa có object nào.

Chiều ngược lại thoải mái: method instance gọi method static bình thường. Biến static chỉ có một bản cho cả class, khởi tạo một lần khi class được nạp.

Mid

protected cho phép truy cập từ đâu? Lớp con ở package khác đọc field protected qua một biến kiểu lớp cha được không?

protected = quyền package-private cộng lớp con ở package khác. Qua biến kiểu lớp cha thì không được.

  • Trong cùng package, mọi class đều đọc được như mức default.
  • Lớp con ở package khác chỉ truy cập qua this hoặc tham chiếu có kiểu chính lớp con; qua Parent other là lỗi has protected access.
  • Vì mở cả package, protected rộng hơn nhiều người nghĩ; thường để field private và chỉ mở method protected cho lớp con.

Senior

Static mutable state gây ra vấn đề gì trong một ứng dụng Spring?

Đó là trạng thái toàn cục dùng chung giữa mọi request và thread, nên dễ race condition, khó test và rò bộ nhớ.

  • Dữ liệu rò từ test này sang test khác, không mock được.
  • Map cứ lớn dần gây rò bộ nhớ; trong môi trường nhiều classloader có thể không giải phóng được.
  • Thay bằng bean singleton do container quản lý, cache có giới hạn (Caffeine), hoặc kho ngoài như Redis, database.

Từ vựng tiếng Anh

Term Phát âm Nghĩa Ví dụ câu dùng khi phỏng vấn
instance /ˈɪnstəns/ thể hiện cụ thể của một class “Each instance has its own copy of the instance fields.”
constructor chaining /kənˈstrʌktər ˈtʃeɪnɪŋ/ constructor gọi lẫn nhau qua this()/super() “Constructor chaining keeps validation in one place.”
invariant /ɪnˈveriənt/ ràng buộc luôn đúng “The constructor enforces the invariant that the denominator is never zero.”
access modifier /ˈækses ˈmɑːdɪfaɪər/ phạm vi truy cập “I start with the most restrictive access modifier and widen it only when needed.”
package-private phạm vi trong package “Package-private classes keep implementation details out of the public API.”
namespace /ˈneɪmspeɪs/ không gian tên “Packages give each class a namespace, so two classes can share a simple name.”
static member /ˈstætɪk ˈmembər/ thành viên thuộc về class “A static member is shared by all instances and has no this.”
default constructor /dɪˈfɔːlt kənˈstrʌktər/ constructor mặc định do compiler sinh “Once you declare any constructor, the default constructor disappears.”

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. 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.