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(); 
	}
}

Citrus citrus = new Citrus();
Lemon lemon = new Lemon();
 
lemon.call(citrus);
lemon.call((Fruit) citrus);
((Orange) lemon).call(citrus);

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

interface Comparable2<T> {  // (2)
  int compareTo(T o);
}

class A {}
 
class B implements Comparable2<A> {
  int compareTo(A o) {...}
}

class C implements Comparable<C> {
  int compareTo(C o) {...}
}
 
class D implements Comparable<C> {
  int compareTo(C o) {...}
}

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

class ReverseComparator<T extends Comparable<T>> implements Comparator<T>
{
   public int compare(T a, T b)
   {
       return -a.compareTo(b);
   }
}

abstract class HasF< T extends HasF< T > > {
    T f() {
        System.out.println( "HasF.f()" );
        return (T)this;
    }
}
 
class A extends HasF< A > {}
 
class B extends HasF< A > {}
 
...
 
A a = new B().f();

abstract class HasF< T extends HasF< T > > {
    T f() {
        System.out.println( "HasF.f()" );
        return newInstance();
    }
    abstract T newInstance();
}
 
class A extends HasF< A > {
    A newInstance() { return new A(); } // OK
}
 
class B extends HasF< A > {
    B newInstance() { return new B(); } // Error flagged
}

 // java.lang.Comparable needs to erase to Object, not Comparable
// hence it isn't a recursive generic because that erases to Comparable
interface Comparable2< T extends Comparable< T > > {
    int compareTo( T other );
}
    
class C implements Comparable2< C > {
    int v;
    C( int v ) { this.v = v; }
    public int compareTo( C other ) { return v - other.v; }
}
    
class D implements Comparable2< C > {
    float v;
    D( float v ) { this.v = v; }
    // does not compile - other.v has a different type and 
    // probably in practice different visibility than v
    public int compareTo( C other ) { return v - other.v; } }

class HasF {
    this f() {
        ...
        return this;
    }
    int compareTo( this other ) { ... }
}

public class PropertySupportAspect<T extends PropertySupportAspect<T>> {
 
   PropertyChangeSupport support = new 
                           PropertyChangeSupport(this);
 
   public void addPropertyChangeListener
       ( PropertyChangeListener listener){
     support.addPropertyChangeListener(listener);
   }
 
   public void addPropertyChangeListener(
                   String propertyName,
		   PropertyChangeListener listener)  {
     support.addPropertyChangeListener(propertyName, 
                                       listener);
   }
 
   public void removePropertyChangeListener(
                   String propertyName,
	           PropertyChangeListener listener) {
     support.removePropertyChangeListener(propertyName, 
                                          listener);
    }
 
    public void removePropertyChangeListener
                     (PropertyChangeListener listener) {
     support.removePropertyChangeListener(listener);
    }
 
    public void hasListeners(String propertyName) {
     support.hasListeners(propertyName);
    }
 
    public void firePropertyChange( Bean b,
				    String property,
				    String oldval,
				    String newval) {
     support.firePropertyChange( property,
			    ( oldval == null ) ?
			  	  oldval :
			  	  new String(oldval),
	   	                  new String(newval));
    }
}
class Bean extends PropertySupportAspect<Bean>{
	private String name;
 
	public String getName() {
		return name;
	}
	public void setName( String name ) {
		firePropertyChange( this,
		                    "name",
				    getName(),
				    name );
		this.name = name;
	}
}

class Y implements/extends  X<Y>

 abstract class HasF< T extends HasF< T > > {
     T f() {
         System.out.println( "HasF.f()" );
         return newInstance();
     }
     abstract T newInstance();
 }
  
 class A extends HasF< A > {
     A newInstance() { return new A(); } // OK
 }
  
 class B extends HasF< A > {
     // We have to code this method to raise an compiler error.
     B newInstance() { return new B(); }
 }

interface A<T extends B<T>> {
    T f(T x);
}
interface B<U extends A<U>> {
    U g(U y);
}

interface A<T extends A<T> & B<T>> { 
    T f(T x);
}
interface B<U extends A<U> & B<U>> { 
    U g(U y);
}

class C implements Comparable<Integer>, Comparable<String> { ... }

import java.util.*;
 
abstract class Subject< S extends Subject< S, O >, O extends Observer< S, O > > {
    private final List< O > observers = new ArrayList< O >();
    void subscribe( O obs ) { observers.add( obs ); }
    void publish() {
        for ( final O obs : observers )
            obs.notify( (S)this );
    }
}
abstract class Observer< S extends Subject< S, O >, O extends Observer< S, O > > {
    abstract void notify( S sub );
}
class Sensor extends Subject< Sensor, Display > {
    double value = 0.0;
    void changeValue( final double v ) {
        value = v;
        publish();
    }
}
class Display extends Observer< Sensor, Display > {
    void notify( Sensor sub ) {
        System.out.println( sub  + " has value " + sub.value );
    }
}
public class SubjectObserver {
    public static void main( final String[] notUsed ) {
        final Display o = new Display();
        final Sensor s = new Sensor();
        s.subscribe( o );
        s.changeValue( 1 );
    }
}