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.
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 đó.
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:
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.
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.
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.
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ại | Phạm vi: nơi tên có tác dụng | Thờ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ối | từ 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ức | từ đầu lời gọi cho đến khi phương thức trả về |
| Biến thể hiện | toà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 static | toàn bộ lớp, kể cả các phương thức static | mộ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.
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.
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.
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.
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.
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.
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.
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.javapublic 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.
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.
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ớ.
Đừ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.javapublic 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: 0Biế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#
- 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.
- 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. - 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à
thisvới tới phía sau nó. - 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.
- Đối tượng sống trên heap; một biến tham chiếu giữ một địa chỉ, nên
b = achia 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 Stringtạo một cái khác. - 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.
- 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.
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ếtthis.stock = stock;. - Nghĩ rằng
b = asao 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ácnew. - 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ã đó.
- Đ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
coinvà tổng.int total = 0; for (int coin = 5; coin <= 25; coin = coin + 10) { total = total + coin; } System.out.println(coin + " " + total); - Cái này in ra gì? Hãy đếm các
newtrước.Locker mine = new Locker(3); Locker hers = mine; mine = new Locker(1); hers.items = 7; System.out.println(mine.items + " " + hers.items); - Trong một lớp
FareCard,tap(int fare)cộngfarevào một biến cục bộsum(bắt đầu từ 0) và vào một trườngtotal, rồi in cả hai.maingọimine.tap(5),mine.tap(3), rồiyours.tap(2)trên một thẻ thứ hai. Hãy dự đoán ba dòng. maingọicheckout(3).checkoutkhai báo một biến cục bộsubtotal, rồi gọitax(subtotal). Trong khitaxchạy: hãy liệt kê các khung từ trên xuống dưới, nóitaxcó thể dùng tênsubtotalhay không, và nóisubtotalcó còn tồn tại hay không.- 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 sangothervà trả vềtrue, hoặc không thay đổi gì và trả vềfalsenếu máy này không có đủ số đó (hoặccansâm). - Trong
main:VendingMachine m = new VendingMachine(4);rồiVendingMachine spare = m;rồim = null;. Cái máy có thể bị thu gom rác bây giờ không? Điều gì thay đổi sauspare = null;, và khi nào bộ nhớ của nó được giải phóng?
Lời giải#
- Dòng
println.coinđược khai báo trong ngoặc đơn củafor, 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.javapublic 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); } }
Hãy khai báoCoins.java:7: error: cannot find symbol System.out.println(coin + " " + total); ^ symbol: variable coin location: class Coins 1 errorcointrướ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 khicoinđạt 35, giá trị đầu tiên vượt qua 25:Coins.javapublic 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 1 7. Hainew, nên hai ngăn tủ.hers = minechia sẻ ngăn đầu. Rồiminechuyển sang ngăn thứ hai, nênhers.items = 7chỉ thay đổi ngăn đầu:Lockers.javaclass 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 75 5,3 8,2 2. Biến cục bộsumbắt đầu từ 0 ở mỗi lời gọi.totallà một trường, nên nó tiếp tục tăng chomine, trong khi thẻ thứ hai cótotalriêng:FareCard.javapublic 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- Từ trên xuống:
tax,checkout,main.taxkhông thể dùng tênsubtotal; nó chỉ có tham số của chính nó, một bản sao của giá trị. Nhưngsubtotalvẫn tồn tại trong khung đang tạm dừng củacheckout. Nằm ngoài phạm vi nhưng vẫn còn sống. stockđơn thuần là trường của máy này;other.stocktheo 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.javapublic 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- Chưa:
sparevẫn tham chiếu đến nó. Sauspare = 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.
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.