简体中文（ZH-CN）English（EN）繁体中文（ZH-TW）日本語（JA）한국어（KO）Melayu（MS）Français（FR）Deutsch（DE）
Home
Article
Q&A
Course
Topic
Download
Game
Dictionary
Recent Updates

Home  >  Article  >  Java  >  Variance in Java

Variance in Java

WBOY
WBOYforward
2023-09-01 13:05:06996browse

Variance in Java

With its powerful object-oriented programming capabilities, Java provides programmers with multiple mechanisms to develop flexible and efficient code. One of the often overlooked but crucial concepts is variance. Understanding variance is crucial to mastering Java, especially when working with generics and collections. This article takes an in-depth look at variance in Java, covering its types (covariance, contravariance, and invariance) and its practical applications.

Understanding variance

Variance refers to the relationship between subtypes of more complex types and the subtypes of their components. Simply put, it determines how the type hierarchy of classes is preserved when these classes are used as type parameters. Variants become particularly important when dealing with generics, providing a framework to ensure type safety while allowing a degree of flexibility in assignments.

Variance can be divided into three main types:

  • Covariance - If ClassB is a subclass of ClassA, then Collection can be considered a subclass of Collection.

  • Contravariance - If ClassB is a subclass of ClassA, then Collection can be considered a subclass of Collection. p>

  • Immutability - Collection and Collection have no subtype relationship, regardless of the relationship between ClassA and ClassB.

Let’s delve deeper into each concept.

Covariance in Java

In Java, covariance is achieved by using wildcards and the extends clause. Let us consider an example -

List<Animal> animals = new ArrayList<>();
<List<super Cat>cats=animals;

In this case, you can add a Cat object or any instance of it to cats, but you cannot read from cats and treat the result as Cat because it may contain any supertype of Cat, including Animal or Object . Therefore, you can write to cats, but you cannot read it in a type-safe manner

Immutability in Java

Immutability is the default behavior in Java and means that there is no subtyping relationship between Collection and Collection, regardless of the relationship between ClassA and ClassB. This may seem limiting, but it's crucial for type safety. In Java, List is not a subtype of List, although String is a subtype of Object. This is because Java collections are mutable and allowing this relationship will result in a runtime type error. 

List<String> strings = new ArrayList<>();
// Compile error: Incompatible types
List<Object> objects = strings;

In the above example, although String is a subtype of Object, List is not a subtype of List, so a compilation error occurs.

This feature may initially seem like a limitation, but it is an important aspect of the Java type system that ensures that unsafe operations are not performed. If List is a subtype of List, objects that are not strings can be added to List, causing a ClassCastException at run time. 

List<String> strings = new ArrayList<>();
// If this were allowed...
List<Object> objects = strings;
// ...this would put a non-String into a List<String>
objects.add(new Object());
String str= strings.get(0); // ClassCastException

This example illustrates why maintaining type-safe immutability is critical.

Bounded type parameters and variance

Covariance and contravariance are most commonly used for bounded type parameters. Bounded type parameters are a way of indicating that a type parameter must be a subtype (extends keyword) or a supertype (super keyword) of a certain type. This allows flexibility in deciding what types can be passed to methods while still maintaining type safety.

For example, you might have a method that operates on a list of Number and all its subclasses -

public <T extends Number> void processNumbers(List<T> numbers) { /* ... */ }

In this method, T is a bounded type parameter and must be Number or a subtype of Number. This allows the method to operate on List, List, List, etc., exhibiting covariance

in conclusion

In summary, understanding variance in Java is crucial to using generics and collections effectively. It allows flexible code while ensuring type safety.

Covariance, using the extends keyword, allows subclasses to replace superclasses, thereby achieving more general object processing. Contravariance, on the other hand, allows superclasses to be substituted for subclasses, enabling a wider range of operations to be performed on more specific objects.

Immutability maintains type safety by ensuring that collections of different types (even if related through inheritance) maintain their uniqueness and prevent runtime type errors.

对象>字符串>

对象>字符串>

The above is the detailed content of Variance in Java. For more information, please follow other related articles on the PHP Chinese website!

Java String Object 面向对象 子类 字符串 继承 Collection 泛型 number 对象
Statement：
This article is reproduced at:tutorialspoint.com. If there is any infringement, please contact admin@php.cn delete
Previous article：What is the way to handle errors generated when deserializing JSON in Java?Next article：What is the way to handle errors generated when deserializing JSON in Java?

Related articles

See more