Trong Java, đa kế thừa thực hiện bằng cách nào?

Đoạn mã trên có hai lỗi:

1. Lỗi 1: Trong Java, khi sử dụng `Boolean` (đối tượng) trong câu lệnh `if`, Java sẽ tự động unboxing (chuyển đổi từ `Boolean` về `boolean`). Tuy nhiên, giá trị của `Boolean b` được khởi tạo bằng chuỗi "TRUE". Trong Java, `new Boolean(String)` chỉ trả về `true` nếu chuỗi truyền vào (không phân biệt hoa thường) là "true". Nếu không, nó sẽ trả về `false`. Như vậy, trong trường hợp này, `b` sẽ có giá trị `false`, và khối mã trong `if` sẽ không được thực thi.

2. Lỗi 2: Tương tự như trên, khi sử dụng `Integer` trong vòng lặp `for`, Java cũng thực hiện unboxing để chuyển đổi `Integer` về `int`. Điều này hoàn toàn hợp lệ và không gây ra lỗi.

Vì vậy, lỗi chính nằm ở việc sử dụng `Boolean` trong câu lệnh `if` và giá trị khởi tạo của nó, dẫn đến điều kiện `if` luôn sai. Câu lệnh `for` sử dụng `Integer` không gây ra lỗi.

Do đó, đáp án đúng nhất là B, vì lỗi nằm ở cách sử dụng `Boolean` trong câu lệnh `if` và giá trị khởi tạo của nó.

Cụ thể:

- `Boolean b = new Boolean("TRUE");` sẽ gán `false` cho `b` vì chuỗi truyền vào không phải là "true" (chú ý phân biệt hoa thường).
- `if (b)` sẽ tương đương với `if (false)`, dẫn đến khối mã bên trong `if` không được thực thi.

Câu C sai vì việc sử dụng `Integer` trong vòng lặp `for` là hợp lệ do unboxing.

Câu D sai vì chỉ có câu B đúng, còn câu C sai.

Đoạn chương trình Java này liên quan đến việc khởi tạo đối tượng và thứ tự gọi constructor trong quan hệ kế thừa.

1. `public class S1`: Định nghĩa một lớp tên là `S1`.
2. `public static void main(String[] args)`: Phương thức `main` là điểm bắt đầu của chương trình. Bên trong `main`, một đối tượng của lớp `S2` được tạo ra: `new S2();`.
3. `S1() { System.out.print("S1"); }`: Đây là constructor của lớp `S1`. Khi một đối tượng của `S1` (hoặc một lớp con của `S1`) được tạo, constructor này sẽ in ra "S1".
4. `class S2 extends S1`: Lớp `S2` kế thừa từ lớp `S1`.
5. `S2() { System.out.print("S2"); }`: Đây là constructor của lớp `S2`. Khi một đối tượng của `S2` được tạo, constructor này sẽ in ra "S2".

Khi `new S2()` được gọi, các bước sau xảy ra:

- Đầu tiên, constructor của lớp cha (`S1`) được gọi một cách ngầm định trước khi constructor của lớp con (`S2`) được thực thi. Điều này đảm bảo rằng các thuộc tính và trạng thái của lớp cha được khởi tạo trước khi lớp con thực hiện việc khởi tạo của riêng nó.
- Do đó, "S1" được in ra từ constructor của `S1`.
- Tiếp theo, constructor của `S2` được thực thi và in ra "S2".

Kết quả là, chương trình in ra "S1S2".

Đoạn chương trình Java này minh họa tính kế thừa và ghi đè biến (variable hiding).

- Lớp `Question` chứa hàm `main`. Hàm `main` tạo một đối tượng `s2` thuộc lớp `S2` và gọi phương thức `display()` trên đối tượng đó.
- Lớp `S1` có một biến `s` kiểu `String` được khởi tạo với giá trị "S1" và một phương thức `display()` in giá trị của biến `s` ra màn hình.
- Lớp `S2` kế thừa từ lớp `S1` và cũng có một biến `s` kiểu `String` được khởi tạo với giá trị "S2".

Khi `s2.display()` được gọi, phương thức `display()` của lớp `S1` được thực thi (vì `S2` không ghi đè phương thức này). Phương thức `display()` này in giá trị của biến `s` mà nó thấy. Trong trường hợp này, nó thấy biến `s` được định nghĩa trong lớp `S1`, do đó nó in ra "S1".

Như vậy, kết quả in ra màn hình là "S1".

Phương thức `main` là điểm khởi đầu của một chương trình Java. Nó phải được khai báo là `public static void main(String[] args)`.

* `public`: Cho phép phương thức `main` được gọi từ bên ngoài lớp.
* `static`: Cho phép phương thức `main` được gọi mà không cần tạo một thể hiện của lớp.
* `void`: Chỉ ra rằng phương thức `main` không trả về bất kỳ giá trị nào.
* `main`: Tên của phương thức.
* `String[] args`: Một mảng các chuỗi đại diện cho các đối số dòng lệnh được truyền cho chương trình.

Phân tích các lựa chọn:

* A. `public static void main()`: Thiếu tham số `String[] args`, là tham số bắt buộc của hàm `main`.
* B. `public void main(String[] arg)`: Thiếu từ khóa `static`, khiến phương thức không thể được gọi trực tiếp từ lớp.
* C. `public static void main(String[] args)`: Đây là khai báo chính xác của phương thức `main`.
* D. `public static int main(String[] arg)`: Kiểu trả về là `int` thay vì `void`, không đúng với quy định của phương thức `main`.

Kiểu dữ liệu `short` trong Java (và nhiều ngôn ngữ lập trình khác) là một kiểu số nguyên có dấu, sử dụng 2 bytes (16 bits) để lưu trữ. Vì nó là kiểu số nguyên có dấu, nó có thể biểu diễn cả số dương và số âm. Phạm vi giá trị của nó được tính như sau:

* Giá trị nhỏ nhất: -2^(số bits - 1) = -2^15 = -32768
* Giá trị lớn nhất: 2^(số bits - 1) - 1 = 2^15 - 1 = 32767

Do đó, miền giá trị của biến kiểu `short` là từ -2^15 đến 2^15 - 1.