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

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

DDD
Libérer: 2024-12-24 21:53:14
original
421 Les gens l'ont consulté

How Can I Refer to the Current Type Using a Type Variable in 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();
}
Copier après la connexion

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<SELF>> {

   /**
    * @return This instance.
    */
   abstract SELF self();
}
Copier après la connexion

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<SELF>>
extends SelfTyped<SELF> {

    MyBaseClass() { }

    public SELF baseMethod() {

        //logic

        return self();
    }
}
Copier après la connexion

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<MyBaseClass>> mbc3 =
        new MyBaseClass<MyBaseClass<MyBaseClass>>().baseMethod();
Copier après la connexion

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
    }
}
Copier après la connexion

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

MyLeafClass mlc = new MyLeafClass().baseMethod().leafMethod();
AnotherLeafClass alc = new AnotherLeafClass().baseMethod().anotherLeafMethod();
Copier après la connexion

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!

source:php.cn
Déclaration de ce site Web
Le contenu de cet article est volontairement contribué par les internautes et les droits d'auteur appartiennent à l'auteur original. Ce site n'assume aucune responsabilité légale correspondante. Si vous trouvez un contenu suspecté de plagiat ou de contrefaçon, veuillez contacter admin@php.cn
Tutoriels populaires
Plus>
Derniers téléchargements
Plus>
effets Web
Code source du site Web
Matériel du site Web
Modèle frontal