Java generics seem to work differently for classes than for methods

Question

I'm following this:

http://rickyclarkson.blogspot.com/2006/07/duck-typing-in-java-and-no-reflection.html

And I'm trying to adapt this:

<T extends CanQuack & CanWalk> void doDucklikeThings(T t)
{
    t.quack();
    t.walk();
}

To this:

public class Activate<D extends CanQuack & CanWalk> {

    D d = new MyWaterFowl(); //Type mismatch
}

Even though MyWaterFowl implements those interfaces.

I'd like a solution that never mentions MyWaterFowl in the <>'s since I'm going to eventually just be injecting it (or anything else that implements those interfaces).

---

If your answer is basically "You can't do that, what type would it even be?". Please explain why it's working for the method doDucklikeThings and conclusively state if it is impossible to do the same with a class or, if it is possible, how to do it.

The T in doDucklikeThings must be something valid since it's working. If I passed that into a class what would I be passing in?

---

As requested here's the MyWaterFowl code:

package singleResponsibilityPrinciple;

interface CanWalk { public void walk(); }
interface CanQuack { public void quack(); }
interface CanSwim { public void swim(); }


public class MyWaterFowl implements CanWalk, CanQuack, CanSwim {

    public void walk() { System.out.println("I'm walkin` here!"); }
    public void quack() { System.out.println("Quack!"); }
    public void swim() { System.out.println("Stroke! Stroke! Stroke!"); }
}

Remember I've confirmed that doDucklikeThings works. I need the syntax that will let me inject anything that implements the required interfaces.

Answer 1

This does not work, because the class/method is generic and the caller of your class/method can set D to MyAmericanEagle.

 Activate<MyAmericanEagle> active = new Activate<>();

Then your code would result in

 MyAmericanEagle d = new MyWaterFowl(); 

Since that makes no sense (would result in ClassCastException) the compiler rejects it.

Answer 2

// Type mismatch

Even though MyWaterFowl implements those interfaces.

It's not about the type D implementing those interfaces (and/or extending a class). A generic type variable is bound to a specific type argument. That type might be completely different than MyWaterFowl so you cannot use them interchangeably.

---

To answer your edit, you are doing two completely different things in your two snippets. The type variable is declared with some bounds. It is therefore guaranteed to be a type that implements some interface (or extends some class), but you don't know which type that is, in either case.

---

I want to clarify the two things you did, ie. what you expect in your question and the solution you gave in your answer.

Generics are a compile time feature where the server code, for example

class Activate<D extends CanWalk & CanQuack> {
    D instance;
    public Activate(D d) {
        this.instance = d;
    }

    public D getInstance() {
        return instance ;
    }
}

declares a type variable. This is a variable. Within its declaration context, you don't know its exact type at compile time.

The client code, for example,

new Activate<>(new MyWaterFowl());

binds the type MyWaterFowl to the type variable declared in Activate. So the client code knows what D is at compile time.

If the following

public D getInstance() {
    D someRef = new MyWaterFowl();
    return someRef;
}

was allowed in the server code, this would fail

Activate<SomeOtherBird> activate = new Activate<>(new SomeOtherBird());
SomeOtherBird reference = activate.getInstance();

Generics guarantee that getInstance() is type safe because it is declared as returning whatever type is bound to the type variable D. In this case, that is SomeOtherBird. If the getInstance() code above was allowed, type safety would be broken as getInstance() would return something other than what was bound to it.

This doesn't change the fact that within your server code (the generic class), you do know the bounds of D, ie. it is both a CanQuack and a CanWalk. Therefore, anything an object of those types can do, so can an object referenced by a D variable do.

Answer 3

It actually can be done.

The generic code between <>'s is fine. It's not different for methods and classes. Just needed to finish doing the dependency injection:

public class Activate<D extends CanQuack & CanWalk> {
    private D d;

    Activate(D d) {
        this.d = d;
    }

    void doDuckLikeThings() {
        d.quack();
        d.walk();
        //d.swim(); //Doesn't work 
        //And shouldn't since that was the whole point of ISP.
    }
}

public class MainClass {
    public static void main(String[] args) {
       Activate<MyWaterFowl> a = new Activate<>(new MyWaterFowl());
       a.doDuckLikeThings();
    }
}

Thought I'd provide an answer that says what to do to fix it.

Answer 4

Type of class which extends Object is different with type of Object. This means you cannot instantiate super class for its extenders.

When you compile this:

1    public class Sample<T extends Object> {
2      public Sample() {
3         T t = new Object();
4       }
5    }

you got incompatible types error.

Sample.java:3: error: incompatible types
    T t = new Object();
          ^
  required: T
  found:    Object
  where T is a type-variable:
    T extends Object declared in class Sample
1 error

Its same as when you do it in non generic form:

1 public class Sample{
2    public Sample() {
3    }
4 }
5
6 class SampleExtends extends Sample {
7   public SampleExtends() {
8
9    }
10 }
11
12 class User {
13    public User() {
14        SampleExtends se = new Sample();
15    }
16 }

you get this error from compiler: incompatible types

Sample.java:14: error: incompatible types
    SampleExtends se = new Sample();
                       ^
  required: SampleExtends
  found:    Sample
1 error

Answer 5

What do you expect the actual type of D to be in the second code snippet?

Let's say something does this:

Activate<Daffy> myActivate = Activate<Daffy>();

What should happen then? This means D needs to be of type Daffy but you are trying to set d to an instance of MyWaterFowl.

Answer 6

Generics works just the same for classes as for methods.

You seem to misunderstand Generics a bit. A type parameter <T extends CanQuack & CanWalk> is not a definition of a new type alias valid for the scope of method or class, it is a placeholder for some type, which is later filled by someone else.

For a generic method like your example

<T extends CanQuack & CanWalk> void doDucklikeThings(T t)
{
    t.quack();
    t.walk();
}

the caller of the method decides which type to substitute for T (within the limits stated by the bounds). So one can use

doDuckLikeThings(myWaterfowl);

and the compiler guesses what type parameter you want here (likely the type of the myWaterfowl variable).

For a generic class, it is the code which creates an instance of the class who decides the actual type parameter. So I can say

Activate<Duck> duckActivator = new Activate<Duck>();

After this, the duckActivator instance is an instance of Activate<Duck>, and inside it, D is now bound to Duck. Now obviously your variable declaration says

Duck d = new MyWaterfowl();

and this doesn't work.

It wouldn't work in a generic method, either – this one is invalid just as well:

<T extends CanQuack & CanWalk> void doDucklikeThings()
{
    T t = new MyWaterfowl();
}

I'd like a solution that never mentions MyWaterFowl in the <>'s since I'm going to eventually just be injecting it (or anything else that implements those interfaces).

Then don't mention its constructor either. Whoever is injecting your duck like object also has to decide the actual type parameter – i.e. this should be the one who creates the Activate instance. And this can't change after construction of your Activate object.

A candidate solution to the actual problem

If this restriction doesn't fit for you (e.g. because the same instance of Activate will need to be able to work with different types of duck like objects one after another), maybe a type parameter is not for you.

Maybe a generic wrapper with a wildcard type parameter for a variable helps instead.

Take this generic wrapper (or something similar):

public class Holder<T> {
    private final T t;
    public T get() { return t; }
    public Holder(T t) { this.t = t; }
}

Then your Activate class doesn't need the type parameter, but just holds a holder variable with a wildcard type parameter. (Note that the actual Holder instantiation has a non-wildcard type argument.)

public class Activate {
    private Holder<? extends CanQuack & CanWalk> holder;

    public <D extends CanQuack & CanWalk> void setDuckLike(D d) {
        this.holder = new Holder<D>(d);
    }

    public Activate() {}

    public void doDucklikeThings() {
         holder.get().quack();
         holder.get().walk();
    }
}

Now you do something like this:

Activate a = new Activate();
a.setDuckLike(new Duck());
a.doDucklikeThings();
a.setDuckLike(new MyWaterfowl());
a.doDucklikeThings();