devolviendo un objeto Void

Question

¿Cuál es la forma correcta de devolver un tipo Void, cuando no es un primitivo? P.ej. Actualmente uso null como abajo.

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

class A implements B<Void>{ 

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

Answer 1

La clase Void es un marcador de posición de clase crearse instancias para almacenar una referencia al objeto de clase que representa el vacío de palabras clave de Java.

Así que cualquiera de los siguientes sería suficiente:

• parametrización con Object y volviendo new Object() o null
• parametrización con Void y volviendo null
• parametrización con un NullObject tuya

No puede hacer este método void, y cualquier cosa devuelve algo. Como ese algo se ignora, puedes devolver cualquier cosa.

Answer 2

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

Creo que la convención es utilizar objetos al heredar como un parámetro de tipo

O

Propagar el parámetro de tipo y luego dejar que los usuarios de su instantiate clase utilizando objetos y asignar el objeto a una mecanografiada variables utilizando un tipo 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>(); 

Answer 3

Si sólo no necesita nada como su tipo, se puede utilizar sin efecto. Esto se puede usar para implementar funciones o acciones. A continuación, podría 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 usted podría omitir la clase abstracta, y hacer la hipótesis nula de retorno en cada acción que no requiere un valor de retorno a sí mismo.

A continuación, podría utilizar esas acciones como esta:

da un método

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

se le puede llamar como

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

o, por la acción de vacío (tenga en cuenta que' no está asignando el resultado a nada)

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

Answer 4

Java 8 ha introducido una nueva clase, Optional<T>, que se puede usar en tales casos.Para usarlo, usted modificar su código ligeramente 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 que siempre obtiene un valor de retorno no nulo de su método, incluso cuando no hay nada que regreso. Esto es especialmente poderoso cuando se usa junto con herramientas que detectan cuándo null puede o no ser devuelto, p. las anotaciones Eclipse @NonNull y @Nullable.