{"id":1964,"date":"2025-06-14T13:13:45","date_gmt":"2025-06-14T01:13:45","guid":{"rendered":"https:\/\/www.ronella.xyz\/?p=1964"},"modified":"2025-06-14T13:13:45","modified_gmt":"2025-06-14T01:13:45","slug":"understanding-covariance-invariance-and-contravariance-in-java-generics","status":"publish","type":"post","link":"https:\/\/www.ronella.xyz\/?p=1964","title":{"rendered":"Understanding Covariance, Invariance, and Contravariance in Java Generics"},"content":{"rendered":"

Java generics are a powerful feature that enable developers to write flexible, type-safe code. However, when it comes to subtyping and how generic types relate to each other, things can get a bit tricky. Three key concepts\u2014covariance<\/strong>, invariance<\/strong>, and contravariance<\/strong>\u2014help explain how generics behave in different scenarios. Let\u2019s break down each one with clear explanations and examples.<\/p>\n

\n

Invariance: The Default Behavior<\/h2>\n

In Java, generics are invariant<\/strong> by default. This means that even if one type is a subtype of another, their corresponding generic types are not related.<\/p>\n

Example:<\/h3>\n
List<Number> numbers = new ArrayList<Integer>(); \/\/ Compilation error!<\/code><\/pre>\n
Even though Integer<\/code> is a subtype of Number<\/code>, List<Integer><\/code> is not<\/strong> a subtype of List<Number><\/code>. This strictness ensures type safety, preventing accidental misuse of collections.<\/p>\n
\n
Covariance: Flexibility with Reading<\/h2>\n
Covariance allows a generic type to be a subtype if its type parameter is a subtype. In Java, you express covariance with the wildcard ? extends Type<\/code>.<\/p>\n
Example:<\/h3>\n
List<? extends Number> numbers = new ArrayList<Integer>();<\/code><\/pre>\n
Here, numbers<\/code> can point to a List<Integer><\/code>, List<Double><\/code>, or any other list whose elements extend Number<\/code>. However, you cannot add<\/strong> elements to numbers<\/code> (except null<\/code>) because the actual list could be of any subtype of Number<\/code>. You can<\/strong> read elements as Number<\/code>.<\/p>\n
Use covariance when you only need to read from a structure, not write to it.<\/strong><\/p>\n
\n
Contravariance: Flexibility with Writing<\/h2>\n
Contravariance is the opposite of covariance. It allows a generic type to be a supertype if its type parameter is a supertype. In Java, you use ? super Type<\/code> for contravariance.<\/p>\n
Example:<\/h3>\n
List<? super Integer> integers = new ArrayList<Number>();\nintegers.add(1); \/\/ OK\nObject obj = integers.get(0); \/\/ Allowed\nInteger num = integers.get(0); \/\/ Compilation error!<\/code><\/pre>\n
Here, integers<\/code> can point to a List<Integer><\/code>, List<Number><\/code>, or even a List<Object><\/code>. You can add<\/strong> Integer<\/code> values, but when you retrieve them, you only know they are Object<\/code>.<\/p>\n
Use contravariance when you need to write to a structure, but not read specific types from it.<\/strong><\/p>\n
\n
Summary Table<\/h2>\n\n\n\n\n\n\n\n
Variance<\/th>\nSyntax<\/th>\nCan Read<\/th>\nCan Write<\/th>\nExample<\/th>\n<\/tr>\n<\/thead>\n
Invariant<\/td>\nList<T><\/code><\/td>\nYes<\/td>\nYes<\/td>\nList<Integer><\/code><\/td>\n<\/tr>\n
Covariant<\/td>\nList<? extends T><\/code><\/td>\nYes<\/td>\nNo<\/td>\nList<? extends Number><\/code><\/td>\n<\/tr>\n
Contravariant<\/td>\nList<? super T><\/code><\/td>\nNo*<\/td>\nYes<\/td>\nList<? super Integer><\/code><\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n
*You can only read as Object<\/code>.<\/p>\n
\n
Conclusion<\/h2>\n
Understanding covariance, invariance, and contravariance is essential for mastering Java generics. Remember:<\/p>\n
    \n
  • Invariant<\/strong>: Exact type matches only.<\/li>\n
  • Covariant<\/strong> (? extends T<\/code>): Flexible for reading.<\/li>\n
  • Contravariant<\/strong> (? super T<\/code>): Flexible for writing.<\/li>\n<\/ul>\n
    By choosing the right variance for your use case, you can write safer and more expressive generic code in Java.<\/p>\n","protected":false},"excerpt":{"rendered":"
    Java generics are a powerful feature that enable developers to write flexible, type-safe code. However, when it comes to subtyping and how generic types relate to each other, things can get a bit tricky. Three key concepts\u2014covariance, invariance, and contravariance\u2014help explain how generics behave in different scenarios. Let\u2019s break down each one with clear explanations […]<\/p>\n","protected":false},"author":1,"featured_media":0,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":[],"categories":[17],"tags":[],"_links":{"self":[{"href":"https:\/\/www.ronella.xyz\/index.php?rest_route=\/wp\/v2\/posts\/1964"}],"collection":[{"href":"https:\/\/www.ronella.xyz\/index.php?rest_route=\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/www.ronella.xyz\/index.php?rest_route=\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/www.ronella.xyz\/index.php?rest_route=\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/www.ronella.xyz\/index.php?rest_route=%2Fwp%2Fv2%2Fcomments&post=1964"}],"version-history":[{"count":1,"href":"https:\/\/www.ronella.xyz\/index.php?rest_route=\/wp\/v2\/posts\/1964\/revisions"}],"predecessor-version":[{"id":1965,"href":"https:\/\/www.ronella.xyz\/index.php?rest_route=\/wp\/v2\/posts\/1964\/revisions\/1965"}],"wp:attachment":[{"href":"https:\/\/www.ronella.xyz\/index.php?rest_route=%2Fwp%2Fv2%2Fmedia&parent=1964"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.ronella.xyz\/index.php?rest_route=%2Fwp%2Fv2%2Fcategories&post=1964"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.ronella.xyz\/index.php?rest_route=%2Fwp%2Fv2%2Ftags&post=1964"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}