Cho đoạn mã sau đây. Sau khi thực hiện, kết quả in lên màn hình là bao nhiêu?

int a = 6,
b = 7;
System.out.println((a > b) ? 10 : 9);

9.0

10.0

Trả lời:

Đáp án đúng: A

Đoạn mã sử dụng toán tử điều kiện (ternary operator) `(a > b) ? 10 : 9`. 1. **`int a = 6, b = 7;`**: Khai báo và khởi tạo hai biến nguyên `a` và `b` với giá trị lần lượt là 6 và 7. 2. **`(a > b) ? 10 : 9`**: Đây là toán tử điều kiện. Nó kiểm tra điều kiện `a > b`. Trong trường hợp này, `a` là 6 và `b` là 7, do đó `a > b` là `false`. 3. Vì điều kiện `a > b` là `false`, toán tử điều kiện sẽ trả về giá trị sau dấu hai chấm (`:`), tức là 9. 4. **`System.out.println(9);`**: Lệnh này in giá trị 9 ra màn hình. Vậy kết quả in ra màn hình là 9.

300+ câu hỏi trắc nghiệm Lập trình mạng có đáp án kèm giải thích - Phần 2

50 câu hỏi 60 phút

Bắt đầu thi

Câu hỏi liên quan

Câu 20:

Cho đoạn lệnh sau đây. Cho biết kết quả khi thực thi chương trình

if ("String".toString() == "String") System.out.println("Equal");
else System.out.println("Not Equal");

Lời giải:

Đáp án đúng: A

Trong Java, khi so sánh hai đối tượng String bằng toán tử `==`, ta đang so sánh tham chiếu (địa chỉ) của chúng trong bộ nhớ, chứ không phải nội dung của chuỗi.

Trong đoạn code này, `"String".toString()` trả về một tham chiếu đến một đối tượng String, và `"String"` cũng là một tham chiếu đến một đối tượng String khác (có thể là một String literal trong string pool hoặc một đối tượng mới). Mặc dù cả hai đều có nội dung là "String", nhưng chúng có thể không phải là cùng một đối tượng trong bộ nhớ. Do đó, phép so sánh `==` có thể trả về `false`. Tuy nhiên, trong nhiều trường hợp, trình biên dịch có thể tối ưu hóa và sử dụng lại các String literal, dẫn đến việc hai tham chiếu này trỏ đến cùng một đối tượng. Điều này làm cho kết quả của phép so sánh `==` không nhất quán và phụ thuộc vào môi trường thực thi.

Trong trường hợp này, do không có đảm bảo rằng hai chuỗi này là cùng một đối tượng, nên kết quả so sánh bằng `==` có thể trả về `false`, dẫn đến việc in ra "Not Equal".

Câu 21:

Cho chương trình sau đây. Hãy cho biết kết quả sau khi thực thi chương trình?

class tbt {
public static void main(String args[]) {
System.out.println("In first main()");
}
public static void main(char args[]) {
System.out.println(''
a '');
}
}

Lời giải:

Đáp án đúng: C

Trong Java, một lớp có thể có nhiều phương thức `main`, miễn là chúng có signature khác nhau (ví dụ: số lượng tham số khác nhau hoặc kiểu dữ liệu của tham số khác nhau). Khi chạy chương trình, JVM sẽ tìm phương thức `main` có signature `public static void main(String[] args)` để thực thi. Trong trường hợp này, chương trình có hai phương thức `main`, một với tham số là mảng các String (`String args[]`) và một với tham số là mảng các char (`char args[]`). Khi chương trình được chạy, JVM sẽ gọi phương thức `main` với tham số là mảng các String. Do đó, chương trình sẽ biên dịch thành công và in ra "In first main()".

Câu 22:

Cho đoạn mã sau đây. Hãy cho biết kết quả khi thực thi

final int i = 100;
byte b = i;
System.out.println(b);

Lời giải:

Đáp án đúng: C

Câu 23:

Cho đoạn mã lệnh sau. Hãy cho biết giá trị của sum sau khi thực hiện xong đoạn lệnh trên?

int i = 5,
sum = 0;
while (i > 0) {
i--;
sum = sum + i;
}

Lời giải:

Đáp án đúng: B

Đoạn code trên thực hiện một vòng lặp `while` với biến `i` khởi tạo bằng 5 và `sum` khởi tạo bằng 0. Vòng lặp tiếp tục cho đến khi `i` không còn lớn hơn 0. Trong mỗi lần lặp, `i` giảm đi 1 và giá trị mới của `i` được cộng vào `sum`.

Các bước thực hiện:

1. `i = 5`, `sum = 0`
2. `i > 0` (5 > 0) là đúng. `i` giảm thành 4, `sum = 0 + 4 = 4`
3. `i > 0` (4 > 0) là đúng. `i` giảm thành 3, `sum = 4 + 3 = 7`
4. `i > 0` (3 > 0) là đúng. `i` giảm thành 2, `sum = 7 + 2 = 9`
5. `i > 0` (2 > 0) là đúng. `i` giảm thành 1, `sum = 9 + 1 = 10`
6. `i > 0` (1 > 0) là đúng. `i` giảm thành 0, `sum = 10 + 0 = 10`
7. `i > 0` (0 > 0) là sai. Vòng lặp kết thúc.

Vậy giá trị cuối cùng của `sum` là 10.

Câu 24:

Cho đoạn chương trình sau. Cho biết kết quả in lên màn hình sau khi thực thi?

class Value {
public int i = 15;
}
public class Test {
public static void main(String args[]) {
Test t = new Test();
t.first();
}
public void first() {
int i = 5;
Value v = new Value();
v.i = 25;
second(v, i);
System.out.print(" " + v.i);
}
public void second(Value v, int i) {
i = 0;
v.i = 20;
Value val = new Value();
v = val;
System.out.print(v.i + " " + i);
}
}

Lời giải:

Đáp án đúng: B

Đoạn chương trình Java này liên quan đến việc truyền tham chiếu đối tượng và ảnh hưởng của nó đến các biến.

Hàm `first()`:
1. Khởi tạo `i = 5` (biến cục bộ).
2. Tạo một đối tượng `Value` và gán `v.i = 25`.
3. Gọi hàm `second(v, i)`.
4. Sau khi `second()` thực thi, in ra giá trị của `v.i`.

Hàm `second(Value v, int i)`:
1. Gán `i = 0` (chỉ ảnh hưởng đến bản sao cục bộ của `i`).
2. Gán `v.i = 20` (thay đổi giá trị của thuộc tính `i` của đối tượng `Value` được tham chiếu bởi `v`).
3. Tạo một đối tượng `Value` mới và gán tham chiếu của đối tượng mới này cho `v`. Lúc này `v` không còn trỏ đến đối tượng `Value` ban đầu được truyền vào nữa. Vì vậy lệnh `System.out.print(v.i + " " + i);` in ra `15 0` (giá trị mặc định của `i` trong class `Value` và giá trị của biến `i` trong hàm `second`)

Vì vậy, hàm `second` in ra "15 0".

Sau khi `second` thực thi, hàm `first` in ra giá trị `v.i`. Vì trong hàm `second`, biến `v` đã bị thay đổi để tham chiếu đến một đối tượng `Value` mới, nên đối tượng `Value` ban đầu được tạo trong hàm `first`, mà `v` tham chiếu đến, đã bị thay đổi giá trị `i` thành 20. Do đó, hàm `first` in ra "20".

Vậy kết quả in ra màn hình là: 15 0 20

Câu 25:

Cho đoạn chương trình sau:

import java.io. * ;
import java.io. * ;
class TBT {
static BufferedReader buf = new BufferedReader(new InputStreamReader(System. in ));
public static void main(String args[]) {
String m = new String();
float x;
m = buf.readLine();
try {
x = Float.parseFloat(m);
} catch(Exception e) {}
}
}

Lời giải: