Use generic interface as method argument in Java

Lets say I have the following interface Foo

abstract public interface Foo {

    abstract String getFoo();
}

and two classes that extend Foo, Bar1 and Bar2

public class Bar1 extends Foo{

    String foo = "foobar";
    public String getFoo(){
        return foo;
    }
}
//repeat for class Bar2 

I want to create a translator class that had a method that a client can call, which takes any object thats extending Foo as an argument (like Bar1 or Bar2 and translate the string to some other string. I did some digging and feel like generics are going to be the best way to do so, however I'm unable to properly modify either the method signature or the class signatures (not sure which, perhaps both?) to allow for this behavior.

public class TranslateBar{
    
//I have tried the following signatures, but clearly I'm missing something    

    public String translateBar(Foo<? extends Foo> pojo>{
        //return translated string
    }
    
    /*
    I read that Object is the supertype for all Java classes, so I thought maybe having it 
    take an Object in the parameters and then doing the wildcard would work, but no luck
    */

    public String translateBar(Object<? extends Foo> pojo>{
        //return translated string
    }

In all cases, it gives me an error in the generic saying Type 'java.lang.Object'(or Foo) does not have type parameters. The two options it gives me to fix are create a field for pojo which still doesn't solve the <? extends Points2> error.

How can I get my translateBar method to allow the client to pass any subclass of Foo?

In Java, a method that accepts a certain type, say Foo, will accept also any sub-type of Foo. There's no need to use generics in such case.

Here's how your code should look like:

public interface Foo {
    String getFoo();
}

public class Bar1 implements Foo {
    final String foo = "foobar";
    @Override
    public String getFoo(){
        return foo;
    }
}

public class TranslateBar {
    public String translateBar(Foo pojo) {
        //return translated string
    }
}

Now you can call translateBar with any implementation of Foo including Bar1:

new TranslateBar().translateBar(new Bar1());

You would use generic for different cases... for example, where the type returned by the getFoo method depended on the implementation.

// the type T is generic and depends on the implementation
public interface Foo<T> {
    T getFoo();
}

public class Bar1 implements Foo<String> {
    final String foo = "foobar";
    @Override
    public String getFoo(){
        return foo;
    }
}

public class TranslateBar {
    public String translateBar(Foo<?> pojo) {
        //return translated string
    }
}

In your case, you don't need to use generics as the basic polymorphism will be sufficient

 public String translateBar(Foo pojo){
    //return translated string
}

And this will solve the issue if you just want to call the getFoo()