Having a Java generic class return a type reference to its specialized class. Aka, using the self-type.

Emulating "self types" using Java Generics to simplify fluent API implementation is a very good example of how to more effectively use Java's generics and inheritance. The "self type" solution is something I would not have imagined. Further, it is motivating to see what other effects can be achieved through Java's generics. Read the article for a compete understanding of self types and a use of them. For those wishing to skip to the conclusion, if you need a generic class instance to return a typed reference to the specialized class then it is coded
public class GenericsTest {
// We have a generic type here that needs to return from its check method
// a reference to the specialized type (that is, the generic's sub-class).
static class Common<SelfType extends Common<SelfType,ElementType>,ElementType> {

protected SelfType self() {
return (SelfType) this;
}

public SelfType check( ElementType e ) {
// do something here that is general to all sub-classes
return self();
}

// ...
}

static class Foo extends Common<Foo,Integer> {

public Foo doFoo() {
// do something here is is specific to Foos
return this;
}
}

static class Bar extends Common<Bar,String> {
public Bar doBar() {
// do something here is is specific to Bars
return this;
}
}

public static void main( String[] args ) throws Exception {
Foo foo = new Foo();
Bar bar = new Bar();
foo.check(1).doFoo();
bar.check("a").doBar();
}
}

// END