web-dev-qa-db-fra.com

renvoyer un objet Void)

Quelle est la bonne façon de retourner un type Void, quand ce n'est pas une primitive? Par exemple. J'utilise actuellement null comme ci-dessous.

interface B<E>{ E method(); }

class A implements B<Void>{

    public Void method(){
        // do something
        return null;
    }
}
javagenericsreturn-value
99
Robert

La classe Void est une classe fictive non instanciable destinée à contenir une référence à l'objet Class représentant le mot clé Java void.).

Donc, un des éléments suivants suffirait:

  • paramétrer avec Object et renvoyer new Object() ou null
  • paramétrer avec Void et renvoyer null
  • paramétrer avec un NullObject de votre part

Vous ne pouvez pas faire cette méthode void, et toute autre chose retourne quelque chose. Depuis que quelque chose est ignoré, vous pouvez retourner n'importe quoi.

120
Bozho

Java 8 a introduit une nouvelle classe, Optional<T>, qui peut être utilisé dans de tels cas. Pour l'utiliser, vous devez modifier votre code légèrement comme suit:

interface B<E>{ Optional<E> method(); }

class A implements B<Void>{

    public Optional<Void> method(){
        // do something
        return Optional.empty();
    }
}

Cela vous permet de vous assurer que toujours obtenez une valeur de retour non nulle de votre méthode, même s'il n'y a rien à renvoyer. C'est particulièrement puissant lorsqu'il est utilisé avec des outils qui détectent quand null peut ou ne peut pas être retourné, par exemple. l'Eclipse @NonNull et @Nullable annotations.

12
Erick G. Hagstrom

Si vous n'avez simplement besoin de rien de tel que votre type, vous pouvez utiliser void. Cela peut être utilisé pour mettre en œuvre des fonctions ou des actions. Vous pouvez alors faire quelque chose comme ceci:

interface Action<T> {
    public T execute();
}

abstract class VoidAction implements Action<Void> {
    public Void execute() {
        executeInternal();
        return null;
    }

    abstract void executeInternal();
}

Vous pouvez également omettre la classe abstraite et effectuer la valeur de retour null pour chaque action ne nécessitant pas de valeur de retour vous-même.

Vous pouvez ensuite utiliser ces actions comme ceci:

Étant donné une méthode

private static <T> T executeAction(Action<T> action) {
    return action.execute();
}

vous pouvez l'appeler comme

String result = executeAction(new Action<String>() {
    @Override
    public String execute() {
        //code here
        return "Return me!";
    }
});

ou, pour l'action vide (notez que vous n'attribuez le résultat à rien)

executeAction(new VoidAction() {
    @Override
    public void executeInternal() {
        //code here
    }
});
3
Jorn

Il n'y a pas de type générique qui dira au compilateur qu'une méthode ne retourne rien.

Je crois que la convention consiste à utiliser Object lors de l'héritage en tant que paramètre de type

OR

Propagez le paramètre de type et laissez les utilisateurs de votre classe instancier à l'aide de Object et affecter l'objet à une variable typée à l'aide d'un caractère générique ?:

interface B<E>{ E method(); }

class A<T> implements B<T>{

    public T method(){
        // do something
        return null;
    }
}

A<?> a = new A<Object>();
0
Christopher Oezbek