zwracanie obiektu Void

Jaki jest prawidłowy sposób zwracania Voidtypu, jeśli nie jest to typ pierwotny? Na przykład. Obecnie używam null, jak poniżej.

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

class A implements B<Void>{

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

Klasa Void jest nieinstanowalną klasą zastępczą, która zawiera odwołanie do obiektu Class reprezentującego słowo kluczowe void w języku Java.

Wystarczyłoby więc jedno z poniższych:

• parametryzacja za pomocą Objecti zwracanie new Object()lubnull
• parametryzacja Voidzi zwracanienull
• parametryzacja z NullObjectTwoim

Nie możesz zrobić tej metody void, a cokolwiek innego coś zwraca . Ponieważ to coś jest ignorowane, możesz zwrócić wszystko.

Java 8 wprowadziła nową klasę Optional<T>, która może być używana w takich przypadkach. Aby z niego skorzystać, zmodyfikuj nieco swój kod w następujący sposób:

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

class A implements B<Void>{

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

Pozwala to upewnić się, że z metody zawsze zostanie zwrócona wartość niezerowa, nawet jeśli nie ma nic do zwrócenia. Jest to szczególnie przydatne w połączeniu z narzędziami, które wykrywają, kiedy nullmożna lub nie można zwrócić, np. Eclipse @NonNulli @Nullableadnotacje.

Jeśli po prostu nie potrzebujesz niczego jako swojego typu, możesz użyć void. Można to wykorzystać do implementacji funkcji lub akcji. Możesz wtedy zrobić coś takiego:

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

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

    abstract void executeInternal();
}

Możesz też pominąć klasę abstrakcyjną i samodzielnie zwrócić wartość null w każdej akcji, która nie wymaga zwracania wartości.

Następnie możesz użyć tych akcji w następujący sposób:

Biorąc pod uwagę metodę

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

możesz to nazwać jak

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

lub, dla akcji void (pamiętaj, że nie przypisujesz wyniku do niczego)

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

W tym celu istnieje oczywiście możliwość stworzenia Voidinstancji za pomocą refleksji:

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

Prawdopodobnie nie zrobisz tego w produkcji.

Nie ma typu ogólnego, który powie kompilatorowi, że metoda nic nie zwraca.

Uważam, że konwencja polega na używaniu Object podczas dziedziczenia jako parametru typu

LUB

Propaguj parametr typu w górę, a następnie pozwól użytkownikom Twojej klasy na tworzenie instancji przy użyciu Object i przypisywanie obiektu do zmiennej wpisanej przy użyciu symbolu wieloznacznego typu ?:

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

class A<T> implements B<T>{

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

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