public class Clazz<T extends Clazz<T>> {
    ...
}

public class Parametrisation {

    private class Provider<P extends Provider<P,C>, C extends Consumer<P,C>> {
        
    }
    
    private class Consumer<P extends Provider<P,C>, C extends Consumer<P,C>> {
        P provider;
    }
    
    private class Seller extends Provider<Seller, Buyer> {
        void sell() {
            
        }
    }
    
    private class Buyer extends Consumer<Seller, Buyer> {
        void buy() {
            // похоже, чтоб не кастить здесь, сомнительное удовольствие ...
            // no need to cast here
            provider.sell();
        }
    }
}

interface Builder<T,B extends Builder<T,B>> {
    B withSomething(Something s);
    T build();
}

class FooBuilder implements Builder<Foo,FooBuilder> {
     private Something s;
     public FooBuilder withSomething(Something s) {
          this.s = s;
          return this;
     }
     public Foo build() {
         return new Foo(s);
     }
}
...
Foo foo = new FooBuilder().withSomething(s).build();

B>interface Builder<T,B extends Builder<T,B>> {
B>    B withSomething(Something s);
B>    T build();
B>}

B>class FooBuilder implements Builder<Foo,FooBuilder> {
B>     private Something s;
B>     public FooBuilder withSomething(Something s) {
B>          this.s = s;
B>          return this;
B>     }
B>     public Foo build() {
B>         return new Foo(s);
B>     }
B>}
B>...
B>Foo foo = new FooBuilder().withSomething(s).build();
B>

interface Builder<T> {
    T build();
}

class FooBuilder implements Builder<Foo> {
     private Something s;
     public FooBuilder(Something s) {
          this.s = s;
     }
     public Foo build() {
         return new Foo(s);
     }
}
...
Foo foo = new FooBuilder(s).build();

If we dissect the declaration " Enum<E extends Enum<E>> " we can see that this pattern has several aspects.

First, there is the fact that the type parameter bound is the type itself: " Enum <E extends Enum <E>> ". It makes sure that only subtypes of type Enum are permitted as type arguments. (Theoretically, type Enum could be instantiated on itself, like in Enum<Enum> , but this is certainly not intended and it is hard to imagine a situation in which such an instantiation would be useful.)

Second, there is the fact that the type parameter bound is the parameterized type Enum <E> , which uses the type parameter E as the type argument of the bound. This declaration makes sure that the inheritance relationship between a subtype and an instantiation of Enum is of the form " X extends Enum<X> ". A subtype such as " X extends Enum<Y> " cannot be declared because the type argument Y would not be within bounds; only subtypes of Enum<X> are within bounds.

Third, there is the fact that Enum is generic in the first place. It means that some of the methods of class Enum take an argument or return a value of an unknown type (or otherwise depend on an unknown type). As we already know, this unknown type will later be a subtype X of Enum<X> . Hence, in the parameterized type Enum<X> , these methods involve the subtype X , and they are inherited into the subtype X . The compareTo method is an example of such a method; it is inherited from the superclass into each subclass and has a subclass specific signature in each case.

To sum it up, the declaration " Enum<E extends Enum<E>> " can be decyphered as: Enum is a generic type that can only be instantiated for its subtypes, and those subtypes will inherit some useful methods, some of which take subtype specific arguments (or otherwise depend on the subtype).

M>public class Clazz<T extends Clazz<T>> {
M>    ...
M>}
M>

public class ComparableClass implements Comparable<ComparableClass> {
    private final int sortOrder;

    public ComparableClass(int sortOrder) {
        this.sortOrder = sortOrder;
    }

    @Override
    public int compareTo(ComparableClass o) {
        return sortOrder - o.sortOrder;
    }
}

M>>public class Clazz<T extends Clazz<T>> {
M>>    ...
M>>}
M>>

F>public class ComparableClass implements Comparable<ComparableClass> {
F>    private final int sortOrder;

F>    public ComparableClass(int sortOrder) {
F>        this.sortOrder = sortOrder;
F>    }

F>    @Override
F>    public int compareTo(ComparableClass o) {
F>        return sortOrder - o.sortOrder;
F>    }
F>}
F>

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