Access modifier trong Java: public, private, protected

Ai được chạm vào code của bạn

Access modifier là một từ khóa (keyword) đặt trước lớp, trường, phương thức hoặc hàm khởi tạo, quyết định những ai khác được phép dùng nó. Đây là nền tảng của tính đóng gói (encapsulation): bạn giấu phần ruột phức tạp của một lớp và chỉ để lộ những phần bạn tin tưởng cho code khác gọi.

Java có bốn mức, từ mở nhất đến khóa chặt nhất: public, protected, mặc định (không có từ khóa nào) và private. Dùng đúng các mức này thì sau này bạn có thể thay đổi lớp một cách an toàn, vì không có gì bên ngoài phụ thuộc vào những chi tiết bạn chưa từng hứa giữ nguyên.

private: chỉ thấy được bên trong lớp

private là mức chặt nhất. Một thành viên private chỉ có thể được chạm vào bởi code viết bên trong cùng lớp: không phải lớp con, không phải các lớp khác trong cùng package, không ai cả. Đây là chỗ của hầu hết các trường.

public class Main {
    static class BankAccount {
        private double balance = 0;

        public void deposit(double amount) {
            if (amount > 0) {
                balance += amount;
            }
        }

        public double getBalance() {
            return balance;
        }
    }

    public static void main(String[] args) {
        BankAccount account = new BankAccount();
        account.deposit(100);
        account.deposit(-50); // ignored by the guard inside deposit
        System.out.println(account.getBalance());
    }
}

balance là private, nên cách duy nhất để thay đổi nó là qua deposit, phương thức từ chối số tiền âm. Nếu balance là public, bất kỳ code nào cũng có thể viết account.balance = -9999 và bỏ qua bước kiểm tra. Chốt chặn đó chính là lý do để giấu trường.

Thử bỏ chú thích dòng account.balance = 500; trong main và bạn sẽ gặp lỗi biên dịch: balance has private access in BankAccount.

public: thấy được ở mọi nơi

public là thái cực ngược lại: bất kỳ ai, ở bất kỳ đâu, đều dùng được thành viên đó. Những phương thức mà code khác cần gọi thường là public. Bản thân lớp cũng vậy khi nó cần được truy cập từ package khác.

public class Main {
    static class Greeter {
        public String greet(String name) {
            return "Hello, " + name + "!";
        }
    }

    public static void main(String[] args) {
        Greeter g = new Greeter();
        System.out.println(g.greet("Ada"));
    }
}

Mẫu thường gặp, đôi khi được gọi là public API của một lớp, là trường private, phương thức public. Các trường giữ trạng thái mà không ai khác nên đụng vào; các phương thức là những cánh cửa ra vào có kiểm soát. getBalance và deposit ở trên chính là như vậy.

Mặc định (package-private): không có từ khóa nào

Nếu bạn không viết modifier nào, bạn có mức truy cập mặc định, còn gọi là package-private. Thành viên đó thấy được với mọi lớp trong cùng package và vô hình với mọi thứ bên ngoài. Mức này không có từ khóa: chính việc không có từ khóa là mức truy cập.

class Invoice {       // no modifier -> visible only within this package
    int amount;       // no modifier -> package-private field
}

Điều này làm nhiều người mới học vấp: bỏ public không làm thứ gì đó thành private, mà làm nó thành package-private. Một trường bạn định giữ bí mật vẫn đọc và ghi được hoàn toàn bởi bất kỳ lớp nào tình cờ nằm trong cùng package. Nếu muốn nó thực sự bị ẩn, bạn phải viết private rõ ràng.

Mức truy cập mặc định thực sự hữu ích cho các lớp phụ trợ là chi tiết cài đặt của một package: bạn không công khai chúng ra ngoài, nhưng các lớp phối hợp với nhau trong package vẫn dùng chúng thoải mái.

protected: package cộng thêm lớp con

protected lỏng hơn mặc định một bậc. Một thành viên protected thấy được ở mọi nơi mà mức mặc định thấy được (cùng package), và cả các lớp con, kể cả lớp con nằm ở package khác. Nó được thiết kế cho những thứ bạn muốn chia sẻ với các lớp kế thừa lớp của bạn, nhưng không phải với cả thế giới.

public class Main {
    static class Animal {
        protected String name;

        Animal(String name) {
            this.name = name;
        }

        protected String sound() {
            return "...";
        }
    }

    static class Dog extends Animal {
        Dog(String name) {
            super(name);
        }

        // The subclass can read the protected field and call the protected method.
        public String describe() {
            return name + " says " + sound();
        }

        @Override
        protected String sound() {
            return "Woof";
        }
    }

    public static void main(String[] args) {
        System.out.println(new Dog("Rex").describe());
    }
}

Dog truy cập được name và sound() vì chúng là protected và Dog là lớp con. Code bên ngoài không phải lớp con và không nằm trong package vẫn không chạm được vào chúng. Hãy dùng protected khi bạn thiết kế một lớp để được kế thừa; còn lại thì ưu tiên private.

Bốn mức truy cập trong một bảng

Đây là bức tranh đầy đủ, từ chặt nhất đến mở nhất:

Một quy tắc đơn giản: bắt đầu với private và chỉ nới lỏng khi có thứ thực sự cần truy cập rộng hơn. Nới rộng quyền truy cập sau này dễ hơn nhiều so với siết lại khi code khác đã bắt đầu phụ thuộc vào một thành viên.

Modifier trên chính các lớp

Access modifier cũng áp dụng cho lớp, không chỉ cho thành viên, nhưng một lớp cấp cao nhất (không lồng trong lớp khác) chỉ có thể là public hoặc mặc định. Bạn không thể viết một lớp cấp cao nhất private hay protected.

public class Order { ... }   // reachable from any package
class LineItem { ... }       // default - only this package can see it

Một lớp cấp cao nhất public phải nằm trong tệp mang tên của nó (Order.java). Ngược lại, lớp lồng nhau có thể dùng cả bốn modifier, đó là lý do các ví dụ trên đánh dấu được lớp bên trong là private hoặc mặc định. Một điểm tinh tế: phương thức public trả về một kiểu package-private thì không hữu ích mấy với code gọi từ bên ngoài, nên hãy giữ phần công khai của bạn nhất quán.

Tiếp theo: thành viên static

Đến giờ, mọi trường và phương thức ở đây đều thuộc về một instance: bạn tạo đối tượng bằng new rồi gọi phương thức trên nó. Nhưng đôi khi một giá trị hay hành vi thuộc về cả lớp, dùng chung cho mọi instance, như bộ đếm số đối tượng đã tạo. Đó là việc của từ khóa static, và nó là nội dung tiếp theo.