Type param in interface referring to concrete class

Question

I want to declare a method in an interface that takes a type parameter that represents the concrete implementing subclass. I can live with something less than that, though I would like to avoid casting as much as possible...
Here's my attempt at a simplified (though contrived) example:
public interface Collectable {
    Collection<Collectable> collectMe();
public class StampCollection implements Collectable<Stamp> {
    // Super-specialized collection for holding stamps
public class Stamp implements Collectable {
    public Collection<Stamp> collectMe() {
        return new StampCollection(this);
}This doesn't work because StampCollection is deemed to be incompatible with Collection<Collectable>. I'm assuming this is because the type parameter for the interface that StampCollection implements is Stamp, which is more specific than Collectable. Is that right? What are my options for fixing this (with minimal casting).

Answer 1

Also, I see from some other reading that there seems to be some precendent for doing things this way (having a class implement an interface parameterized by the class itself). For example, on the Angelika Langer Java Generic FAQ linked to from the notice on this forum, she gives an example of
    class Pair<A extends Comparable<A> & Cloneable ,
               B extends Comparable<B> & Cloneable >
      implements Comparable<Pair<A,B>>, Cloneable { ... } Which is a fairly complicated example for our purposes, but does seem to use the same strategy.
Is this a common idiom?
Michael