Working with generics

Question

Hi everyone, I'm really new to the use of generics. I've worked with them in the Java Collections Frameworks and other framewroks as well. Now I'm working in an application that uses some of them, but I've encountered a problem.
Suppose we have a List of object which are implementations of a Generic interface, this interface is parametrized by any kind of object with the relation IS-A. Now we want to call the implemented in each object contained in the List by passing as argument an object which can be a parameter of the generic interface, and here is the problem: When I try to call it in a "safe" way (this means: by making the generic type explicit) the compiler throws an Error (the line with the comment "Error" on it), but when I call it without any parameter the code runs fine, but the compiler shows a warning (the line with the comment "Warning" on it).
Here is the code showing the problem:
package example;
import java.util.*;
public class Example {
     public static List<GenericInterface<? extends Foo>> list = new ArrayList<GenericInterface<? extends Foo>>();
     public static void methodWithError() {
          list.add(new GenericImplementation());
          Bar bar = new Bar();
          for (GenericInterface<? extends Foo> imp : list) {
               imp.doSomething(bar);// ERROR!!
     public static void methodWithWarning() {
          list.add(new GenericImplementation());
          Bar bar = new Bar();
          for (GenericInterface imp : list) {
               imp.doSomething(bar); // WARNING
interface GenericInterface<T extends Foo> {
     public void doSomething(T t);
class GenericImplementation implements GenericInterface<Bar> {
     @Override
     public void doSomething(Bar bar) {
          System.out.println(bar);
class Foo {
class Bar extends Foo {
}Now the question is: Is there a way to call the method in a "safe" way?, Am I doing some wrong or crazy?.
Thanks in advanced.
David

Answer 1

Thanks for the answer, you both are right about the example, I was my mistake to write it that way.
Now, I could declared an iterate this way:
public static List<GenericInterface<Bar>> list = new ArrayList<GenericInterface<Bar>>();
for ( GenericInterface<Bar> imp : list ) {
      imp.doSomething(bar);// FINE
}but if I don't know the exact type of the implementing class, something like this:
public static void methodWithError() {
          list.add(new GenericImplementation());
          list.add(new SecondGenericImplementation());
          Bar bar = new Bar();
          for (GenericInterface<? extends Foo> imp : list) {
               imp.doSomething(bar);
//...with:
class SecondGenericImplementation implements GenericInterface<Bar2> {
     @Override
     public void doSomething(Bar2 bar2) {
          System.out.println(bar2);
class Bar2 extends Foo{
}From this is were my question really came. And again sorry for my bad explanation, and thanks for your answer.