Tại sao tôi phải quan tâm rằng Java không có các generic được sửa đổi?

Đây là một câu hỏi mà tôi đã hỏi trong một cuộc phỏng vấn gần đây như một thứ mà ứng viên muốn thấy được thêm vào ngôn ngữ Java. Nó thường được xác định là một nỗi đau mà Java không có các generic được sửa đổi lại, nhưng khi được thúc đẩy, ứng viên không thể thực sự cho tôi biết loại thứ mà anh ta có thể đạt được khi họ ở đó.

Rõ ràng là vì các kiểu thô được cho phép trong Java (và các kiểm tra không an toàn), nên có thể lật ngược các loại chung và kết thúc bằng một loại List<Integer>(ví dụ) thực sự chứaString s. Điều này rõ ràng có thể được thực hiện không thể được sửa đổi thông tin loại; nhưng phải có nhiều hơn thế này !

Mọi người có thể đăng ví dụ về những điều mà họ thực sự muốn làm , có sẵn các chỉ số chung được sửa đổi không? Ý tôi là, rõ ràng bạn có thể nhận được loại a Listtrong thời gian chạy - nhưng bạn sẽ làm gì với nó?

public <T> void foo(List<T> l) {
   if (l.getGenericType() == Integer.class) {
       //yeah baby! err, what now?

CHỈNH SỬA : Cập nhật nhanh điều này vì các câu trả lời dường như chủ yếu quan tâm đến nhu cầu chuyển vào một Classdưới dạng tham số (ví dụ EnumSet.noneOf(TimeUnit.class)). Tôi đã tìm kiếm nhiều hơn cho một cái gì đó dọc theo ranh giới mà điều này không thể thực hiện được . Ví dụ:

List<?> l1 = api.gimmeAList();
List<?> l2 = api.gimmeAnotherList();

if (l1.getGenericType().isAssignableFrom(l2.getGenericType())) {
    l1.addAll(l2); //why on earth would I be doing this anyway?

Từ một vài lần mà tôi bắt gặp "nhu cầu" này, cuối cùng nó kết thúc với cấu trúc này:

public class Foo<T> {

    private T t;

    public Foo() {
        this.t = new T(); // Help?
    }

}

Điều này hoạt động trong C # giả sử rằng nó Tcó một hàm tạo mặc định . Bạn thậm chí có thể lấy kiểu thời gian chạy typeof(T)và lấy các hàm tạo bằng Type.GetConstructor().

Giải pháp Java phổ biến sẽ là chuyển Class<T>đối số dưới dạng.

public class Foo<T> {

    private T t;

    public Foo(Class<T> cls) throws Exception {
        this.t = cls.newInstance();
    }

}

(nó không nhất thiết phải được truyền dưới dạng đối số hàm tạo, vì đối số phương thức cũng tốt, ở trên chỉ là một ví dụ, cũng try-catchđược bỏ qua cho ngắn gọn)

Đối với tất cả các cấu trúc kiểu chung khác, kiểu thực tế có thể dễ dàng được giải quyết với một chút trợ giúp của sự phản ánh. Phần Hỏi & Đáp dưới đây minh họa các trường hợp sử dụng và khả năng:

• Nhận loại java.util.List chung
• Làm cách nào để lấy kiểu chung trong thời gian chạy?
• Nhận kiểu thực tế của đối số kiểu chung trên lớp cha trừu tượng

Điều mà tôi thường gặp nhất là không có khả năng tận dụng nhiều công văn trên nhiều loại chung chung. Những điều sau đây là không thể và có nhiều trường hợp nó sẽ là giải pháp tốt nhất:

public void my_method(List<String> input) { ... }
public void my_method(List<Integer> input) { ... }

Loại an toàn được nghĩ đến. Việc hạ cấp xuống một loại tham số sẽ luôn không an toàn nếu không có các chỉ số chung được sửa đổi:

List<String> myFriends = new ArrayList();
myFriends.add("Alice");
getSession().put("friends", myFriends);
// later, elsewhere
List<Friend> myFriends = (List<Friend>) getSession().get("friends");
myFriends.add(new Friend("Bob")); // works like a charm!
// and so...
List<String> myFriends = (List<String>) getSession().get("friends");
for (String friend : myFriends) print(friend); // ClassCastException, wtf!? 

Cũng thế, tóm tắt sẽ ít bị rò rỉ hơn - ít nhất là những phần có thể quan tâm đến thông tin thời gian chạy về các tham số kiểu của chúng. Ngày nay, nếu bạn cần bất kỳ loại thông tin thời gian chạy nào về loại của một trong các tham số chung, bạn cũng phải chuyển nó Classtheo. Bằng cách đó, giao diện bên ngoài của bạn phụ thuộc vào việc triển khai của bạn (cho dù bạn có sử dụng RTTI về các tham số của mình hay không).

Bạn có thể tạo các mảng chung trong mã của mình.

public <T> static void DoStuff() {
    T[] myArray = new T[42]; // No can do
}

Đây là một câu hỏi cũ, có rất nhiều câu trả lời, nhưng tôi nghĩ rằng các câu trả lời hiện có là không đúng.

"reified" chỉ có nghĩa là thực và thường chỉ có nghĩa ngược lại với loại tẩy.

Vấn đề lớn liên quan đến Java Generics:

• Yêu cầu quyền anh khủng khiếp này và sự ngắt kết nối giữa các loại nguyên thủy và các loại tham chiếu. Điều này không liên quan trực tiếp đến việc sửa đổi hoặc tẩy xóa loại. C # / Scala sửa lỗi này.
• Không có tự loại. JavaFX 8 đã phải loại bỏ "người xây dựng" vì lý do này. Hoàn toàn không liên quan đến tẩy xóa kiểu chữ. Scala sửa lỗi này, không chắc chắn về C #.
• Không có phương sai loại bên khai báo. C # 4.0 / Scala có cái này. Hoàn toàn không liên quan đến tẩy xóa kiểu chữ.
• Không thể quá tải void method(List<A> l)và method(List<B> l). Đây là do tẩy xóa kiểu nhưng cực kỳ nhỏ.
• Không hỗ trợ phản chiếu kiểu thời gian chạy. Đây là trọng tâm của loại tẩy. Nếu bạn thích trình biên dịch siêu nâng cao xác minh và chứng minh càng nhiều logic chương trình của bạn tại thời điểm biên dịch, bạn nên sử dụng phản chiếu càng ít càng tốt và kiểu xóa kiểu này sẽ không làm phiền bạn. Nếu bạn thích lập trình kiểu động, chắp vá, phức tạp hơn và không quan tâm nhiều đến việc trình biên dịch chứng minh càng nhiều logic của bạn càng chính xác càng tốt, thì bạn muốn phản ánh tốt hơn và việc sửa lỗi xóa là quan trọng.

Serialization sẽ đơn giản hơn với việc sửa đổi. Những gì chúng tôi muốn là

deserialize(thingy, List<Integer>.class);

Những gì chúng ta phải làm là

deserialize(thing, new TypeReference<List<Integer>>(){});

trông xấu xí và hoạt động vui nhộn.

Cũng có những trường hợp sẽ thực sự hữu ích nếu nói những điều như

public <T> void doThings(List<T> thingy) {
    if (T instanceof Q)
      doCrazyness();
  }

Những thứ này không cắn thường xuyên, nhưng chúng sẽ cắn khi chúng xảy ra.

Khả năng tiếp xúc của tôi với Java Geneircs là khá hạn chế, và ngoài những điểm mà các câu trả lời khác đã đề cập, có một kịch bản được giải thích trong cuốn sách Java Generics and Collections , bởi Maurice Naftalin và Philip Walder, nơi mà những generic được sửa lại rất hữu ích.

Vì không thể tái định danh các loại, nên không thể có ngoại lệ Tham số hóa.

Ví dụ, khai báo của biểu mẫu dưới đây không hợp lệ.

class ParametericException<T> extends Exception // compile error

Điều này là do mệnh đề bắt kiểm tra xem ngoại lệ được ném có khớp với một kiểu nhất định hay không. Kiểm tra này cũng giống như kiểm tra được thực hiện bởi kiểm tra mẫu và vì kiểu này không thể tái lập nên biểu mẫu trên không hợp lệ.

Nếu mã trên là hợp lệ thì việc xử lý ngoại lệ theo cách dưới đây sẽ có thể thực hiện được:

try {
     throw new ParametericException<Integer>(42);
} catch (ParametericException<Integer> e) { // compile error
  ...
}

Cuốn sách cũng đề cập rằng nếu các tổng thể Java được định nghĩa tương tự như cách các mẫu C ++ được định nghĩa (mở rộng), nó có thể dẫn đến việc triển khai hiệu quả hơn vì điều này mang lại nhiều cơ hội hơn để tối ưu hóa. Nhưng không cung cấp bất kỳ lời giải thích nào hơn thế này, vì vậy bất kỳ lời giải thích nào (gợi ý) từ những người hiểu biết sẽ hữu ích.

Mảng có thể sẽ hoạt động tốt hơn nhiều với generic nếu chúng được sửa đổi.

Tôi có một trình bao bọc trình bày một tập kết quả jdbc như một trình lặp, (điều đó có nghĩa là tôi có thể kiểm tra đơn vị các hoạt động bắt nguồn từ cơ sở dữ liệu dễ dàng hơn rất nhiều thông qua chèn phụ thuộc).

API trông giống như Iterator<T> trong đó T là một số kiểu có thể được xây dựng chỉ bằng cách sử dụng các chuỗi trong hàm tạo. Sau đó, Iterator xem xét các chuỗi được trả về từ truy vấn sql và sau đó cố gắng so khớp nó với một phương thức khởi tạo kiểu T.

Theo cách hiện tại mà các generic được triển khai, tôi cũng phải chuyển vào lớp các đối tượng mà tôi sẽ tạo từ tập kết quả của mình. Nếu tôi hiểu đúng, nếu generic được sửa đổi, tôi chỉ có thể gọi T.getClass () lấy các hàm tạo của nó và sau đó không phải ép kiểu kết quả của Class.newInstance (), sẽ gọn gàng hơn nhiều.

Về cơ bản, tôi nghĩ nó làm cho việc viết API (thay vì chỉ viết một ứng dụng) dễ dàng hơn, vì bạn có thể suy luận nhiều hơn từ các đối tượng và do đó sẽ cần ít cấu hình hơn ... Tôi không đánh giá cao ý nghĩa của chú thích cho đến khi tôi đã thấy chúng được sử dụng trong những thứ như spring hoặc xstream thay vì hàng loạt cấu hình.

Một điều tốt đẹp sẽ là tránh quyền anh cho các loại (giá trị) nguyên thủy. Điều này phần nào liên quan đến khiếu nại về mảng mà những người khác đã nêu ra và trong trường hợp việc sử dụng bộ nhớ bị hạn chế, nó thực sự có thể tạo ra sự khác biệt đáng kể.

Cũng có một số loại vấn đề khi viết một khung công tác trong đó khả năng phản ánh qua kiểu tham số hóa là rất quan trọng. Tất nhiên điều này có thể được giải quyết bằng cách truyền một đối tượng lớp xung quanh trong thời gian chạy, nhưng điều này che khuất API và tạo thêm gánh nặng cho người dùng của khung.

Không phải là bạn sẽ đạt được bất cứ điều gì phi thường. Nó sẽ đơn giản hơn để hiểu. Xóa kiểu có vẻ như là một thời gian khó khăn cho người mới bắt đầu và cuối cùng nó đòi hỏi sự hiểu biết của một người về cách thức hoạt động của trình biên dịch.

Ý kiến ​​của tôi là, generic chỉ đơn giản là một phần bổ sung giúp tiết kiệm rất nhiều việc đúc dư thừa.

Một cái gì đó mà tất cả các câu trả lời ở đây đã bỏ lỡ khiến tôi liên tục đau đầu là vì các loại bị xóa, bạn không thể kế thừa một giao diện chung hai lần. Đây có thể là một vấn đề khi bạn muốn tạo giao diện chi tiết.

    public interface Service<KEY,VALUE> {
           VALUE get(KEY key);
    }

    public class PersonService implements Service<Long, Person>,
        Service<String, Person> //Can not do!!

Đây là một trong những điều khiến tôi chú ý hôm nay: mà không cần sửa đổi, nếu bạn viết một phương thức chấp nhận một danh sách kỳ lạ của các mục chung chung ... người gọi có thể NGHĨ chúng là loại an toàn, nhưng vô tình vượt qua bất kỳ thứ gì cũ kỹ và làm hỏng phương pháp của bạn.

Có vẻ như điều đó sẽ không xảy ra? ... Chắc chắn rồi, cho đến khi ... bạn sử dụng Lớp làm kiểu dữ liệu của mình. Tại thời điểm này, người gọi của bạn sẽ vui vẻ gửi cho bạn nhiều đối tượng Lớp, nhưng một lỗi đánh máy đơn giản sẽ gửi cho bạn các đối tượng Lớp không tuân theo T và thảm họa sẽ xảy ra.

(NB: Tôi có thể đã nhầm lẫn ở đây, nhưng tìm kiếm xung quanh "generics varargs", những điều ở trên dường như chỉ là những gì bạn mong đợi. Điều làm cho vấn đề này trở thành một vấn đề thực tế là việc sử dụng Class, tôi nghĩ - những người gọi dường như để bớt cẩn thận :()

Ví dụ, tôi đang sử dụng một mô hình sử dụng các đối tượng Lớp làm khóa trong bản đồ (nó phức tạp hơn một bản đồ đơn giản - nhưng về mặt khái niệm thì đó là những gì đang xảy ra).

ví dụ: điều này hoạt động tốt trong Java Generics (ví dụ nhỏ):

public <T extends Component> Set<UUID> getEntitiesPossessingComponent( Class<T> componentType)
    {
        // find the entities that are mapped (somehow) from that class. Very type-safe
    }

ví dụ như không sửa đổi trong Java Generics, cái này chấp nhận BẤT KỲ đối tượng "Lớp" nào. Và nó chỉ là một phần mở rộng nhỏ của mã trước đó:

public <T extends Component> Set<UUID> getEntitiesPossessingComponents( Class<T>... componentType )
    {
        // find the entities that are mapped (somehow) to ALL of those classes
    }

Các phương pháp trên phải được viết ra hàng nghìn lần trong một dự án riêng lẻ - do đó, khả năng xảy ra lỗi của con người là rất cao. Gỡ lỗi cho những sai lầm được chứng minh là "không vui". Tôi hiện đang cố gắng tìm một giải pháp thay thế, nhưng không có nhiều hy vọng.