This has the dizzying effect of two mirrors pointed at each other, a kind of infinite reflection. The class SelfBounded takes a generic argument T, T is constrained by a bound, and that bound is this class, with T as an argument.

Although it's difficult to parse when you first see it, it emphasizes that the extends keyword, when used with bounds, is definitely different than when it is used to create classes.

To understand what this idiom means, look at how the resulting class can and can't be used:

//: generics/SelfBounding.java

class SelfBounded<T extends SelfBounded<T>> {
  T element;
  SelfBounded<T> set(T arg) {
    element = arg;
    return this;
  }
  T get() { return element; }
}

class A extends SelfBounded<A> {}
class B extends SelfBounded<A> {} // Also OK

class C extends SelfBounded<C> {
  C setAndGet(C arg) { set(arg); return get(); }
}

class D {}
// Can't do this:
// class E extends SelfBounded<D> {}
// Compile error: Type parameter D is not within its bound

public class SelfBounding {
  public static void main(String[] args) {
    A a = new A();
    a.set(new A());
    a = a.set(new A()).get();
    a = a.get();
    C c = new C();
    c = c.setAndGet(new C());
  }
} ///:~

What self-bounding does is require the use of the class in an inheritance relationship like this: class A extends SelfBounded<A> {}

This forces you to pass the class that you are defining as a parameter to the base class.

The type parameter must be the same as the class being defined. As you can see in the definition of class B, you can also derived from a SelfBounded that uses a parameter of another SelfBounded, although the predominant use seems to be the one that you see for class A. The attempt to define E shows that you cannot use a type parameter that is not a SelfBounded.

Notice that you can remove the constraint and all the classes will still compile, but E will also compile:

//: generics/NotSelfBounded.java

public class NotSelfBounded<T> {
  T element;
  NotSelfBounded<T> set(T arg) {
    element = arg;
    return this;
  }
  T get() { return element; }
}

class A2 extends NotSelfBounded<A2> {}
class B2 extends NotSelfBounded<A2> {}

class C2 extends NotSelfBounded<C2> {
  C2 setAndGet(C2 arg) { set(arg); return get(); }
}

class D2 {}
// Now this is OK:
class E2 extends NotSelfBounded<D2> {} ///:~

So clearly, the self-bounding constraint serves only to force the inheritance relationship. If you use self-bounding, you know that the type parameter used by the class will be the same basic type as the class that's using that parameter. It forces anyone using that class to follow that form.

It's also possible to use self-bounding for generic methods:

//: generics/SelfBoundingMethods.java

public class SelfBoundingMethods {
  static <T extends SelfBounded<T>> T f(T arg) {
    return arg.set(arg).get();
  }
  public static void main(String[] args) {
    A a = f(new A());
  }
} ///:~

interface Comparable {
  int compareTo(Object o);
}

interface Comparable<T extends Comparable<T>> {
  int compareTo(T o);
}

interface HasEquals<T extends HasEquals<T>> {
  boolean equals(T o);
}

  new Integer(3).equals("hello");

> interface Comparable<T extends Comparable<T>> {
>   int compareTo(T o);
> }

interface Comparable<T> { 
  int compareTo(T o); 
} 

class Foo<self> // Foo<T extends self>
{
}

//: generics/SelfBounding2.java
 
class SelfBounded2<T extends SelfBounded2<T>> {
  T element;
  SelfBounded2<T> set(T arg) {
    element = arg;
    return this;
  }
  T get() { return element; }
  void f(T arg) {}
  void g(T arg) { element.f(arg); }
}
 
class User extends SelfBounded2<User> {
  void h(User arg) { g(arg); }
}
 
public class SelfBounding2 {
  public static void main(String[] args) {
    User user1 = new User(), user2 = new User();
    SelfBounded2<User> sbUser = user1.set(user2);
    User user4 = user2.get();
    user1.f(user2);
    user2.g(user1);
    user1.h(user2);
  }
} ///:~

public class Test
{
    public static void main(String[] args)
    {
        A a = new B().f();
        //B b = new B().f(); does not compile
    }
}
 
abstract class HasF< T extends HasF< T > > {
    @SuppressWarnings( "unchecked" ) 
    T f() {
        System.out.println( "HasF.f()" );
        return (T)this;
    }
}
 
class A extends HasF<A>
{
}
 
class B extends HasF<A>
{
}

public class Edible {
	public void a() {}
}
public abstract class Fruit extends Edible{
	public void a() {}
	public abstract void b();
	public abstract void c();
 
}
public class Citrus extends Fruit {
	public void a() {}
	public void b() {}
	public void c() { System.out.println("Citrus");}
 
}
public class Orange{
	public void call( Fruit f ){      --> Super
		f.b(); 
	}
}
public class Lemon extends Orange{
	public  void call( Citrus c ){    --> Sub
		c.c(); 
	}
}