Comment puis-je faire référence au type actuel à l'aide d'une variable de type en Java ?

Comment référencer le type actuel avec une variable de type

Pouvez-vous faire référence au type actuel avec une variable de type ?

Supposons que vous créer une fonction pour renvoyer une instance du type actuel. Existe-t-il un moyen de faire en sorte que la variable de type T fasse référence au sous-type précis (donc T devrait faire référence à B dans la classe B) ?

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

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

Solution

Pour s'appuyer sur la réponse de StriplingWarrior, le La conception suivante est requise (une formule pour une API de constructeur hiérarchique fluide) :

Tout d'abord, une classe de base abstraite (ou interface) qui établit le contrat pour récupérer le type d'exécution d'une instance étendant la classe :

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

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

Les classes d'extension intermédiaires doivent être abstraites et conserver le paramètre de type récursif SELF :

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

    MyBaseClass() { }

    public SELF baseMethod() {

        //logic

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

Les classes dérivées peuvent suivre la même chose modèle. Cependant, aucune de ces classes ne peut être utilisée directement comme types de variables sans utiliser de types bruts ou de caractères génériques (ce qui mine l'objectif du modèle). Par exemple (si MyClass n'était pas abstraite) :

//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>

C'est pourquoi ces classes sont appelées « intermédiaires » et pourquoi elles doivent toutes être déclarées abstraites. Les classes "Leaf" sont nécessaires pour compléter la boucle et utiliser le modèle, qui résout le paramètre de type hérité SELF avec son type et implémente self(). Pour éviter de rompre le contrat, ils doivent également être marqués comme finaux :

public final class MyLeafClass extends MyBaseClass<myleafclass> {

    @Override
    MyLeafClass self() {
        return this;
    }

    public MyLeafClass leafMethod() {

        //logic

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

L'utilisation de telles classes rend le modèle utilisable :

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

Le principal avantage est que les appels de méthode peuvent être enchaîné de haut en bas dans la hiérarchie des classes tout en conservant le même type de retour spécifique.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!