covariante return typen... Het klinkt heel stoer, maar het is vrij simpel

. Het komt er op neer dat je methoden van interfaces mag implementeren met een specifieker return type (of methoden mag overriden met een specifieker return type).
Stel dat je bijvoorbeeld een interface hebt:
code:
1
2
3
4
| interface Bla
{
Collection getCollection()
} |
dan mag je deze implementeren met een Collection of een extensie daarvan:
code:
1
2
3
4
| class Boeh implements Bla
{
List getCollection();
} |
Je zou zeggen dat dit altijd mogelijk zou moeten zijn, maar in Java is dat nu dus niet zo (net als in C# en veel andere talen). Ook zou je kunnen zeggen, wat heb je hier nu aan? Soms heb je er heel erg veel aan

. Zeker in combinatie met geparameterizeerde typen is het uitermate nuttig.
Je hebt ook contravariante argumenttypen, daarbij mag je een methode implementeren met een algemener argument type (hierbij is dit dus precies andersom, waarom dat is, is grappig om ff over na te denken).
Zowel covariante return typen als contravariante argument typen zijn volledig type safe en zorgen in geen enkel geval voor incorrecte situaties.