Đoạn mã sau có lỗi biên dịch gì?
public class Person {
private String name;
protected int age;
public static void main(String[] args) {
Person p = new Person();
p.name = "Tom";
System.out.println(p.name);
}
}

Đoạn mã trên có lỗi biên dịch vì biến `name` trong lớp `Person` được khai báo là `protected`. Điều này có nghĩa là `name` chỉ có thể được truy cập từ bên trong lớp `Person`, từ các lớp con của `Person`, và từ các lớp trong cùng package. Trong đoạn mã trên, biến `name` đang được truy cập trực tiếp từ lớp `Main`, là một lớp khác package (ngầm định) và không phải là lớp con của `Person`. Do đó, trình biên dịch sẽ báo lỗi "name has protected access". Biến `age` được khai báo là `public` nên có thể truy cập từ bất kỳ đâu.

Đoạn mã khai báo lớp `Student` trong package `java.class` sẽ gây ra lỗi biên dịch. Lý do là vì theo quy ước và khuyến cáo của Java, các package bắt đầu bằng `java.` (ví dụ: `java.lang`, `java.util`, `java.io`) được dành riêng cho các thư viện chuẩn của Java. Việc tự định nghĩa package bắt đầu bằng `java.` có thể gây ra xung đột và hành vi không mong muốn, mặc dù trình biên dịch có thể không báo lỗi ngay lập tức trong một số trường hợp, nhưng đây là một thông lệ lập trình không tốt và nên tránh. Trong trường hợp này, trình biên dịch sẽ báo lỗi "incorrect package" hoặc tương tự, tùy thuộc vào môi trường phát triển.

Đoạn mã Java này có một lỗi. Dòng `greet = “Hello”;` sẽ gây ra lỗi biên dịch vì bạn không thể gán một chuỗi (String) trực tiếp cho một mảng ký tự (char[]). Bạn cần chuyển đổi chuỗi "Hello" thành một mảng ký tự trước khi gán.

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

Đoạn code thực hiện một vòng lặp `for` từ `i = 0` đến `i < 10`. Trong mỗi vòng lặp, giá trị của `i` được cộng vào biến `s`. Ban đầu, `s = 0`.

- Lần lặp 1: `i = 0`, `s = 0 + 0 = 0`
- Lần lặp 2: `i = 1`, `s = 0 + 1 = 1`
- Lần lặp 3: `i = 2`, `s = 1 + 2 = 3`
- Lần lặp 4: `i = 3`, `s = 3 + 3 = 6`
- Lần lặp 5: `i = 4`, `s = 6 + 4 = 10`
- Lần lặp 6: `i = 5`, `s = 10 + 5 = 15`
- Lần lặp 7: `i = 6`, `s = 15 + 6 = 21`
- Lần lặp 8: `i = 7`, `s = 21 + 7 = 28`
- Lần lặp 9: `i = 8`, `s = 28 + 8 = 36`
- Lần lặp 10: `i = 9`, `s = 36 + 9 = 45`

Vậy, sau khi vòng lặp kết thúc, giá trị của `s` là 45.

Đoạn code khởi tạo một mảng `mang` gồm 10 phần tử kiểu `int`. Sau đó, nó sử dụng vòng lặp `for-each` để duyệt qua mảng. Tuy nhiên, có một điểm quan trọng là trong vòng lặp, giá trị của `i` (biến lặp) được gán bằng `++j`. Biến `j` được tăng lên 1 trước khi gán cho `i`. Giá trị của `i` chỉ thay đổi trong phạm vi vòng lặp, không ảnh hưởng đến giá trị thực tế của các phần tử trong mảng `mang`. Biến `s` được dùng để tính tổng các giá trị của `i` trong mỗi lần lặp. Vì vậy, đoạn code này tính tổng các số từ 1 đến 10, chứ không phải tính tổng các phần tử của mảng `mang` (vì các phần tử của mảng không bị thay đổi).

* Khởi tạo mảng: `int[] mang = new int[10]` tạo một mảng gồm 10 số nguyên, tất cả đều có giá trị mặc định là 0.
* Khởi tạo biến: `int s = 0;` và `int j = 0;` khởi tạo biến `s` để lưu tổng và biến `j` để đếm.
* Vòng lặp: `for (int i: mang)` lặp qua từng phần tử của mảng `mang`. Tuy nhiên, việc gán `i = ++j;` chỉ thay đổi giá trị của biến `i` trong vòng lặp, chứ không thay đổi giá trị của phần tử trong mảng `mang`. Giá trị của `j` tăng lên mỗi lần lặp, và giá trị này được cộng vào `s`.
* Tính tổng: `s += i;` cộng giá trị hiện tại của `i` (là giá trị của `j` sau khi tăng) vào `s`.
* In kết quả: `System.out.println("S = " + s);` in ra giá trị của `s`, là tổng các số từ 1 đến 10.

Vì vậy, đáp án chính xác nhất là B. Tính tổng mảng nguyên một cách gián tiếp thông qua biến j. Mảng các phần tử vẫn có giá trị mặc định là 0.