Give examples of functions which demonstrate covariance and contravariance in the cases of both overloading and overriding in Java? [closed]

Covariance:

class Super {
  Object getSomething(){}
}
class Sub extends Super {
  String getSomething() {}
}

Sub#getSomething is covariant because it returns a subclass of the return type of Super#getSomething (but fullfills the contract of Super.getSomething())

Contravariance

class Super{
  void doSomething(String parameter)
}
class Sub extends Super{
  void doSomething(Object parameter)
}

Sub#doSomething is contravariant because it takes a parameter of a superclass of the parameter of Super#doSomething (but, again, fullfills the contract of Super#doSomething)

Notice: this example doesn’t work in Java. The Java compiler would overload and not override the doSomething()-Method. Other languages do support this style of contravariance.

Generics

This is also possible for Generics:

List<String> aList...
List<? extends Object> covariantList = aList;
List<? super String> contravariantList = aList;

You can now access all methods of covariantList that doesn’t take a generic parameter (as it must be something “extends Object”), but getters will work fine (as the returned object will always be of type “Object”)

The opposite is true for contravariantList: You can access all methods with generic parameters (you know it must be a superclass of “String”, so you can always pass one), but no getters (The returned type may be of any other supertype of String)