Skip to content

Latest commit

 

History

History
 
 

crtp

Folders and files

NameName
Last commit message
Last commit date

parent directory

..
 
 
 
 
 
 
 
 
title language category tag
Curiously Recurring Template Pattern
en
Structural
Extensibility
Instantiation

Name / classification

Curiously Recurring Template Pattern

Also known as

Recursive Type Bound, Recursive Generic

Intent

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

Explanation

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) {
    this.name = name;
    this.surname = surname;
    this.nickName = nickName;
    this.speciality = speciality;
  }

  @Override
  public void fight(T opponent) {
    LOGGER.info("{} is going to fight against {}", this, opponent);
  }

  @Override
  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

Applicability

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.

Tutorials

Known uses

Credits