Kết quả in ra của đoạn mã trên là gì?
int i = 1,
j = 10;
do {
if (i++>--j) {
continue;
}
} while ( i < 5 );
System.out.println("i = " + i + "and j = " + j);

i = 6 and j = 6

i = 5 and j = 5

i = 6 and j = 5

i = 5 and j = 6

Trả lời:

Đáp án đúng: D

Đoạn code sử dụng vòng lặp `do...while` và câu lệnh `if` với các toán tử tăng/giảm tiền tố và hậu tố. Ta sẽ theo dõi giá trị của `i` và `j` trong mỗi vòng lặp: - **Lần 1:** `i = 1`, `j = 10`. Điều kiện `i++ > --j` trở thành `1 > 9` (vì `i++` trả về giá trị hiện tại của `i` trước khi tăng, và `--j` giảm `j` trước khi so sánh). Điều kiện sai. `i` thành `2`, `j` thành `9`. - **Lần 2:** `i = 2`, `j = 9`. Điều kiện `i++ > --j` trở thành `2 > 8`. Điều kiện sai. `i` thành `3`, `j` thành `8`. - **Lần 3:** `i = 3`, `j = 8`. Điều kiện `i++ > --j` trở thành `3 > 7`. Điều kiện sai. `i` thành `4`, `j` thành `7`. - **Lần 4:** `i = 4`, `j = 7`. Điều kiện `i++ > --j` trở thành `4 > 6`. Điều kiện sai. `i` thành `5`, `j` thành `6`. Vòng lặp `while (i < 5)` kết thúc vì `i = 5`. Vậy, kết quả in ra là `i = 5 and j = 6`.

150+ câu hỏi trắc nghiệm Lập trình Java kèm đáp án chi tiết - Phần 1

50 câu hỏi 60 phút

Bắt đầu thi

Câu hỏi liên quan

Câu 46:

Làm thế nào để đoạn mã trên biên dịch thành công?
public abstract class Test {
public abstract void methodA();
public abstract void methodB()
{
System.out.printIn("Hello");
}
}

Lời giải:

Đáp án đúng: C

Đoạn mã trên không biên dịch được vì phương thức `methodB()` được khai báo là `abstract` nhưng lại có phần thân (body) `{ System.out.printIn("Hello"); }`. Một phương thức `abstract` không được phép có phần thân. Để sửa lỗi này, chúng ta cần xóa từ khóa `abstract` ở dòng 4 để `methodB()` trở thành một phương thức bình thường có phần thân.

* Phương án A: Cài đặt cụ thể phần thân cho phương thức `methodA()` sẽ chỉ giải quyết được lỗi liên quan đến `methodA()`, nhưng lỗi ở `methodB()` vẫn còn.
* Phương án B: Thay thế `public` thành `private` không ảnh hưởng đến việc phương thức `abstract` có phần thân hay không.
* Phương án D: Xóa từ khóa `abstract` ở dòng 2 sẽ khiến lớp `Test` không còn là lớp `abstract` nữa, điều này có thể không phù hợp với yêu cầu của bài toán. Ngoài ra, lỗi ở `methodB()` vẫn còn.

Câu 47:

Một lớp kế thừa từ lớp abstract thì từ khóa nào sau đây được sử dụng để cài đặt các phương thức của lớp kế thừa này? Chọn một câu trả lời

Lời giải:

Đáp án đúng: D

Khi một lớp kế thừa từ một lớp abstract (lớp trừu tượng), lớp con đó phải cung cấp triển khai (implementation) cụ thể cho tất cả các phương thức trừu tượng (abstract methods) của lớp cha. Để các phương thức này có thể được truy cập và sử dụng từ bên ngoài lớp, chúng thường được khai báo là `public`.

* A. static: Từ khóa `static` được sử dụng để tạo các phương thức hoặc biến thuộc về lớp chứ không phải là một đối tượng cụ thể của lớp. Nó không liên quan đến việc triển khai các phương thức trừu tượng.
* B. public: Từ khóa `public` cho phép truy cập vào các phương thức và thuộc tính từ bất kỳ đâu. Khi triển khai một phương thức trừu tượng, ta thường sử dụng `public` để làm cho phương thức này có thể được gọi từ bên ngoài lớp.
* C. private: Từ khóa `private` giới hạn quyền truy cập chỉ trong phạm vi lớp mà nó được khai báo. Không thể truy cập từ bên ngoài lớp, vì vậy không phù hợp để triển khai các phương thức trừu tượng mà lớp con cần cung cấp.
* D. abstract: Từ khóa `abstract` được sử dụng để khai báo một lớp hoặc phương thức là trừu tượng, tức là nó không có phần triển khai. Lớp con phải triển khai các phương thức này, nhưng không sử dụng `abstract` trong lớp con để thực hiện việc đó.

Do đó, đáp án đúng là B.

Câu 48:

Giá trị cuối cùng của i tại dòng 7 là bao nhiêu?
public class Test {
public static void main(string args[]) {
int i = 0;
while (true) {
if (i == 4) break;
++i;
System.out.println(i);
}
}
}

Lời giải:

Đáp án đúng: C

Đoạn code trên thực hiện một vòng lặp `while` vô tận cho đến khi `i` bằng 4.
- `i` được khởi tạo bằng 0.
- Vòng lặp bắt đầu.
- `++i` tăng `i` lên 1.
- `i` được in ra màn hình.
- Kiểm tra điều kiện `i == 4`. Nếu đúng, vòng lặp kết thúc.

Khi `i` bằng 4, điều kiện `i == 4` trở thành đúng, lệnh `break` được thực thi và vòng lặp kết thúc. Giá trị cuối cùng của `i` trước khi vòng lặp kết thúc là 4. Tuy nhiên, giá trị của `i` được in ra trong mỗi lần lặp trước khi kiểm tra điều kiện dừng. Vì vậy, giá trị cuối cùng được in ra là 4.
Giá trị của `i` tăng lên lần lượt là 1, 2, 3, 4. Khi `i` bằng 4 thì vòng lặp `while` kết thúc. Như vậy giá trị cuối cùng của `i` là 4.

Câu 49:

Kết quả in ra của đoạn mã trên là gì?
Chọn một câu trả lời
public class Foo {
public static void main(String[] args) {
try {
return;
} finally {
System.out.println( "Finally" );
}
}
}

Lời giải:

Đáp án đúng: A

Đoạn mã Java này minh họa cách khối `finally` hoạt động trong cấu trúc `try-finally`. Dù câu lệnh `return` được gọi trong khối `try`, khối `finally` vẫn luôn được thực thi trước khi hàm thực sự trả về. Do đó, dòng chữ "Finally" sẽ được in ra màn hình trước khi chương trình kết thúc.

Phân tích các lựa chọn:
- A. Finally: Đây là đáp án chính xác vì khối `finally` luôn được thực thi.
- B. Lỗi biên dịch: Mã này biên dịch thành công.
- C. Đoạn mã thực thi nhưng không in ra kết quả: Mã sẽ in ra "Finally".
- D. Lỗi sinh ra trong quá trình chạy: Mã này không gây ra lỗi runtime.

Câu 50:

Kết quả sau khi biên dịch mã: class A { public static void main(String[] args) {A a = new B();}} class B extends A{}

Lời giải:

Đáp án đúng: C

Đoạn mã trên không gây ra lỗi biên dịch hay ngoại lệ thời gian chạy. Lớp `B` kế thừa từ lớp `A`, và một đối tượng của lớp `B` được gán cho một biến kiểu `A`. Đây là một ví dụ của tính đa hình (polymorphism) trong Java, nơi một đối tượng của một lớp con có thể được gán cho một biến của lớp cha. Do đó, chương trình sẽ biên dịch và chạy mà không gặp lỗi.

Câu 1:

Đâu không phải là một kiểu dữ liệu nguyên thủy trong Java?

Lời giải: