renvoyer un objet Void

Quelle est la manière correcte de renvoyer un Voidtype, 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;
    }
}

La classe Void est une classe d'espace réservé non instable pour contenir une référence à l'objet Class représentant le mot clé Java void.

Donc, l'une des choses suivantes suffirait:

• paramétrage avec Objectet retour new Object()ounull
• paramétrage avec Voidet retournull
• paramétrage avec l'un NullObjectde vos

Vous ne pouvez pas utiliser cette méthode void, et tout le reste renvoie quelque chose . Puisque ce quelque chose est ignoré, vous pouvez renvoyer n'importe quoi.

Java 8 a introduit une nouvelle classe Optional<T>, qui peut être utilisée dans de tels cas. Pour l'utiliser, vous modifierez légèrement votre code 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 vous toujours obtenez une valeur de retour non nulle de votre méthode, même s'il n'y a rien à retourner. C'est particulièrement puissant lorsqu'il est utilisé en conjonction avec des outils qui détectent quand nullpeut ou ne peut pas être retourné, par exemple l'Eclipse @NonNullet les @Nullableannotations.

Si vous n'avez simplement besoin de rien comme type, vous pouvez utiliser void. Cela peut être utilisé pour implémenter 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();
}

Ou vous pouvez omettre la classe abstraite et effectuer le retour null dans chaque action qui ne nécessite 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();
}

tu peux l'appeler comme

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

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

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

Juste pour le plaisir, il y a bien sûr la possibilité de créer une Voidinstance en utilisant la réflexion:

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

class A implements B<Void>{

    public Void method(){
        // do something

        try {
            Constructor<Void> voidConstructor = Void.class.getDeclaredConstructor();
            voidConstructor.setAccessible(true);
            return voidConstructor.newInstance();
        } catch (Exception ex) {
            // Rethrow, or return null, or whatever.
        }
    }
}

Vous ne ferez probablement pas cela en production.

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

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

OU

Propagez le paramètre de type vers le haut, puis laissez les utilisateurs de votre classe instancier en utilisant Object et en affectant l'objet à une variable tapée à l'aide d'un caractère générique de type ?:

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

class A<T> implements B<T>{

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

A<?> a = new A<Object>();