Biểu tượng chim cắt của Kestrel Exams KESTREL EXAMSLUYỆN TẬP ĐỂ ĐẠT
Bản dịch này do AI thực hiện và chưa được người bản ngữ kiểm duyệt. Nếu có khác biệt, bản tiếng Anh là bản chính. Mã nguồn được giữ nguyên bằng tiếng Anh. Ứng dụng luyện tập và tài liệu cho các kỳ thi chứng chỉ của Hoa Kỳ chỉ có bằng tiếng Anh. Read in English
JavaĐọc trong 19 phútMã đã được kiểm chứng

Phạm vi, stack và heap: biến sống ở đâu, và trong bao lâu

Mỗi biến có một vùng mã nơi tên của nó có tác dụng và một khoảng thời gian nó tồn tại. Bài hướng dẫn này xây một lớp máy bán hàng tự động để cho thấy cả hai, rồi theo các lời gọi phương thức của nó vào ngăn xếp lời gọi và các đối tượng của nó vào heap. Mọi đoạn mã đều đã được biên dịch và chạy trên OpenJDK 21.

Luyện tập chủ đề này trong ứng dụng miễn phí →Tất cả bài hướng dẫn Java

Một cái máy nhớ, một lần bấm nút quên#

Hãy hình dung một máy bán hàng tự động ở hành lang. Màn hình của nó hiện số tiền bạn đã nạp: bỏ vào một đồng 25 xu, đi tìm thêm đồng khác, và 25 xu vẫn còn đó khi bạn quay lại. Bấm một nút và, vào ngày thuận lợi, chiếc máy tự tính tiền thối trên một tờ nháp bên trong, nhả các đồng xu ra, và vứt tờ nháp đi.

Biến trong Java cũng có hai loại như vậy. Hãy hỏi với mỗi biến: tôi có thể dùng tên của nó ở đâu trong mã? Vùng đó là phạm vi (scope) của nó. Khi nào, trong lúc chương trình chạy, nó tồn tại? Khoảng thời gian đó là thời gian sống (lifetime) của nó. Rồi hãy hỏi nó nằm ở đâu trong bộ nhớ. Một lớp, VendingMachine, lớn dần qua toàn bộ bài hướng dẫn này, và mỗi bước đều cho thấy đầu ra thật.

Phạm vi: các dấu ngoặc nhọn quyết định#

Bạn đã biết khai báo một biến là một kiểu rồi đến một tên: int credit = 100;. Ý tưởng mới duy nhất là một khai báo có tầm với. Một cặp dấu ngoặc nhọn, { và }, đánh dấu một khối (block). Một biến được khai báo bên trong một khối có thể được dùng từ khai báo của nó xuống đến dấu ngoặc nhọn đóng của khối đó, và không ở đâu khác. Đây là quy tắc khối (block rule).

Phiên bản đầu của máy nằm trong main. Nó bán một lon 75 xu và tính tiền thối bên trong một khối if.

Hãy thử trước

Dòng cuối in change, được khai báo bên trong khối if. Nó có biên dịch được không? Nếu không, trình biên dịch sẽ chỉ vào dòng nào?

Xem đáp án

Không. change ngừng tồn tại ở dấu ngoặc nhọn đóng của if. Trình biên dịch chỉ vào dòng 9, dòng dùng tên đó.

VendingMachine.java
public class VendingMachine {
    public static void main(String[] args) {
        int credit = 100;                    // cents inserted so far
        int price = 75;                      // one can
        if (credit >= price) {
            int change = credit - price;     // change is born here...
            System.out.println("Vend! Change: " + change);
        }                                    // ...and its scope ends here
        System.out.println("Coins returned: " + change);
    }
}
VendingMachine.java:9: error: cannot find symbol
        System.out.println("Coins returned: " + change);
                                                ^
  symbol:   variable change
  location: class VendingMachine
1 error

cannot find symbol nghĩa là “tôi không biết tên này ở đây”, và dấu mũ, ^, chỉ vào chỗ dùng. Biến này có thật; nó chỉ nằm ngoài phạm vi. Cách sửa là khai báo change trong khối riêng của main, trước if, và chỉ gán bên trong:

VendingMachine.java
public class VendingMachine {
    public static void main(String[] args) {
        int credit = 100;
        int price = 75;
        int change = 0;                      // declared in main's block
        if (credit >= price) {
            change = credit - price;         // assigned, not declared again
            System.out.println("Vend! Change: " + change);
        }
        System.out.println("Coins returned: " + change);
    }
}
Vend! Change: 25
Coins returned: 25

Hãy để ý không có int bên trong if: một khai báo thứ hai sẽ thất bại với variable change is already defined in method main(String[]). Và change bắt đầu bằng 0 vì một biến cần có giá trị trước khi được đọc, và if có thể bị bỏ qua (chỉ int change; thì thất bại với variable change might not have been initialized). Quy ước thông thường là khai báo mỗi biến trong khối nhỏ nhất cần nó, để ít dòng hơn có thể dùng sai nó. Khai báo mọi thứ ở đầu phương thức cũng được.

Kiểm tra bẫy: dấu ngoặc đóng nào kết thúc nó?

Với mỗi lần dùng một biến, hãy tìm khai báo của nó và theo xuống đến dấu ngoặc nhọn đóng của khối đó. Một biến được khai báo trong ngoặc đơn của vòng lặp for thuộc về vòng lặp. Vì vậy trong for (int i = 0; i < 3; i++) { ... }, tên i biến mất sau vòng lặp. Các khối lồng nhau: một khối bên trong có thể dùng biến của khối bên ngoài, không bao giờ ngược lại.

Nếu bạn biết Python, điều này là mới: Python giữ một biến tạo trong một if cho đến hết hàm. Java kết thúc nó ở dấu ngoặc nhọn đóng.

Tham số và biến cục bộ thuộc về một phương thức#

Một cái máy thật là một đối tượng, nên VendingMachine trở thành một lớp. Số tiền đã nạp và số hàng trong kho (số lon bên trong) trở thành các biến thể hiện (instance variables), còn gọi là các trường (fields): được khai báo trong lớp nhưng bên ngoài mọi phương thức, nên mỗi đối tượng máy có bản riêng. Một tham số (parameter), như quarters trong insertCoins(int quarters, int dimes), được điền bởi mỗi lời gọi và nằm trong phạm vi toàn bộ thân phương thức của nó. Một biến cục bộ (local variable), như count, được khai báo bên trong một phương thức và tuân theo quy tắc khối.

Hãy thử trước

insertCoins và restock mỗi cái khai báo một biến cục bộ tên count. main nạp 3 đồng 25 xu và 1 đồng 10 xu, nhập kho 2 thùng 6 lon, rồi nạp 2 đồng 10 xu. Ở dòng cuối, count là 2 hay 6? credit là 20 hay 105?

Xem đáp án

count là 2 và credit là 105. Mỗi lời gọi có một count mới; credit là một trường, nên nó giữ giá trị giữa các lời gọi.

VendingMachine.java
public class VendingMachine {
    private int credit;                      // cents inserted, not yet spent
    private int stock;                       // cans inside

    public VendingMachine(int stock) {
        this.stock = stock;
    }

    public void insertCoins(int quarters, int dimes) {
        int count = quarters + dimes;        // coins in this handful
        credit = credit + quarters * 25 + dimes * 10;
        System.out.println(count + " coins in, credit " + credit);
    }

    public void restock(int boxes) {
        int count = boxes * 6;               // cans added this time
        stock = stock + count;
        System.out.println(count + " cans added, stock " + stock);
    }

    public static void main(String[] args) {
        VendingMachine lobby = new VendingMachine(4);
        lobby.insertCoins(3, 1);
        lobby.restock(2);
        lobby.insertCoins(0, 2);
    }
}
4 coins in, credit 85
12 cans added, stock 16
2 coins in, credit 105

Điều này có hợp lý không? Hai đồng 10 xu là 2 đồng, và 85 cộng 20 xu là 105. Hai biến count không bao giờ gặp nhau, nên bạn có thể đặt tên một biến cục bộ theo ý nghĩa của nó trong phương thức này mà không cần kiểm tra các phương thức khác. Tham số hoạt động tương tự: restock dùng quarters sẽ gặp cannot find symbol, và main cũng vậy.

Biến thể hiện: nằm trong phạm vi toàn bộ lớp#

Các phương thức dùng credit và stock, mà không ai truyền chúng vào. Phạm vi của một trường là toàn bộ lớp, bất kể nó được viết ở đâu trong lớp: một trường khai báo ở tận cuối vẫn dùng được trong một phương thức ở phía trên. Trong mọi hàm tạo và mọi phương thức thể hiện (phương thức không có static), tên đơn thuần credit nghĩa là số tiền đã nạp của đối tượng này.

Điều bất tiện là một phương thức static, như main. Nó chạy mà không có máy cụ thể nào, nên credit đơn thuần bên trong nó thất bại với non-static variable credit cannot be referenced from a static context. Hãy để ý lỗi không phải là cannot find symbol: tên nằm trong phạm vi, nhưng Java hỏi số tiền của máy nào. Hãy chỉ một máy qua một tham chiếu, như trong lobby.getCredit(). Bài hướng dẫn về phương thức cho thấy cùng lỗi đó với một phương thức.

Điều này giải đáp một bí ẩn cũ: this.stock = stock; trong hàm tạo. Hai biến tên stock cùng nằm trong phạm vi ở đó, trường và tham số, và Java chọn cái gần nhất, tham số. Đó là che khuất (shadowing). this nghĩa là “đối tượng mà phương thức này được gọi trên”, nên this.stock với tới trường. Bài hướng dẫn viết lớp cho thấy điều gì sai nếu thiếu nó.

Phạm vi là ở đâu, thời gian sống là khi nào#

Phạm vi nói về văn bản: những dòng nào được nhắc đến một tên. Thời gian sống nói về thời gian: từ khi biến được tạo, trong lúc chương trình chạy, đến khi nó bị hủy. Bạn vừa thấy cả hai: count được sinh ra mới ở mỗi lời gọi và mất đi sau đó, còn credit sống tiếp trong máy.

LoạiPhạm vi: nơi tên có tác dụngThời gian sống: khi nó tồn tại
Biến cục bộtừ khai báo của nó đến dấu ngoặc nhọn đóng của khốitừ khi khai báo của nó chạy cho đến khi khối của nó kết thúc
Tham số (parameter)toàn bộ thân phương thứctừ đầu lời gọi cho đến khi phương thức trả về
Biến thể hiệntoàn bộ lớp; trong một phương thức static, chỉ qua một đối tượng, như trong lobby.getCredit()chừng nào đối tượng sở hữu nó còn tồn tại
Trường statictoàn bộ lớp, kể cả các phương thức staticmột bản cho cả lớp, trong khi lớp được nạp (trong một chương trình nhỏ, là toàn bộ lần chạy)

Hai thứ này có thể tách rời. Chẳng bao lâu buy sẽ gọi makeChange. Trong khi makeChange chạy, biến cục bộ change của buy nằm ngoài phạm vi, vì makeChange không thể gọi tên nó, nhưng nó vẫn còn sống, chờ buy tiếp tục. Ngăn xếp lời gọi giải thích cách thức.

Ngăn xếp lời gọi: một khung cho mỗi lời gọi#

Hãy hình dung những chiếc khay ở căng tin: khay mới đặt lên trên, và chỉ khay trên cùng được lấy ra. Mỗi lời gọi phương thức có một khung ngăn xếp (stack frame), một khối bộ nhớ giữ các tham số và biến cục bộ của lời gọi đó. Một lời gọi đẩy (push) khung của nó lên ngăn xếp lời gọi (call stack). Trả về lấy ra (pop) nó, và các biến cục bộ của nó mất đi. Khung của bên gọi chờ ở bên dưới, không bị động đến, và tiếp tục.

Giờ buy gọi makeChange để đếm các đồng xu cùng một cỡ. Mỗi println được thụt vào theo độ sâu lời gọi, nên đầu ra vẽ ngăn xếp theo chiều ngang. Lần mua thứ hai cố ý yêu cầu các đồng xu trị giá 0 xu, để làm lời gọi sâu nhất thất bại.

Hãy thử trước

Trong khi makeChange chạy, có bao nhiêu khung trên ngăn xếp, và khung nào ở trên cùng?

Xem đáp án

Ba: main ở dưới cùng, rồi buy, rồi makeChange ở trên cùng. Hai khung bên dưới đang tạm dừng, chờ đợi.

VendingMachine.java
public class VendingMachine {
    private int credit;
    private int stock;

    public VendingMachine(int stock) {
        this.stock = stock;
    }

    public void insertCoins(int quarters, int dimes) {
        credit = credit + quarters * 25 + dimes * 10;
    }

    public void buy(int price, int coin) {
        System.out.println("  buy(" + price + ", " + coin + ") starts");
        int change = credit - price;
        credit = 0;
        stock--;
        int coins = makeChange(change, coin);
        System.out.println("  buy: drop " + coins + " coins, change was " + change);
        System.out.println("  buy returns");
    }

    public int makeChange(int cents, int coin) {
        System.out.println("    makeChange(" + cents + ", " + coin + ") starts");
        int count = cents / coin;
        System.out.println("    makeChange returns " + count);
        return count;
    }

    public static void main(String[] args) {
        System.out.println("main starts");
        VendingMachine lobby = new VendingMachine(4);
        lobby.insertCoins(5, 0);
        lobby.buy(75, 25);
        lobby.insertCoins(5, 0);
        lobby.buy(75, 0);                    // a coin worth 0 cents: fails on purpose
        System.out.println("main ends");
    }
}
main starts
  buy(75, 25) starts
    makeChange(50, 25) starts
    makeChange returns 2
  buy: drop 2 coins, change was 50
  buy returns
  buy(75, 0) starts
    makeChange(50, 0) starts
Exception in thread "main" java.lang.ArithmeticException: / by zero
	at VendingMachine.makeChange(VendingMachine.java:25)
	at VendingMachine.buy(VendingMachine.java:18)
	at VendingMachine.main(VendingMachine.java:36)

Ở lần mua đầu, makeChange trả về 2, khung của nó bị lấy ra, và buy tiếp tục với change vẫn giữ 50. Ngay trước lần trả về đó, ngăn xếp trông như thế này, trên cùng trước:

Khung (frame)Chứa gì
makeChange (đang chạy)cents = 50, coin = 25, count = 2, this
buy (tạm dừng)price = 75, coin = 25, change = 50, coins (chưa được gán), this
main (tạm dừng)args, lobby

this là một tham số ẩn mà mọi phương thức thể hiện đều có: một tham chiếu đến đối tượng mà nó được gọi trên, nhờ đó buy với tới credit. Hãy để ý hai biến coin. Mỗi tham số là một bản sao của đối số của nó, trong khung riêng, đó là lý do một phương thức không thể thay đổi biến của bên gọi (xem điều một phương thức không thể thay đổi).

Lần mua thứ hai bị lỗi: 50 / 0 là phép chia số nguyên cho không, mà Java từ chối bằng một ArithmeticException. Không gì bắt nó (bài hướng dẫn về ngoại lệ cho thấy cách làm), nên Java in một stack trace: các khung trên ngăn xếp vào thời điểm đó, trên cùng trước, mỗi khung kèm dòng nó đã đạt tới. makeChange ở trên cùng tại dòng 25, buy chờ tại dòng 18, và main ở dưới cùng tại dòng 36. main ends không bao giờ được in: ngoại lệ không được bắt đã lấy ra mọi khung mà không cho nó kết thúc. Bài hướng dẫn về đệ quy chồng nhiều khung của cùng một phương thức.

Kiểm tra bẫy: phép chia này có an toàn không?

Với mỗi phép chia: vế phải có thể bằng 0 không? Phép chia số nguyên cho 0 dừng chương trình; phép chia dấu phẩy động cho 0 cho Infinity.

Kiểm tra bẫy: khung nào ở trên cùng?

Phương thức đang chạy lúc này luôn là khung trên cùng, cái được gọi gần đây nhất. main ở dưới cùng, vì nó được gọi đầu tiên. “main ở trên cùng” là một đáp án sai được ưa chuộng.

Thu nhỏ về trường hợp nhỏ nhất. Nếu main không gọi gì, ngăn xếp có một khung. Khi main trả về, ngăn xếp rỗng và chương trình kết thúc.

Đối tượng sống trên heap#

Các đối tượng thường phải sống lâu hơn lời gọi đã tạo ra chúng. Vì vậy mọi đối tượng, dù tạo bằng new, một mảng hay một literal String, đều sống trên heap (vùng nhớ heap): một vùng bộ nhớ lớn, tách biệt với ngăn xếp. VendingMachine lobby = new VendingMachine(4); tách làm hai. Đối tượng đi vào heap. Biến lobby đi vào khung của main và giữ một tham chiếu (reference) đến đối tượng:

 STACK: main's frame             HEAP
 +-----------------------+        +-----------------------------+
 | lobby   o-------------+------->| a VendingMachine object     |
 +-----------------------+        |   credit   0                |
                                  |   stock    4                |
                                  +-----------------------------+

Một tham chiếu, về thực chất, là địa chỉ của đối tượng. Java không bao giờ cho bạn thấy con số đó; bạn chỉ có thể theo nó bằng một dấu chấm, như trong lobby.insertCoins(4, 0). Vì vậy một biến tham chiếu (reference variable) giữ một địa chỉ, không bao giờ là đối tượng. Lưu ý credit, một int, nằm trên heap, vì nó là một phần của đối tượng. Nơi một biến được khai báo quyết định nơi nó sống: biến cục bộ và tham số trong một khung, trường bên trong đối tượng của chúng.

Hãy thử trước

sameOne = lobby sao chép lobby, và gym có new riêng. Bốn đồng 25 xu được nạp vào sameOne. lobby và gym hiện số tiền nạp bao nhiêu?

Xem đáp án

100 và 0. Sao chép biến là sao chép địa chỉ, nên lobby và sameOne là một cái máy; gym là cái thứ hai.

VendingMachine.java
public class VendingMachine {
    private int credit;
    private int stock;

    public VendingMachine(int stock) {
        this.stock = stock;
    }

    public void insertCoins(int quarters, int dimes) {
        credit = credit + quarters * 25 + dimes * 10;
    }

    public int getCredit() {
        return credit;
    }

    public static void main(String[] args) {
        VendingMachine lobby = new VendingMachine(4);
        VendingMachine sameOne = lobby;               // copies the reference
        VendingMachine gym = new VendingMachine(4);   // a second new: a second machine
        sameOne.insertCoins(4, 0);
        System.out.println("lobby credit: " + lobby.getCredit());
        System.out.println("gym credit:   " + gym.getCredit());
        System.out.println(lobby == sameOne);
        System.out.println(lobby == gym);
    }
}
lobby credit: 100
gym credit:   0
true
false

Trên các tham chiếu, == hỏi “cùng một đối tượng?”, đó là lý do lobby == gym là false.

Kiểm tra bẫy: có bao nhiêu new?

Trong bất kỳ câu hỏi “cái này in ra gì?” nào có đối tượng, hãy đếm các new. Mỗi new tạo đúng một đối tượng. b = a không tạo cái nào: nó sao chép một tham chiếu, nên một thay đổi thực hiện qua b hiện ra qua a.

String cũng là đối tượng, với một nếp nhăn đáng gặp có chủ đích:

VendingMachine.java
public class VendingMachine {
    public static void main(String[] args) {
        String shelf = "Cola";
        String button = "Cola";
        String built = new String("Cola");
        System.out.println(shelf == button);
        System.out.println(shelf == built);
        System.out.println(shelf.equals(built));
    }
}
true
false
true

Java chia sẻ một bản của mỗi literal String giống hệt nhau (văn bản trong dấu nháy kép trong mã), được giữ trong cái gọi là string pool, nên shelf == button là true. new luôn tạo một đối tượng riêng, nên shelf == built là false, trong khi equals so sánh các chữ cái. Văn bản từ một Scanner thường là một đối tượng mới, nên hãy so sánh văn bản bằng equals, như bài hướng dẫn về String giải thích.

Truyền một đối tượng cho một phương thức: vẫn là một bản sao#

Java truyền mọi đối số theo giá trị: tham số nhận một bản sao của những gì đối số giữ. Với một đối tượng, đó là một bản sao của tham chiếu. Đối tượng không được sao chép, và nó cũng không được truyền “theo tham chiếu”. Vì vậy một phương thức có thể theo bản sao của nó và thay đổi đối tượng, nhưng không thể khiến biến của bên gọi trỏ đi nơi khác.

Hãy thử trước

service đặt kho của máy là 30, rồi trỏ tham số của nó vào một máy hoàn toàn mới và đặt kho của máy đó là 99. Sau đó, kho của lobby là 4, 30 hay 99?

Xem đáp án

30. Dòng đầu theo địa chỉ đã sao chép đến máy ở sảnh. Dòng thứ hai chỉ di chuyển bản sao riêng của phương thức.

VendingMachine.java
public class VendingMachine {
    private int credit;
    private int stock;

    public VendingMachine(int stock) {
        this.stock = stock;
    }

    public int getStock() {
        return stock;
    }

    public static void service(VendingMachine vm) {
        vm.stock = 30;                       // follows the copy to the real machine
        vm = new VendingMachine(0);          // moves only the method's own copy
        vm.stock = 99;                       // changes the new machine
    }

    public static void main(String[] args) {
        VendingMachine lobby = new VendingMachine(4);
        service(lobby);
        System.out.println("lobby stock: " + lobby.getStock());
    }
}
lobby stock: 30

lobby và vm là hai biến trong hai khung giữ một địa chỉ. Khi service trả về, chiếc máy 99 lon bị bỏ lại không còn tham chiếu nào ở bất cứ đâu.

Khi một biến chết, và khi một đối tượng có thể bị thu gom#

Một biến cục bộ hoặc một tham số mất đi, chậm nhất, khi phương thức của nó trả về và khung của nó bị lấy ra. Một biến thể hiện tồn tại chừng nào đối tượng của nó còn. Và một đối tượng ở lại trên heap chừng nào mã đang chạy của bạn còn với tới được nó, dù bao nhiêu phương thức trả về.

VendingMachine lobby = new VendingMachine(4);   // machine A on the heap
lobby = new VendingMachine(10);                 // machine B; nothing refers to A now
lobby = null;                                   // nothing refers to B either

null nghĩa là “không tham chiếu đến gì”. Một đối tượng mà mã đang chạy của bạn không còn với tới được, bằng cách theo các tham chiếu từ biến của nó, là không thể với tới (unreachable), và bộ thu gom rác (garbage collector), phần của môi trường chạy Java giải phóng bộ nhớ heap, có thể khi đó thu hồi nó, cùng các trường của nó. Java không hứa khi nào, thậm chí không hứa rằng việc đó sẽ xảy ra trước khi chương trình kết thúc; System.gc() chỉ là một yêu cầu. Bạn không bao giờ tự giải phóng bộ nhớ.

Hãy tự gõ đoạn này

Đừng dán vào. Hãy thêm một phương thức refund() trả về số tiền đã nạp hiện tại và đặt số tiền đó về 0. Bạn cần một biến cục bộ: hãy tìm ra vì sao trước. Kiểm thử nó với 3 đồng 25 xu và 1 đồng 10 xu.

Xem đáp án

Hãy lưu số tiền đã nạp vào một biến cục bộ trước khi xóa trường, nếu không giá trị sẽ mất:

VendingMachine.java
public class VendingMachine {
    private int credit;
    private int stock;

    public VendingMachine(int stock) {
        this.stock = stock;
    }

    public void insertCoins(int quarters, int dimes) {
        credit = credit + quarters * 25 + dimes * 10;
    }

    public int getCredit() {
        return credit;
    }

    public int refund() {
        int back = credit;                   // save it first
        credit = 0;                          // then clear the field
        return back;
    }

    public static void main(String[] args) {
        VendingMachine lobby = new VendingMachine(4);
        lobby.insertCoins(3, 1);
        System.out.println("Refund: " + lobby.refund());
        System.out.println("Credit now: " + lobby.getCredit());
    }
}
Refund: 85
Credit now: 0

Biến cục bộ back chỉ sống trong lời gọi, đó là tất cả những gì nó cần: return trao giá trị của nó đi trước khi khung bị lấy ra.

Điều mới trong bài hướng dẫn này#

  1. Phạm vi là nơi một tên có thể được dùng; thời gian sống là biến tồn tại bao lâu.
  2. Quy tắc khối: một biến cục bộ nằm trong phạm vi từ khai báo của nó đến dấu ngoặc nhọn đóng của khối, nếu không bạn gặp cannot find symbol.
  3. Tham số nằm trong phạm vi toàn bộ phương thức của chúng, trường trong toàn bộ lớp (một phương thức static với tới chúng qua một đối tượng); một tham số trùng tên che khuất một trường, và this với tới phía sau nó.
  4. Mỗi lời gọi đẩy một khung ngăn xếp gồm tham số và biến cục bộ; trả về lấy nó ra. Một stack trace in các khung ra.
  5. Đối tượng sống trên heap; một biến tham chiếu giữ một địa chỉ, nên b = a chia sẻ một đối tượng. Trên các tham chiếu, == hỏi “cùng một đối tượng?”; các literal String giống hệt nhau chia sẻ một đối tượng, và new String tạo một cái khác.
  6. Java truyền một bản sao của mọi đối số, kể cả một bản sao của một tham chiếu.
  7. Biến cục bộ chết khi phương thức trả về; các đối tượng không thể với tới có thể bị thu gom rác, vào thời điểm Java chọn.
Một câu để mang vào phòng thi

Phạm vi là nơi một tên có thể được dùng, từ khai báo của nó đến dấu ngoặc nhọn đóng của khối; thời gian sống là biến tồn tại bao lâu. Biến cục bộ và tham số sống trong khung ngăn xếp của lời gọi và chết khi phương thức trả về; đối tượng sống trên heap, được với tới qua các tham chiếu, và khi không gì với tới được chúng, bộ thu gom rác có thể thu hồi chúng, vào thời điểm Java chọn.

Những chỗ dễ sai#

  • Dùng một biến sau khối đã khai báo nó. Đó là cannot find symbol. Hãy khai báo nó trước khối và chỉ gán bên trong.
  • Mong một biến cục bộ nhớ giá trị của nó giữa các lời gọi. Mỗi lời gọi có một biến mới. Một giá trị cần tồn tại lâu hơn phải là một trường.
  • Viết stock = stock; khi tham số cũng tên là stock. Tham số che khuất trường. Hãy viết this.stock = stock;.
  • Nghĩ rằng b = a sao chép một đối tượng. Nó sao chép tham chiếu, nên cả hai tên chia sẻ một đối tượng. Hãy đếm các new.
  • Nói rằng Java truyền đối tượng theo tham chiếu. Nó truyền một bản sao của tham chiếu. Trỏ tham số vào một đối tượng mới không ảnh hưởng gì đến bên gọi.
  • Nói rằng một đối tượng bị hủy khi phương thức của nó trả về. Chỉ khung mất đi. Một đối tượng không thể với tới có thể được bộ thu gom rác thu hồi, vào thời điểm Java chọn.

Trong bài thi: Với phạm vi, hãy trượt ngón tay từ khai báo xuống dấu ngoặc nhọn đóng tương ứng. Với đối tượng, hãy đếm các new và vẽ một ô cho mỗi đối tượng. Với ngăn xếp, hãy viết các khung từ dưới lên theo thứ tự gọi. Đọc câu hỏi hai lần, trả lời, rồi đọc lại để kiểm tra từng phần.

Luyện tập#

Hãy trả lời từng câu trên giấy trước khi xem lời giải. Mọi đáp án có chạy mã đều đã được kiểm tra bằng cách biên dịch và chạy mã đó.

  1. Đoạn này không biên dịch được. Trình biên dịch chỉ vào dòng nào, và vì sao? Hãy sửa để nó in giá trị cuối của coin và tổng.
    int total = 0;
    for (int coin = 5; coin <= 25; coin = coin + 10) {
        total = total + coin;
    }
    System.out.println(coin + " " + total);
  2. Cái này in ra gì? Hãy đếm các new trước.
    Locker mine = new Locker(3);
    Locker hers = mine;
    mine = new Locker(1);
    hers.items = 7;
    System.out.println(mine.items + " " + hers.items);
  3. Trong một lớp FareCard, tap(int fare) cộng fare vào một biến cục bộ sum (bắt đầu từ 0) và vào một trường total, rồi in cả hai. main gọi mine.tap(5), mine.tap(3), rồi yours.tap(2) trên một thẻ thứ hai. Hãy dự đoán ba dòng.
  4. main gọi checkout(3). checkout khai báo một biến cục bộ subtotal, rồi gọi tax(subtotal). Trong khi tax chạy: hãy liệt kê các khung từ trên xuống dưới, nói tax có thể dùng tên subtotal hay không, và nói subtotal có còn tồn tại hay không.
  5. Viết một phương thức thể hiện transferTo(VendingMachine other, int cans) chuyển từng ấy lon từ máy này sang other và trả về true, hoặc không thay đổi gì và trả về false nếu máy này không có đủ số đó (hoặc cans âm).
  6. Trong main: VendingMachine m = new VendingMachine(4); rồi VendingMachine spare = m; rồi m = null;. Cái máy có thể bị thu gom rác bây giờ không? Điều gì thay đổi sau spare = null;, và khi nào bộ nhớ của nó được giải phóng?

Lời giải#

  1. Dòng println. coin được khai báo trong ngoặc đơn của for, nên phạm vi của nó kết thúc ở dấu ngoặc nhọn đóng của vòng lặp:Coins.java
    public class Coins {
        public static void main(String[] args) {
            int total = 0;
            for (int coin = 5; coin <= 25; coin = coin + 10) {
                total = total + coin;
            }
            System.out.println(coin + " " + total);
        }
    }
    Coins.java:7: error: cannot find symbol
            System.out.println(coin + " " + total);
                               ^
      symbol:   variable coin
      location: class Coins
    1 error
    Hãy khai báo coin trước vòng lặp và chỉ gán nó trong phần đầu của vòng lặp. Vòng lặp dừng khi coin đạt 35, giá trị đầu tiên vượt qua 25:Coins.java
    public class Coins {
        public static void main(String[] args) {
            int total = 0;
            int coin;
            for (coin = 5; coin <= 25; coin = coin + 10) {
                total = total + coin;
            }
            System.out.println(coin + " " + total);
        }
    }
    35 45
  2. 1 7. Hai new, nên hai ngăn tủ. hers = mine chia sẻ ngăn đầu. Rồi mine chuyển sang ngăn thứ hai, nên hers.items = 7 chỉ thay đổi ngăn đầu:Lockers.java
    class Locker {
        int items;
    
        Locker(int items) {
            this.items = items;
        }
    }
    
    public class Lockers {
        public static void main(String[] args) {
            Locker mine = new Locker(3);
            Locker hers = mine;
            mine = new Locker(1);
            hers.items = 7;
            System.out.println(mine.items + " " + hers.items);
        }
    }
    1 7
  3. 5 5, 3 8, 2 2. Biến cục bộ sum bắt đầu từ 0 ở mỗi lời gọi. total là một trường, nên nó tiếp tục tăng cho mine, trong khi thẻ thứ hai có total riêng:FareCard.java
    public class FareCard {
        private int total;
    
        public void tap(int fare) {
            int sum = 0;
            sum = sum + fare;
            total = total + fare;
            System.out.println(sum + " " + total);
        }
    
        public static void main(String[] args) {
            FareCard mine = new FareCard();
            mine.tap(5);
            mine.tap(3);
            FareCard yours = new FareCard();
            yours.tap(2);
        }
    }
    5 5
    3 8
    2 2
  4. Từ trên xuống: tax, checkout, main. tax không thể dùng tên subtotal; nó chỉ có tham số của chính nó, một bản sao của giá trị. Nhưng subtotal vẫn tồn tại trong khung đang tạm dừng của checkout. Nằm ngoài phạm vi nhưng vẫn còn sống.
  5. stock đơn thuần là trường của máy này; other.stock theo tham chiếu đến máy kia. Mã bên trong một lớp có thể dùng các trường private của mọi đối tượng thuộc lớp đó:VendingMachine.java
    public class VendingMachine {
        private int stock;
    
        public VendingMachine(int stock) {
            this.stock = stock;
        }
    
        public int getStock() {
            return stock;
        }
    
        public boolean transferTo(VendingMachine other, int cans) {
            if (cans < 0 || cans > stock) {
                return false;                    // cannot move what is not here
            }
            stock = stock - cans;                // this machine's field
            other.stock = other.stock + cans;    // the other machine's field
            return true;
        }
    
        public static void main(String[] args) {
            VendingMachine lobby = new VendingMachine(10);
            VendingMachine gym = new VendingMachine(2);
            System.out.println(lobby.transferTo(gym, 4));
            System.out.println(lobby.transferTo(gym, 40));
            System.out.println(lobby.getStock() + " " + gym.getStock());
        }
    }
    true
    false
    6 6
  6. Chưa: spare vẫn tham chiếu đến nó. Sau spare = null; nó không thể với tới, nên bộ thu gom rác có thể thu hồi nó. Java không hứa khi nào, thậm chí không hứa rằng việc đó sẽ xảy ra trước khi chương trình kết thúc.

Danh sách kiểm tra trước khi thi#

Đây là các mục trong danh sách chủ đề Bài thi 1 của môn học mà bài hướng dẫn này đề cập. Chỉ đánh dấu mỗi mục khi bạn làm được mà không cần nhìn.

  • ☐  Tôi có thể nói một biến cục bộ, một tham số và một biến thể hiện nằm trong phạm vi ở đâu.
  • ☐  Tôi có thể giải thích phạm vi so với thời gian sống.
  • ☐  Tôi có thể vẽ ngăn xếp lời gọi cho một chuỗi lời gọi và nói mỗi khung giữ gì.
  • ☐  Tôi có thể nói cái gì nằm trong khung ngăn xếp và cái gì nằm trên heap với một dòng như VendingMachine m = new VendingMachine(4);.
  • ☐  Tôi có thể dự đoán cái gì được in khi hai tham chiếu chia sẻ một đối tượng, và nói khi nào một đối tượng có thể bị thu gom.

Tự kiểm tra trong ứng dụng Kestrel Exams miễn phí

18 câu hỏi luyện tập về phạm vi và bộ nhớ, mỗi đáp án mã đều được kiểm tra bằng cách biên dịch và chạy. Miễn phí, ngoại tuyến, không cần tài khoản.

Luyện tập phạm vi và bộ nhớ →

Câu hỏi thường gặp#

Phạm vi biến trong Java là gì?

Phạm vi là vùng mã nơi tên của một biến có thể được dùng. Một biến cục bộ nằm trong phạm vi từ khai báo của nó đến dấu ngoặc nhọn đóng của khối, một tham số trong toàn bộ phương thức của nó, và một biến thể hiện trong toàn bộ lớp, dù một phương thức static như main phải truy cập nó qua một đối tượng. Bên ngoài phạm vi, tên đó gây lỗi biên dịch cannot find symbol.

Khác biệt giữa phạm vi và thời gian sống trong Java là gì?

Phạm vi nói về văn bản chương trình: những dòng nào được dùng tên đó. Thời gian sống nói về thời gian: biến tồn tại bao lâu khi chương trình chạy. Khi phương thức a chờ phương thức b, các biến cục bộ của a nằm ngoài phạm vi trong b nhưng vẫn còn sống.

Khác biệt giữa stack và heap trong Java là gì?

Ngăn xếp lời gọi giữ một khung cho mỗi lời gọi phương thức chưa kết thúc, cùng với các tham số và biến cục bộ của lời gọi đó. Heap giữ mọi đối tượng, dù tạo bằng new, một mảng hay một literal String, cùng các trường của nó. Trong VendingMachine m = new VendingMachine(4); bên trong một phương thức, biến m nằm trong khung ngăn xếp còn đối tượng nằm trên heap.

Java truyền theo giá trị hay truyền theo tham chiếu?

Luôn truyền theo giá trị. Với một đối tượng, tham số nhận một bản sao của tham chiếu, nên phương thức có thể thay đổi đối tượng, nhưng gán một đối tượng mới cho tham số không làm thay đổi biến của nơi gọi.

Khi nào một đối tượng bị thu gom rác trong Java?

Khi mã đang chạy không còn với tới được nó, một đối tượng đủ điều kiện. Bộ thu gom rác khi đó có thể thu hồi nó, nhưng Java không hứa khi nào; System.gc() chỉ là một yêu cầu.

Đề xuất chỉnh sửa

Có chỗ nào chưa rõ? Có chủ đề nào bạn mong chúng tôi viết? Hãy cho chúng tôi biết. Chúng tôi đọc mọi tin nhắn, và một lời đề nghị là cách nhanh nhất để có một bài hướng dẫn mới: nhiều bài trong số này ra đời vì có người đã hỏi.