Скачать или смотреть Understanding Java Generics: Why List Object Cannot Accept List A in Java

Uncover the intricacies of Java generics with a deep dive into why a method accepting `List Object ` can't also take `List A `. Gain clarity on covariance, contravariance, and invariance as we break it down simply.
---
This video is based on the question https://stackoverflow.com/q/63752786/ asked by the user 'Yulin' ( https://stackoverflow.com/u/8200378/ ) and on the answer https://stackoverflow.com/a/63752865/ provided by the user 'rzwitserloot' ( https://stackoverflow.com/u/768644/ ) at 'Stack Overflow' website. Thanks to these great users and Stackexchange community for their contributions.

Visit these links for original content and any more details, such as alternate solutions, latest updates/developments on topic, comments, revision history etc. For example, the original title of the Question was: Why method with argument List Object can not accept a list of any type like List A as argument in java?

Also, Content (except music) licensed under CC BY-SA https://meta.stackexchange.com/help/l...
The original Question post is licensed under the 'CC BY-SA 4.0' ( https://creativecommons.org/licenses/... ) license, and the original Answer post is licensed under the 'CC BY-SA 4.0' ( https://creativecommons.org/licenses/... ) license.

If anything seems off to you, please feel free to write me at vlogize [AT] gmail [DOT] com.
---
Understanding Java Generics: Why List<Object> Cannot Accept List<A> in Java

Java is a powerful programming language, but like any other, it comes with its peculiarities and complexities. One such complexity arises when we deal with generics. A commonly asked question among developers is: Why can't a method that takes a List<Object> argument also accept a List<A> like other object types?

The Problem Explained

When you have a method defined as void m0(List<Object> lst), it might seem logical to pass a List<Integer> to it (since integers are objects too). However, this leads to a compilation error. In contrast, if you had a method defined as void m0(Object a), passing an integer like m0(1); is perfectly valid. This raises a fundamental question about how Java treats types and generics.

The Concept of Variance

The key to understanding this issue lies in a concept called variance. Variance describes how type relationships work in programming languages. In Java, this is essential because:

Covariance allows for type substitution in a certain way.

Contravariance restricts certain types from being mixed together.

Invariance states a case where neither substitution nor mixing is permitted.

Covariance

In a covariant system:

[[See Video to Reveal this Text or Code Snippet]]

This is allowed because you can substitute Integer, which extends Number. However:

[[See Video to Reveal this Text or Code Snippet]]

Contravariance

In a contravariant system, you face the opposite:

[[See Video to Reveal this Text or Code Snippet]]

Invariance

In an invariant case, the following is the only valid structure:

[[See Video to Reveal this Text or Code Snippet]]

Generics in Java

While Java supports covariance for basic types, it approaches generics differently. Generics are primarily invariant unless otherwise specified. Here's how:

Covariant Example:

[[See Video to Reveal this Text or Code Snippet]]

Contravariant Example:

[[See Video to Reveal this Text or Code Snippet]]

Invariant Example:

[[See Video to Reveal this Text or Code Snippet]]

Why the Restriction on List<Object>

When you declare a method that takes List<Object> as an argument, you restrict its use to only lists that specifically hold Object. This means that an instance of List<Integer> is not a valid input for List<Object> because generics in Java are invariant.

Impact of Invariance

If Java allowed List<Integer> to be passed into List<Object>, it would break type safety. For example:

[[See Video to Reveal this Text or Code Snippet]]

This would lead to potential run-time errors when expecting an Integer but receiving a Double.

Finding Workarounds

If your method m0 only needs to read items from a list, you can change its definition:

[[See Video to Reveal this Text or Code Snippet]]

Using the wildcard ? allows you to accept any type of list, even List<String>, while still preventing any addition to the list that could violate type safety.

Conclusion

Understanding the nuances of Java's generics system, especially about covariance, contravariance, and invariance, is crucial for developing robust applications. By grasping these concepts, you can write cleaner code while efficiently handling type constraints in Java collections. Remember, generics support type safety, and these rules are in place to protect you from runtime errors.

By acknowledging these rules, you're not just playing with syntax — you're mastering the art of Java programming.