web-dev-qa-db-fra.com

Classe générique qui étend la classe et implémente l'interface

Pour réduire la dépendance de la classe, je veux envoyer un paramètre (en utilisant une classe générique) au constructeur qui étend une certaine classe et implémente l'interface, par exemple

public interface SomeInterface{
    public void someMethod();
}

public class MyFragment extends Fragment implements SomeInterface{
    //implementation
}

//here is classs, that I need to create. T must extend Fragment and implements 
//SomeInterface. But, I'm afraid, if I'll use MyFragment directly, it will create a
//dependence of SomeClass from MyFragment.

public class SomeClass /*generic?*/ {
    public SomeClass(T parent);
}

C'est possible?

Plus loin, en utilisant ma classe T, je veux créer des vues, en utilisant T.getActivity () comme contexte.

javaandroidgenerics
54
Dmitry Zaytsev

T doit étendre Fragment et implémenter SomeInterface

Dans ce cas, vous pouvez déclarer SomeClass comme suit:

public class SomeClass<T extends Fragment & SomeInterface>

Cela nécessiterait un objet de type T pour étendre Fragment et implémenter SomeInterface.

De plus, en utilisant ma classe T, je veux créer des vues, en utilisant T.getActivity () comme contexte.

Je ne connais pas Android, mais si getActivity() est une méthode d'instance publique déclarée dans Fragment alors il sera tout à fait possible de l'appeler sur une instance de T, puisque le le compilateur saura que tous les T doivent hériter de cette méthode.

121
Paul Bellora

Voulez-vous faire quelque chose comme ça?

class SomeClass {}

interface SomeInterface{
    public void someMethod();
}

class AGenericClass<T> extends SomeClass implements SomeInterface {
    public void someMethod() {}
}

C'est permis.

Mais quel est Android spécifique à votre question? Je pense que je dois manquer quelque chose, pouvez-vous fournir plus de détails?

mise à jour ci-dessous

Je ne suis toujours pas totalement sûr de ce que vous voulez faire, et je ne suis pas sûr non plus que vous deviez vous soucier de la dépendance tout de suite, mais c'est également légal, en utilisant paramètres de type bornés :

interface SomeInterface{
    public void someMethod();
}

class Fragment {
    public void aMethodInFragment() { }
}

public class SomeClass <T extends Fragment & SomeInterface> {
    public SomeClass(T parent) {
        parent.someMethod();
        parent.aMethodInFragment();
    }
}

Le paramètre de type <T extends Fragment & SomeInterface> spécifie que T doit être une sous-classe de Fragment et implémenter SomeInterface.

6
michiakig

C'est facile si je comprends que vous vous corrigez d'avoir un type T qui étend Fragment et implémente une interface. Il faut donc écrire quelque chose comme ça.

abstract class TemplateFragment extends Fragment implements SomeInterface{}

puis dans vos cours

class SomeClass<T extends TemplateFragment> {
...
}

Il fera l'affaire.

4
Orest