Skip to main content

Curiously Recurring Template Pattern

StructuralExtensibilityInstantiationAbout 2 min

Name / classification

Curiously Recurring Template Pattern

Also known as

Recursive Type Bound, Recursive Generic


Allow derived components to inherit certain functionalities from a base component that are compatible with the derived type.


Real-world example

For a mixed martial arts promotion that is planning an event, ensuring that the fights are organized between athletes
of the same weight class is crucial. This prevents mismatches between fighters of significantly different sizes, such
as a heavyweight facing off against a bantamweight.

In plain words

Make certain methods within a type to accept arguments specific to its subtypes.

Wikipedia says

The curiously recurring template pattern (CRTP) is an idiom, originally in C++, in which a class X
derives from a class template instantiation using X itself as a template argument.

Programmatic example

Let's define the generic interface Fighter

public interface Fighter<T> {

  void fight(T t);


The MMAFighter class is used to instantiate fighters distinguished by their weight class

public class MmaFighter<T extends MmaFighter<T>> implements Fighter<T> {

  private final String name;
  private final String surname;
  private final String nickName;
  private final String speciality;

  public MmaFighter(String name, String surname, String nickName, String speciality) { = name;
    this.surname = surname;
    this.nickName = nickName;
    this.speciality = speciality;

  public void fight(T opponent) {"{} is going to fight against {}", this, opponent);

  public String toString() {
    return name + " \"" + nickName + "\" " + surname;

The followings are some subtypes of MmaFighter

class MmaBantamweightFighter extends MmaFighter<MmaBantamweightFighter> {

  public MmaBantamweightFighter(String name, String surname, String nickName, String speciality) {
    super(name, surname, nickName, speciality);


public class MmaHeavyweightFighter extends MmaFighter<MmaHeavyweightFighter> {

  public MmaHeavyweightFighter(String name, String surname, String nickName, String speciality) {
    super(name, surname, nickName, speciality);


A fighter is allowed to fight an opponent of the same weight classes, if the opponent is of a different weight class
there is an error

MmaBantamweightFighter fighter1 = new MmaBantamweightFighter("Joe", "Johnson", "The Geek", "Muay Thai");
MmaBantamweightFighter fighter2 = new MmaBantamweightFighter("Ed", "Edwards", "The Problem Solver", "Judo");
fighter1.fight(fighter2); // This is fine

MmaHeavyweightFighter fighter3 = new MmaHeavyweightFighter("Dave", "Davidson", "The Bug Smasher", "Kickboxing");
MmaHeavyweightFighter fighter4 = new MmaHeavyweightFighter("Jack", "Jackson", "The Pragmatic", "Brazilian Jiu-Jitsu");
fighter3.fight(fighter4); // This is fine too

fighter1.fight(fighter3); // This will raise a compilation error

Class diagram

alt text
CRTP class diagram


Use the Curiously Recurring Template Pattern when

  • You have type conflicts when chaining methods in an object hierarchy
  • You want to use a parameterized class method that can accept subclasses of the class as arguments, allowing it to be applied to objects that inherit from the class
  • You want certain methods to work only with instances of the same type, such as for achieving mutual comparability.


Known uses