Why a generic method of an interface can be implemented as non-generic in Java?

Question

Let's say we have a few test interfaces/classes like this:

abstract class Plant {
    public abstract String getName();
}

interface Eatable { }

class Apple extends Plant implements Eatable {
    @Override
    public String getName() {
        return "Apple";
    }
}

class Rose extends Plant {
    @Override
    public String getName() {
        return "Rose";
    }
}

interface Animal {
    <T extends Plant & Eatable> void eat(T plant);
}

You can see Animal.eat is a generic method with constraints. Now I have my Human class like this:

class Human implements Animal {
    @Override
    public void eat(Plant plant) {
    }
}

which compiles fine. You can see Human.eat is less constrained than Animal.eat because the Eatable interface is lost.

Q1: Why doesn't the compiler complain about this inconsistency?

Q2: If Plant&Eatable downgrades to Plant is acceptable for the compiler, why it complains on eat(Object plant)?

Which version of Java are you using. Using Java 1.8 in eclipse gives compile time error as expected. — Codebender, Aug 10 '16 at 02:55
@Codebender I have no issue compiling this. https://ideone.com/7xUcZn — flakes, Aug 10 '16 at 03:00
@ElliottFrisch But it happens in compile phase, the compiler knows that, and I think it should gives an error, at least a warning? — Cheng Chen, Aug 10 '16 at 03:09
Just tried it with `javac` on the command line, and it doesn't get an error. But if I change `Plant` to `Rose` in the parameter list of `Human.eat`, I now get an error. — ajb, Aug 10 '16 at 04:19
For what it's worth, I can't think of a case where the posted code causes a "problem"--i.e. where code compiles, but at runtime the code attempts to call an `Eatable` method on an object of a class that doesn't implement `Eatable` (assuming we added some methods to `Eatable`). — ajb, Aug 10 '16 at 05:08

score 12 · Accepted Answer · edited Aug 15 '16 at 08:06

Lesson: Generics by Gilad Bracha according to him

public static <T extends Object & Comparable<? super T>> T max(Collection<T> coll)
This is an example of giving multiple bounds for a type parameter, using the syntax T1 & T2 ... & Tn. A type variable with multiple bounds is known to be a subtype of all of the types listed in the bound. When a multiple bound is used, the first type mentioned in the bound is used as the erasure of the type variable.

so your example <T extends Plant & Eatable> void eat(T plant); will be erased to void eat(Plant plant); so when you override it the compiler doesn't complain

score 0 · Answer 2 · answered Aug 13 '16 at 07:30

Ahmed answer is right,by the way,if you wanna put constraint the implementation of the interface of Animal, you should declare it as this:

interface Animal<T extends Plant & Eatable>  {
    void eat(T plant);
}

Then, if you implements the Animal interface without providing the type information, the compiler will using the least surprise policy to infer the T as a Plant type. But if you provide the necessary type information, the compiler works fine.

class Human implements Animal<Rose> // won't compile
class Human implements Animal<Apple> // compile

Why a generic method of an interface can be implemented as non-generic in Java?

2 Answers2