How Can I Refer to the Current Type Using a Type Variable in Java?

How to Reference the Current Type with a Type Variable

Can you refer to the current type with a type variable?

Suppose you're creating a function to return an instance of the current type. Is there a way to make the type variable T refer to the precise subtype (so T should refer to B in class B)?

class A {
    <t extends a> void foo();
}

class B extends A {
    @Override
    T foo();
}</t>

Solution

To build on StriplingWarrior's response, the following design is required (a formula for a hierarchical fluent builder API):

Firstly, an abstract base class (or interface) that establishes the contract for retrieving the runtime type of an instance extending the class:

/**
 * @param <self> The runtime type of the implementer.
 */
abstract class SelfTyped<self extends selftyped>> {

   /**
    * @return This instance.
    */
   abstract SELF self();
}</self></self>

Intermediate extending classes must be abstract and maintain the recursive type parameter SELF:

public abstract class MyBaseClass<self extends mybaseclass>>
extends SelfTyped<self> {

    MyBaseClass() { }

    public SELF baseMethod() {

        //logic

        return self();
    }
}</self></self>

Classes derived further can follow the same pattern. However, none of these classes can be utilized directly as types of variables without using raw types or wildcards (which undermines the purpose of the pattern). For instance (if MyClass wasn't abstract):

//wrong: raw type warning
MyBaseClass mbc = new MyBaseClass().baseMethod();

//wrong: type argument is not within the bounds of SELF
MyBaseClass<mybaseclass> mbc2 = new MyBaseClass<mybaseclass>().baseMethod();

//wrong: no way to correctly declare the type, as its parameter is recursive!
MyBaseClass<mybaseclass>> mbc3 =
        new MyBaseClass<mybaseclass>>().baseMethod();</mybaseclass></mybaseclass></mybaseclass></mybaseclass>

This is why these classes are referred to as "intermediate," and why they should all be declared abstract. "Leaf" classes are required to complete the loop and make use of the pattern, which resolve the inherited type parameter SELF with its type and implement self(). To prevent breaking the contract, they should also be marked as final:

public final class MyLeafClass extends MyBaseClass<myleafclass> {

    @Override
    MyLeafClass self() {
        return this;
    }

    public MyLeafClass leafMethod() {

        //logic

        return self(); //could also just return this
    }
}</myleafclass>

Using such classes makes the pattern usable:

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

The primary advantage of this is that method calls can be chained up and down the class hierarchy while maintaining the same specific return type.

The above is the detailed content of How Can I Refer to the Current Type Using a Type Variable in Java?. For more information, please follow other related articles on the PHP Chinese website!