class Enum< E extends Enum< E > >

interface Comparable< T extends Comparable< T > >

// 2. Return a specific type, rather than a base type:
 
interface MyInterface2 {
  Object returnMySpecificType();
  // ...
}
 
class Pet {}
class Dog extends Pet {}
class Waffle {}
 
class MI2Test1 implements MyInterface2 {
  public Pet returnMySpecificType() { return new Pet(); }
}
 
class MI2Test2 implements MyInterface2 {
  public Dog returnMySpecificType() { return new Dog(); }
}
 
class MI2Test3 implements MyInterface2 {
  public Waffle returnMySpecificType() {
    return new Waffle();
  }
}

interface MyInterface3 {
  Pet returnMySpecificType();
  // ...
}

interface A
{
   Number foo();
}
 
interface B extends A
{
   Integer foo();
}

List<Object> list = new List<String> // nope, not allowed
 
List<? extends Object> = new List<String> // OK

public class Test<T extends Test<T>>
{
    public static void main(String[] args)
    {
        new A().foo(new B());
        new B().foo(new A());
    }
 
    public void foo(T other)
    {
    }   
}
 
class A extends Test<B>
{
}
 
class B extends Test<B>
{
}

MyInterface2 t1 = new MI2Test1();
Pet p1 = t1.returnMySpecificType(); // error - needs a cast

C:\Personal\Java\examples\annotations\show\src\show\Main.java:8: foo(show.B) in show.Main<show.B> cannot be applied to (show.A)
        new B().foo(new A());
1 error

public class Test
{
    public static void main(String[] args)
    {
        B b = new B();
        C c = new C();
 
        b.compareTo(c);
        c.compareTo(b);
    }
}
 
class A<T extends A> implements Comparable<T>
{
   public int compareTo(T a)
   {
       return 0;
   }
}
 
class B extends A<A>{}
 
class C extends A<C>{}

class B extends A< A >{}
 
class C extends A< C >{}

class B extends A< A >{}
 
class C extends A< A >{}

class A< T extends A > implements Comparable< A > {
   public final int compareTo( final A notUsed ) { return 0; }
}
 
class B extends A< B >{}
 
class C extends A< C >{}

interface IMorph {
   <T> morph( Class<T> type );
}

public <T> morph( Class<T> type ){
   if( type.isAssignableFrom( this.getClass() ) ){
      return type.cast( this );
   }
   else {
       // engage the plugin system ...
   }
}

    public static <V extends Vertex<V,G>, G extends Graph<V,G>> List<V> searchOrder(Graph<V,G> graph){...}