devolver un objeto vacío

¿Cuál es la forma correcta de devolver un Voidtipo, cuando no es un primitivo? P.ej. Actualmente uso null como se muestra a continuación.

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

class A implements B<Void>{

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

La clase Void es una clase de marcador de posición no desinstalable para contener una referencia al objeto Class que representa la palabra clave de Java void.

Entonces, cualquiera de los siguientes sería suficiente:

• parametrizar con Objecty devolver new Object()onull
• parametrizar con Voidy regresarnull
• parametrizar con uno NullObjecttuyo

No puede hacer este método voidy cualquier otra cosa devuelve algo . Dado que ese algo se ignora, puede devolver cualquier cosa.

Java 8 ha introducido una nueva clase, Optional<T> , que se puede utilizar en tales casos. Para usarlo, modificaría ligeramente su código de la siguiente manera:

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

class A implements B<Void>{

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

Esto le permite asegurarse de obtener siempre un valor de retorno no nulo de su método, incluso cuando no hay nada que devolver. Eso es especialmente poderoso cuando se usa junto con herramientas que detectan cuándo se nullpuede o no se puede devolver, por ejemplo, el Eclipse @NonNully las @Nullableanotaciones.

Si simplemente no necesita nada como su tipo, puede usar void. Esto se puede utilizar para implementar funciones o acciones. Entonces podrías hacer algo como esto:

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

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

    abstract void executeInternal();
}

O puede omitir la clase abstracta y hacer el retorno nulo en cada acción que no requiera un valor de retorno usted mismo.

Luego puede usar esas acciones como esta:

Dado un método

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

puedes llamarlo como

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

o, para la acción nula (tenga en cuenta que no está asignando el resultado a nada)

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

Por el simple hecho de hacerlo, existe, por supuesto, la posibilidad de crear una Voidinstancia mediante la reflexión:

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

Probablemente no haga eso en producción.

No existe un tipo genérico que le diga al compilador que un método no devuelve nada.

Creo que la convención es usar Object cuando se hereda como parámetro de tipo

O

Propague el parámetro de tipo y luego permita que los usuarios de su clase creen una instancia usando Object y asignen el objeto a una variable escrita usando un tipo de comodín ?:

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

class A<T> implements B<T>{

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

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