No.  It doesn't compile.

I guess you meant:

  public B cool() {
    return (B) super.cool();
  }

My intent was to prevent from unnecessary cast.

piotr

I very much doubt it, since there are no templates in Java.  Despite the  
unfortunate similarity in syntax, Java generics are nothing like  
C++ templates (for details search the newsgroup archives).

class A
{
    public <T extends A> T cool( T in ) // parameter is used to determine  
return type
    {
        System.out.println("Hello, World");
        return (T)this;
    }
}

class B extends A
{
    public void anotherFunction()
    {
        System.out.println("other func");
    }
}

B myB = new B();
myB.cool( myB ).anotherFunction();

No casting in the calling code, but is this really any better than what  
Piotr and Liu suggested?  I doubt it.

Ben

As Ben already explained, there are no "template structures" in Java.

Assuming a "kind of ..." means Java generics, just another simple
approach in your case might be:

    public class A<T extends A> {
        public T cool() {
            System.out.println("Hello, World");
            return (T)this;  // unsafe!
        }
    }

    public class B extends A<B> {
        public void anotherFunction() { }
    }

It allows for usage like that:

    new A().cool();  // raw type A is used here!
    new B().cool().anotherFunction();

However, mixing a raw and parameterized types is discouraged, and usage
of it is limited to a single level of inheritance only (erasure of B
declared as "class B<T extends B<T>> extends A<T>", without overriding a
cool() method, results in A (not B) taken as a return type for that method).

Safer approach is to have a generic base class for A and B:

    public abstract class Base<T extends Base<T>> {
        protected abstract T getT();

        public T cool() {
            System.out.println("Hello, World");
            return getT();
        }
    }

    public class A extends Base<A> {
        protected A getT() { return this; }
    }

    public class B extends Base<B> {
        protected B getT() { return this; }

        public void anotherFunction() { }
    }

There is no problem now in using A and B the way you expect (there is
also easy way to extend that "pattern" with other classes, e.g.
introducing another generic base class for B derived from the A's base
class).  Unfortunately, it disallows a direct inheritance of A from B,
so then B can not be used as replacement of A anymore.  Partial solution
for that problem may appear already mentioned extended version of that
"pattern", i.e.:

    public abstract class ABase<T extends ABase<T>> {
        protected abstract T getT();

        public T cool() {
            System.out.println("Hello, World");
            return getT();
        }
    }
   
    public abstract class BBase<T extends BBase<T>> extends ABase<T> {
        public void anotherFunction() { }
    }

    public class A extends ABase<A> {
        protected A getT() { return this; }
    }

    public class B extends BBase<B> {
        protected B getT() { return this; }
    }

There's still illegal to do that:

    A a = new A();
    B b = new B();
    a = b;

But the following is legal now:

    ABase<?> a = new A();
    BBase<?> b = new B();
    a = b;

(Using A and B as a names for the abstract base classes, and e.g. AImpl
and BImpl for a concrete implementations' names appears more convenient
for me in that extended "pattern".  Consider that if you'll decide to
use it.)

piotr

No, its not.
Think of the Type Safe enum pattern.
Think of the factory pattern.
Its a bad thing to hard code conditional logic around the subclass in
a super type. Its a good thing to use polymorphism correctly.

But he's not doing that except in the main() method, which isn't part of the
pattern; it's simply there as a demonstration that the pattern works.