Cho biết các tạo ra một thể hiện của InputStreamReader từ một thể hiện của InputStream

Lớp `Writer` trong Java được thiết kế để ghi các ký tự ra luồng xuất. Nó là lớp cha của các lớp như `BufferedWriter`, `FileWriter`, `PrintWriter`,...

- Phát biểu (1): Lớp `Writer` có thể được dùng để ghi các ký tự có cách mã hóa khác nhau ra luồng xuất. Điều này đúng vì các lớp con của `Writer` có thể hỗ trợ các bảng mã khác nhau. Ví dụ, `OutputStreamWriter` có thể chỉ định bảng mã khi tạo.
- Phát biểu (2): Lớp `Writer` có thể được dùng để ghi các ký tự Unicode ra luồng xuất. Điều này đúng vì Java sử dụng Unicode cho các ký tự, và `Writer` có thể ghi các ký tự này một cách dễ dàng.
- Phát biểu (3): Lớp `Writer` không trực tiếp hỗ trợ ghi giá trị các kiểu dữ liệu cơ sở (int, float, boolean,...) ra luồng xuất. Để ghi các kiểu dữ liệu này, chúng ta thường sử dụng `PrintWriter` hoặc kết hợp với các lớp khác để chuyển đổi kiểu dữ liệu thành chuỗi trước khi ghi.

Vì vậy, cả (1) và (2) đều đúng, làm cho đáp án D là chính xác nhất.

Đoạn mã Java sử dụng lớp `StringBuffer`.
- Dòng (1) khởi tạo một đối tượng `StringBuffer` rỗng.
- Dòng (2) khai báo một biến `StringBuffer` tên `s` nhưng gán giá trị `null`.
- Dòng (3) gọi phương thức `append(s)` trên đối tượng `result`. Khi `s` là `null`, phương thức `append` sẽ thêm chuỗi "null" vào `result`. Điều này không gây ra lỗi.
- Dòng (4) chèn chuỗi "123" vào vị trí 0 của `result`. Như vậy, "123" sẽ được thêm vào đầu chuỗi hiện tại.
- Dòng (5) in ra nội dung của `result`.

Vì vậy, kết quả in ra sẽ là "123null".

Phương án A sai vì lớp Object là lớp cha của tất cả các lớp trong Java, không phải ngược lại. Phương án B sai vì lớp Object không phải là lớp final, do đó nó có thể được kế thừa. Phương án C đúng vì trong Java, mọi lớp đều kế thừa từ lớp Object một cách trực tiếp hoặc gián tiếp, tạo thành một hệ thống phân cấp lớp duy nhất.

Đoạn mã Java này minh họa cách tham số được truyền theo giá trị (pass-by-value) trong Java. Biến `d` trong phương thức `main` được khởi tạo với giá trị 12.3. Sau đó, nó được truyền cho phương thức `decrement` của đối tượng `Decrement`. Trong phương thức `decrement`, biến `decMe` nhận giá trị của `d`, và sau đó `decMe` bị trừ đi 1.0. Tuy nhiên, đây chỉ là một bản sao của `d`. Do đó, giá trị của `d` trong phương thức `main` không bị thay đổi. Khi `System.out.println(d)` được gọi, nó in ra giá trị ban đầu của `d`, tức là 12.3.

Câu hỏi này kiểm tra kiến thức về toán tử dịch bit không dấu `>>>` trong Java. Toán tử này dịch các bit sang phải và điền các bit trống ở phía bên trái bằng số 0. Điều này đảm bảo kết quả luôn là một số không âm.

* Đáp án A: `int x = -1; x = x >>> 5;`
* `x = -1` (dạng nhị phân là tất cả các bit đều là 1).
* `x >>> 5` dịch các bit của `x` sang phải 5 vị trí, điền các bit bên trái bằng 0. Vì `x` là một số nguyên 32 bit, kết quả sẽ là một số dương lớn.
* Đáp án B: `int x = -1; x = x >>> 32;`
* `x = -1` (dạng nhị phân là tất cả các bit đều là 1).
* `x >>> 32` dịch các bit của `x` sang phải 32 vị trí. Vì Java chỉ sử dụng 5 bit cuối cùng của toán hạng bên phải cho `int`, nên `x >>> 32` tương đương với `x >>> 0`, tức là không dịch gì cả. Giá trị của `x` vẫn là -1.
* Đáp án C: `byte x = -1; x = x >>> 5;`
* `byte x = -1` (dạng nhị phân là tất cả các bit đều là 1).
* `x >>> 5`: Đầu tiên, `x` được chuyển đổi thành `int` (mở rộng dấu), do đó nó trở thành `-1` kiểu `int`. Sau đó, `x >>> 5` hoạt động như trong đáp án A, cho ra một số dương lớn. Tuy nhiên, vì kiểu trả về là `byte`, giá trị này sẽ bị cắt ngắn để phù hợp với một `byte`. Vì số này lớn hơn phạm vi của `byte`, kết quả cuối cùng sẽ bị sai lệch và không chắc chắn là dương.
* Đáp án D: `int x = -1; x = x >> 5;`
* `x = -1` (dạng nhị phân là tất cả các bit đều là 1).
* `x >> 5` dịch các bit của `x` sang phải 5 vị trí, điền các bit bên trái bằng bit dấu (trong trường hợp này là 1). Kết quả vẫn là một số âm.

Vậy, chỉ có đáp án A đảm bảo `x` có giá trị dương sau phép toán.