Một loại nguyên liệu là gì?
Đặc tả ngôn ngữ Java định nghĩa một kiểu thô như sau:
Một loại nguyên được định nghĩa là một trong:
Kiểu tham chiếu được hình thành bằng cách lấy tên của khai báo kiểu chung mà không có danh sách đối số kiểu đi kèm.
Một kiểu mảng có kiểu phần tử là kiểu thô.
Một loại không phải là staticthành viên của một loại thô Rkhông được kế thừa từ một siêu lớp hoặc siêu giao diện của R.
Đây là một ví dụ để minh họa:
public class MyType<E> {
class Inner { }
static class Nested { }
public static void main(String[] args) {
MyType mt; // warning: MyType is a raw type
MyType.Inner inn; // warning: MyType.Inner is a raw type
MyType.Nested nest; // no warning: not parameterized type
MyType<Object> mt1; // no warning: type parameter given
MyType<?> mt2; // no warning: type parameter given (wildcard OK!)
}
}
Ở đây, MyType<E>là một loại tham số ( JLS 4.5 ). Thông thường người ta thường gọi loại này là đơn giản MyType, nhưng về mặt kỹ thuật thì tên này là MyType<E>.
mt có một kiểu thô (và tạo cảnh báo biên dịch) bởi dấu đầu dòng đầu tiên trong định nghĩa trên; inncũng có một loại nguyên bởi điểm đạn thứ ba.
MyType.Nestedkhông phải là loại tham số, mặc dù đó là loại thành viên của loại được tham số hóa MyType<E>, bởi vì đó là loạistatic .
mt1và mt2cả hai đều được khai báo với các tham số loại thực tế, vì vậy chúng không phải là loại thô.
Có gì đặc biệt về các loại nguyên liệu?
Về cơ bản, các kiểu thô hoạt động giống như trước khi thuốc generic được giới thiệu. Đó là, sau đây là hoàn toàn hợp pháp tại thời gian biên dịch.
List names = new ArrayList(); // warning: raw type!
names.add("John");
names.add("Mary");
names.add(Boolean.FALSE); // not a compilation error!
Đoạn mã trên chỉ chạy tốt, nhưng giả sử bạn cũng có những điều sau đây:
for (Object o : names) {
String name = (String) o;
System.out.println(name);
} // throws ClassCastException!
// java.lang.Boolean cannot be cast to java.lang.String
Bây giờ chúng tôi gặp rắc rối vào thời gian chạy, bởi vì namescó chứa một cái gì đó không phải là một instanceof String.
Có lẽ, nếu bạn chỉ muốn nameschứa String, có lẽ bạn vẫn có thể sử dụng loại thô và tự kiểm tra thủ công add , sau đó tự đúc cho Stringmọi mục từ đó names. Thậm chí tốt hơn là KHÔNG sử dụng một kiểu thô và để trình biên dịch thực hiện tất cả công việc cho bạn , khai thác sức mạnh của các tổng quát Java.
List<String> names = new ArrayList<String>();
names.add("John");
names.add("Mary");
names.add(Boolean.FALSE); // compilation error!
Tất nhiên, nếu bạn DO muốn namesđể cho phép một Boolean, sau đó bạn có thể khai báo nó nhưList<Object> names , và các mã trên sẽ biên dịch.
Xem thêm
Làm thế nào một loại thô khác với việc sử dụng <Object>như tham số loại?
Sau đây là trích dẫn từ Phiên bản Java hiệu quả thứ 2, Mục 23: Không sử dụng các loại thô trong mã mới :
Sự khác biệt giữa loại thô Listvà loại tham số là List<Object>gì? Nói một cách lỏng lẻo, cái trước đã từ chối kiểm tra loại chung, trong khi cái sau nói rõ ràng với trình biên dịch rằng nó có khả năng giữ các đối tượng thuộc bất kỳ loại nào. Trong khi bạn có thể truyền một List<String>tham số loại List, bạn không thể chuyển nó sang tham số loại List<Object>. Có các quy tắc phân nhóm cho generic, và List<String>là một kiểu con của kiểu thô List, nhưng không phải là kiểu tham số List<Object>. Hậu quả là bạn mất an toàn kiểu nếu bạn sử dụng kiểu thô như thế List, nhưng không mất nếu bạn sử dụng kiểu tham số nhưList<Object> .
Để minh họa điểm, hãy xem xét phương pháp sau đây lấy List<Object>và nối thêm a new Object().
void appendNewObject(List<Object> list) {
list.add(new Object());
}
Generics trong Java là bất biến. A List<String>không phải là một List<Object>, vì vậy, sau đây sẽ tạo ra một cảnh báo trình biên dịch:
List<String> names = new ArrayList<String>();
appendNewObject(names); // compilation error!
Nếu bạn đã tuyên bố appendNewObjectlấy một kiểu thô Listlàm tham số, thì điều này sẽ biên dịch và do đó bạn sẽ mất đi sự an toàn của loại mà bạn nhận được từ thuốc generic.
Xem thêm
Làm thế nào là một loại thô khác với việc sử dụng <?>như một tham số loại?
List<Object>, List<String>v.v ... là tất cả List<?>, vì vậy có thể rất hấp dẫn khi chỉ nói rằng họ chỉ là Listthay thế. Tuy nhiên, có một sự khác biệt lớn: vì chỉ một List<E>định nghĩa add(E), bạn không thể thêm bất kỳ đối tượng tùy ý nào vào a List<?>. Mặt khác, vì loại thô Listkhông có loại an toàn, bạn có thể có addbất cứ thứ gì để a List.
Hãy xem xét các biến thể sau của đoạn trước:
static void appendNewObject(List<?> list) {
list.add(new Object()); // compilation error!
}
//...
List<String> names = new ArrayList<String>();
appendNewObject(names); // this part is fine!
Trình biên dịch đã làm một công việc tuyệt vời để bảo vệ bạn khỏi khả năng vi phạm kiểu bất biến của List<?>! Nếu bạn đã khai báo tham số là kiểu thô List list, thì mã sẽ biên dịch và bạn vi phạm loại bất biến List<String> names.
Một loại thô là tẩy xóa của loại đó
Quay lại JLS 4.8:
Có thể sử dụng như một kiểu xóa của một kiểu tham số hóa hoặc xóa một kiểu mảng có kiểu phần tử là kiểu tham số. Một loại như vậy được gọi là một loại thô .
[...]
Các siêu lớp (tương ứng, các siêu giao diện) của một loại thô là sự xóa của các siêu lớp (siêu giao diện) của bất kỳ tham số nào của loại chung.
Kiểu của hàm tạo, phương thức cá thể hoặc statictrường không thuộc loại thô Ckhông được kế thừa từ siêu lớp hoặc siêu giao diện của nó là kiểu thô tương ứng với kiểu xóa của loại đó trong khai báo chung tương ứng với C.
Nói một cách đơn giản hơn, khi một kiểu thô được sử dụng, các hàm tạo, phương thức cá thể và các statictrường không phải cũng bị xóa .
Lấy ví dụ sau:
class MyType<E> {
List<String> getNames() {
return Arrays.asList("John", "Mary");
}
public static void main(String[] args) {
MyType rawType = new MyType();
// unchecked warning!
// required: List<String> found: List
List<String> names = rawType.getNames();
// compilation error!
// incompatible types: Object cannot be converted to String
for (String str : rawType.getNames())
System.out.print(str);
}
}
Khi chúng ta sử dụng phần thô MyType, getNamescũng bị xóa, để nó trả về phần thô List!
JLS 4.6 tiếp tục giải thích như sau:
Kiểu xóa cũng ánh xạ chữ ký của hàm tạo hoặc phương thức sang chữ ký không có kiểu tham số hoặc biến kiểu. Việc xóa chữ ký của hàm tạo hoặc chữ ký phương thức slà một chữ ký bao gồm cùng tên svà độ xóa của tất cả các kiểu tham số chính thức được cho trong s.
Kiểu trả về của một phương thức và các tham số loại của một phương thức chung hoặc hàm tạo cũng trải qua việc xóa nếu chữ ký của phương thức hoặc hàm tạo bị xóa.
Việc xóa chữ ký của một phương thức chung không có tham số kiểu.
Báo cáo lỗi sau đây chứa một số suy nghĩ từ Maurizio Cimadamore, một nhà biên dịch và Alex Buckley, một trong những tác giả của JLS, về lý do tại sao loại hành vi này phải xảy ra: https://bugs.openjdk.java.net/browse / JDK-6400189 . (Nói tóm lại, nó làm cho đặc tả đơn giản hơn.)
Nếu nó không an toàn, tại sao nó được phép sử dụng loại thô?
Đây là một trích dẫn khác từ JLS 4.8:
Việc sử dụng các loại thô chỉ được phép như một sự nhượng bộ cho tính tương thích của mã kế thừa. Việc sử dụng các kiểu thô trong mã được viết sau khi đưa tính tổng quát vào ngôn ngữ lập trình Java được khuyến khích mạnh mẽ. Có thể các phiên bản tương lai của ngôn ngữ lập trình Java sẽ không cho phép sử dụng các kiểu thô.
Phiên bản Java 2 hiệu quả cũng có thêm điều này:
Cho rằng bạn không nên sử dụng các loại thô, tại sao các nhà thiết kế ngôn ngữ cho phép chúng? Để cung cấp khả năng tương thích.
Nền tảng Java sắp bước vào thập kỷ thứ hai khi các thế hệ được giới thiệu và có một lượng lớn mã Java tồn tại không sử dụng chung chung. Nó được coi là quan trọng rằng tất cả các mã này vẫn hợp pháp và có thể tương thích với mã mới sử dụng thuốc generic. Nó phải là hợp pháp để chuyển các thể hiện của các loại tham số cho các phương thức được thiết kế để sử dụng với các loại thông thường và ngược lại. Yêu cầu này, được gọi là khả năng tương thích di chuyển , đã đưa ra quyết định hỗ trợ các loại thô.
Tóm lại, các kiểu thô KHÔNG BAO GIỜ được sử dụng trong mã mới. Bạn nên luôn luôn sử dụng các loại tham số .
Không có ngoại lệ?
Thật không may, vì các tổng quát Java không được thống nhất, nên có hai trường hợp ngoại lệ trong đó các kiểu thô phải được sử dụng trong mã mới:
- Lớp học, ví dụ
List.class, khôngList<String>.class
instanceoftoán hạng, ví dụ o instanceof Set, khôngo instanceof Set<String>
Xem thêm