Explanation of the get-put principle
generics, java
Solution
Consider a bunch of bananas. This is a `Collection<? extends Fruit>` in that it's a collection of a particular kind of fruit - but you don't know (from that declaration) what kind of fruit it's a collection of. You can get an item from it and know it will definitely be a fruit, but you can't add to it - you might be trying to add an apple to a bunch of bananas, which would definitely be wrong. You can add `null` to it, as that will be a valid value for any kind of fruit.
Now consider a fruitbowl. This is a `Collection<? super Banana>`, in that it's a collection of some type "greater than" `Banana` (for instance, `Collection<Fruit>` or `Collection<TropicalFruit>`). You can definitely add a banana to this, but if you fetch an item from the bowl you don't know what you'll get - it may well not be a banana. All you know for sure is that it will be a valid (possibly `null`) `Object` reference.
(In general, for Java generics questions, the Java Generics FAQ is an excellent resource which contains the answer to almost anything generics-related you're likely to throw at it.)
Problem
I have read O'Reilly book, in that I came to know this get-put principle. - Use an `extends` wildcard when you only get values out of a structure. - Use a `super` wildcard when you only put values into a structure. - And don't use a wildcard when you both want to get and put from/to a structure. Exceptions are: You cannot put anything into a type declared with an `extends` wildcard except for the value `null`, which belongs to every reference type. You cannot get anything out from a type declared with an `super` wildcard except for a value of type `Object`, which is a super type of every reference type. Can anyone help me to explore this rule at depth? If possible, please put them hierarchical manner.