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