3

I have a question about Java Generics. In code below we have interface B parametrized by another type that must implement interface A.

This code is correct. Question is: why it does not work with following list() method declaration?

private <X extends A, Y extends B<X>> List<Y> list()

Working code:

public interface A {
}
public interface B<T extends A> {
}
public class Test {

    private static class AA implements A {}
    private static class BB implements B<AA> {}

    private <R extends A, X extends R, Y extends B<X>> List<Y> list() {
        return null;
    }

    private void test() {
        List<BB> l = list();
    }
}

EDIT: I've reworked the code. Now we have bird paremetrized by sound it can make. Question is why useless_t is necessary?

public class Test {
    public interface Sound {
    }
    public interface Bird<T extends Sound> {
    }

    private static class Quack implements Sound {}
    private static class Duck implements Bird<Quack> {}


    private <useless_t extends Sound, sound_t extends useless_t, bird_t extends Bird<sound_t>> List<bird_t> list() {
            return null;
    }

    private void test() {
            List<Duck> l = list();
    }
}
Improve this question
3
  • 2
    What are you trying to achieve? Commented Jun 9, 2012 at 7:55
  • Get some book and then mess with generics. You totally miss the point of them. I suggest Java head first. Commented Jun 9, 2012 at 8:25
  • I second that. You are trying to specify your entire inheritance hierarchy in that list type. I don't know why you'd want to do that, but it is almost certainly not the best way to do things. If you give more context of what you are trying to achieve you might get better answers. Commented Jun 9, 2012 at 11:15

3 Answers 3

Reset to default
3

My Eclipse IDE does not compile any of your code examples as is. But they do compile when given additional type hints. In the second example, with or without the type parameter useless_t, the following line does not compile for me:

List<Duck> l = list();

But the following does compile for me:

List<Duck> l = this.<Sound, Quack, Duck> list();

With the useless_t factored out, the following compiles, too:

List<Duck> l = this.<Quack, Duck> list();

So it is basically a matter of the compiler not getting the type parameters right, and you need to give the types explicitly.

UPDATE : If you really came across a program where adding the useless_t made a difference, you are on unsafe terrain, and rely on unspecified compiler behaviour.

You ran into an issue where different compilers behave differently, namely Type Inference. The JLS is not entirely clear on where a compiler must infer types, and where it must refuse to infer, so there is wiggle room here. Different versions of the Eclipse compiler and different versions of javac differ in where they do infer types. For javac, this is true even when comparing different 1.5.0_x versions, and the Eclipse compiler usually can infer more than javac.

You should only rely on type inference where all common compilers succeed, and otherwise give type hints. Sometimes, that is as easy as introducing a temporary variable, but sometimes (as in your example) you must use the var.<Types>method() syntax.

Regarding the comment: what if i want method Duck.getSound() to return Quack, not Sound using generics?

Assume the Bird interface had the following method:

public interface Bird<T extends Sound> {
    T getSound();
}

Then you could implement it like so:

private static class Duck implements Bird<Quack> {
    public Quack getSound() { return new Quack(); }
}

This is one use case for generics - allow implementations to specify concrete types, so that even the superclass can use that type. (The Bird interface could have a setSound(T), or do other stuff with T, without knowing the concrete type of T.)

If a caller only knew that an instance was of type Bird<? extends Sound>, he would have to call getSound like so:

Sound birdSound = bird.getSound();

If the caller knew about Quack, he could perform an instanceof test. But if the caller knew that the bird was really a Bird<Quack>, or even that is was a Duck, then he can write this and it compiles as desired:

Quack birdSound = bird.getSound();

But beware: Generifying too many types used in the interface or superclass brings the risk of overcomplicating the system. As Slanec wrote, Rethink your real design to see whether it's really needed to have so many generics.

I once went too far, and ended up with a interface hierarchy and two implementation hierarchies, based on interfaces like this:

interface Tree<N extends Node<N>,
               T extends Tree<N, T>> { ... }

interface SearchableTree<N extends SearchableNode<N>,
                         S extends Searcher<N>,
                         T extends SearchableTree<N, S, T>>
    extends Tree<N, T> { ... }

I do not recommend to follow that example. ;-)

Improve this answer
Sign up to request clarification or add additional context in comments.

6 Comments

This. The useless_t really is useless. Also, private <bird_t extends Bird<? extends Sound>> List<bird_t> list() compiles right away.
That said, in this example, the Duck should know it Quacks from its constructor and an inner field, not a generic type. Rethink your real design to see whether it's really needed to have so many generics.
Funny enough, it compiles with my Eclipse (3.7.2, Java6) but fails on javac. But works if compiled from Maven. As to design comments - what if i want method Duck.getSound() to return Quack, not Sound using generics?
@user1445898 That's would require its own answer... It will return a Quack even though it presents itself as a Sound. If Quack has some methods overridden over its supertype, it will call the Quack's one. If Quack has some new methods over the Interface and it's necessary, then yeah, you need to use instanceof or generics or something.
@user1445898 : your code CAN'T compile as you've posted it. the "list()" method is not defined anywhere. As for the sound, There's no reason your bird interface should genericize the sound. Sounds are sounds, and no one really should care whether a bird makes a quack or a chirp, or whatever. That's an implementation detail that's best left to being internal to the object, not part of the generic signature.
|
1

I'd say: AA implements A, by defining List<AA> l = list() you expect it to extend B<X> which it does not. Anyway, you see how easly you get confused by writing such code. This is just TOO complex.

Improve this answer

Comments

0

You have a slight misunderstanding of Java Generics. The thing to remember, and this is a subtle thing, a List<Y> is not about the contents of the list, but a modification of the list itself.

Let's extrapolate a little bit; say I have interface Animal and interface Dog extends Animal and interface Cat extends Animal. (I'll just invent more classes and interfaces as we go along.) Now if I declare a method that returns animals as List<Animal> createList(), there's nothing wrong with the following code:

List<Animal> litter = createList();
Cat tabby = new Tabby();
litter.add(tabby);
Dog poodle = new Poodle();
litter.add(poodle);

That's because a Dog is an Animal, and a Cat is an Animal; the method signature of add on type List<Animal> is add(Animal); we can call add with any valid instance of Animal, as expected. But the type parameter on List does not modify or restrict the contents of the list, it modifies the type of the list itself; and a "list of cats" is not a "list of animals", neither is a "list of dogs". Even if the createLitter() method actually returns a new ArrayList<Animal>() that contains only instances of Parrot, the above code is fine. What you cannot do however is 'narrow' the type of the list. For example, this is a compile error:

List<Bird> birds = createList(); // does not compile

Imagine if it were allowed, and createList returned a "list of animals" that contained our tabby; the following would result in a class cast exception:

Bird leaderOfTheFlock = birds.get(0);

You also cannot 'widen' the type of list. Imagine if it were possible:

List<Object> things = createList(); // does not compile

The reason this is not allowed either is that code could now add a new Integer(0) to things - because an Integer is an Object. Clearly that's not what we want either, and for the same reason - a "list of animals" is not a "list of objects". The type parameter "Animal" on List<Animal> modifies the type of the list itself, and we are talking about two distinct types of lists. This leads us to the first consequence of that point - generic types do not follow the inheritance (is-a) hierarchy.

Without knowing more of what you want to do it's hard to go from here and stay relevant. I don't mean to be harsh, but it looks like you started throwing generics at your code to see if something would work. I struggled for years with Generics. Even after running across a blog that explained this subtle point I had to recreate quite a few variations of the above to reinforce the lesson, looking for various ways I would end up with a class-cast-exception if I broke the rules. Likely the solution to your problem is that other parts of the code are not well defined with respect to the strict type system you are trying to introduce, and the generics problems you see are only a symptom of that. Try to reduce the generics and rely more on composition and inheritance. I still shoot myself in the foot occasionally by going off the generic deep end. It's also helpful to try and remember the point of generics is not to eliminate casts, but to make type information available to the compiler as an aid to verifying the correctness of how your code deals with the types; or in other words it turns runtime errors (class cast) into source / compile-time errors, so it is important to try to keep in mind the distinction between what type information you have at compile-time (which is limited, even with generics) and what type information you have at runtime (which is the full type information of the instances).

Improve this answer

Comments

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service and acknowledge you have read our privacy policy.

Start asking to get answers

Find the answer to your question by asking.

Ask question

Explore related questions

See similar questions with these tags.