Question

For example, in C#, Foo, Foo<T>, Foo<T1, T2> could have similar semantic but are different classes. But in Java, I can’t name classes like that. How to name them? I don’t think Foo, Foo1<T>, Foo2<T1, T2> are appropriate. Any other suggestions?

Actually, I want to design some interfaces which have only one method just like Runnable. But run in Runnable doesn’t have return value and any parameters. I want interfaces like

public interface Runnable<T>{
    void run(T t);
}

public interface Runnable<T, TResult>{
    TResult run(T t);
}

public interface Runnable<T1, T2, TResult>{
    TResult run(T1 t1, T2 t2);
}

And so on. And I think they are better in the same package.

Answer 1

You can rename them to truly reflect their function:

BasicFoo
GenericFoo<T>
SuperDuperAdvancedFoo<T, U>

you can even declare an interface, say Foo, that provides all the methods every well-behaved Foo should have. Then you implement the interface in different Foos with different type parameters:

interface Foo<T, U>
BasicFoo implements Foo<Object, Object>
GenericFoo<T> implements Foo<T, Object>
SuperDuperAdvancedFoo<T, U> implements Foo<T, U>

EDIT: working at your examples, the 3 interfaces can really be declare just using one of them:

public interface Runnable<T1, T2, TResult>{
    TResult run(T1 t1, T2 t2);
}

and if you don’t want any parameters, you just supply Void whenever necessary. A Void class in uninstantiable, so the only other possibility is to pass or return null. So for example:

public class MyRunnable implements Runnable<Void, Void, Void>;

creates a method similar to

void run();

You actually declared

Void run(Void a, Void b);

but Void in uninstantiable, so you must pass nulls and the function will always return null.