Can Type Variables Refer to Their Defining Class in Java?

Can Type Variables Refer to the Current Type?

Suppose you want to create a function that returns an instance of the current type. Is there a way to ensure that T refers specifically to the subtype (e.g., T should refer to B in class B)?

Implementing the Solution

Extending StriplingWarrior's response, the following pattern is essential for achieving this (a recipe for a hierarchical fluent builder API):

SOLUTION

1. Define a Base Abstract Class or Interface:

   Establish a contract for obtaining the runtime type of an instance extending the class:

   abstract class SelfTyped<self extends selftyped>> {
      abstract SELF self();
   }</self>

2. Create Intermediate Abstract Classes:

   Intermediate classes maintain the recursive type parameter SELF. They should be abstract to prevent direct use:

   public abstract class MyBaseClass<self extends mybaseclass>> extends SelfTyped<self> {...}</self></self>

3. Define Leaf Classes:

   The final classes resolve the SELF type parameter with their own type. Make them final for safety:

   public final class MyLeafClass extends MyBaseClass<myleafclass> {...}</myleafclass>

Example Usage:

MyLeafClass mlc = new MyLeafClass().baseMethod().leafMethod();
AnotherLeafClass alc = new AnotherLeafClass().baseMethod().anotherLeafMethod();

Caution and Conclusion

This pattern is an implementation of the "curiously recurring template" in Java. While powerful, it requires careful use and is best reserved for internal APIs only. The pattern is inherently unsafe and must be used with caution to avoid misuse. However, when employed effectively, it can enhance the expressiveness and usability of builder APIs.

The above is the detailed content of Can Type Variables Refer to Their Defining Class in Java?. For more information, please follow other related articles on the PHP Chinese website!