Rückgabe eines Void-Objekts

Was ist der richtige Weg, um einen VoidTyp zurückzugeben, wenn er kein Grundelement ist? Z.B. Ich benutze derzeit null wie unten.

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

class A implements B<Void>{

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

Die Void-Klasse ist eine nicht instabilisierbare Platzhalterklasse, die einen Verweis auf das Class-Objekt enthält, das das Java-Schlüsselwort void darstellt.

Folgendes würde also ausreichen:

• parametrieren mit Objectund zurückgeben new Object()odernull
• Parametrieren mit Voidund Zurückgebennull
• Parametrieren mit einem NullObjectvon Ihnen

Sie können diese Methode nicht ausführen void, und alles andere gibt etwas zurück . Da dieses Etwas ignoriert wird, können Sie alles zurückgeben.

Java 8 hat eine neue Klasse eingeführt, Optional<T>die in solchen Fällen verwendet werden kann. Um es zu verwenden, würden Sie Ihren Code wie folgt leicht ändern:

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

class A implements B<Void>{

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

Auf diese Weise können Sie sicherstellen, dass Ihre Methode immer einen Rückgabewert ungleich Null erhält, auch wenn nichts zurückgegeben werden muss. Dies ist besonders leistungsfähig, wenn es in Verbindung mit Tools verwendet wird, die erkennen, wann zurückgegeben werden nullkann oder nicht, z. B. Eclipse @NonNullund @NullableAnmerkungen.

Wenn Sie einfach nichts als Typ benötigen, können Sie void verwenden. Dies kann zum Implementieren von Funktionen oder Aktionen verwendet werden. Sie könnten dann so etwas tun:

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

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

    abstract void executeInternal();
}

Oder Sie können die abstrakte Klasse weglassen und die Rückgabe null in jeder Aktion ausführen, für die selbst kein Rückgabewert erforderlich ist.

Sie können diese Aktionen dann folgendermaßen verwenden:

Eine Methode gegeben

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

man kann es so nennen

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

oder für die void-Aktion (beachten Sie, dass Sie das Ergebnis nichts zuweisen)

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

Nur deswegen gibt es natürlich die Möglichkeit, eine VoidInstanz mithilfe von Reflexion zu erstellen :

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.
        }
    }
}

Das werden Sie in der Produktion wahrscheinlich nicht tun.

Es gibt keinen generischen Typ, der dem Compiler mitteilt, dass eine Methode nichts zurückgibt.

Ich glaube, die Konvention besteht darin, Object beim Erben als Typparameter zu verwenden

ODER

Verbreiten Sie den Typparameter nach oben und lassen Sie die Benutzer Ihrer Klasse mithilfe von Object instanziieren und das Objekt einer Variablen zuweisen, die mit einem Typ-Platzhalter eingegeben wurde ?:

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

class A<T> implements B<T>{

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

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