A Collection genérica: métodos que recebem Object

 void imprime(List<Comparable> lista) { for (Comparable c : lista) System.out.println(c); } 
``` Podemos passar para esse método uma `List<Comparable>`. E uma `List<String>`? Não podemos, porque uma `List<String>` **não é** uma `List<Comparable>`. Se isso fosse possível, poderíamos adicionar objetos `Comparable` que não apenas `String`s dentro de uma `List<String>`, quebrando o contrato! Para resolver esse problema, mudamos a assinatura do nosso método para:
```java
 void imprime(List<? extends Comparable> lista) { for (Comparable c : lista) System.out.println(c); } 

 public void adicionaString(List<Comparable> lista) { lista.add("caelum"); } 

 public void adicionaString(List<? extends Comparable> lista) { lista.add("caelum"); // não podemos invocar métodos que recebem o tipo // parametrizado (a menos que seja passado null) } 
``` O código acima não compila! Isso ocorre porque `List<? extends Comparable>` pode receber uma lista de qualquer tipo que seja `Comparable`. Se isso fosse possível, alguém poderia passar como argumento uma `List<Integer>`, e no fim do método esta lista de inteiro estaria contendo uma `String`, quebrando o contrato novamente!
Como resolver esse problema? Não tem como! Se você recebe um objeto parametrizado pelo coringa `?`, você nunca poderá invocar um método desse objeto, porque você não sabe qual o tipo que ele realmente aceita! A linguagem não permite isso porque não sabe exatamente o que você vai fazer com esse objeto. Em alguns casos, semanticamente, apesar de um método receber um tipo parametrizado, não tem problema ele receber um objeto que não esteja de acordo com seu tipo parametrizado. Esse é exatamente o caso do método `contains`: não haveria problema de passar um `Integer` para o `contains` de uma `List<String>`! Mas se contains recebesse `E`, o seguinte código não compilaria:
```java
 public boolean contemCaelum(List<? extends Comparable> lista) { return lista.contains("caelum"); // ok, recebe Object! } 

 public static <T extends Object & Comparable<? super T>> T min(Collection<? extends T> coll); 

 public static <T extends Comparable<T>> T min(Collection<T> coll);