restituire un oggetto Void

Question

Qual è il modo corretto per restituire un tipo Void, quando non è un primitivo? Per esempio. Attualmente utilizzo null come di seguito.

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

class A implements B<Void>{ 

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

Answer 1

La classe Void è una classe segnaposto istanziabili di tenere un riferimento all'oggetto classe che rappresenta la parola chiave void Java.

Così una delle seguenti sarebbe sufficiente:

• parametrizzazione con Object e tornando new Object() o null
• parametrizzazione con Void e tornando null
• parametrizzazione con un NullObject tuo

Non è possibile effettuare questo metodo void e qualsiasi altra cosa restituisce qualcosa. Dal momento che quel qualcosa viene ignorato, puoi restituire qualsiasi cosa.

Answer 2

Non esiste un tipo generico che dirà al compilatore che un metodo non restituisce nulla.

Credo che la convenzione è quello di utilizzare l'oggetto quando si eredita come un parametro di tipo

O

propagare il parametro di tipo e poi lasciare che gli utenti della vostra classe instantiate utilizzando oggetti e assegnare l'oggetto a una tipizzato variabile utilizzando un tipo-jolly ?:

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

Se proprio non si ha bisogno di qualcosa come tipo, è possibile utilizzare vuoto. Questo può essere usato per implementare funzioni o azioni. È quindi possibile fare qualcosa del genere:

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

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

    abstract void executeInternal(); 
} 

Oppure si potrebbe omettere la classe astratta, e fare il return null in ogni azione che non richiede un valore di ritorno da soli.

È quindi possibile utilizzare queste azioni come questa:

dato un metodo di

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

si può chiamare come

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

o, per l'azione vuoto (si noti che è' non assegnando il risultato a nulla)

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

Answer 4

Java 8 ha introdotto una nuova classe, Optional<T>, che può essere utilizzata in questi casi.Per usarlo, devi modificare il codice di un po 'come segue:

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

class A implements B<Void>{ 

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

questo modo è possibile garantire che si sempre ottiene un valore di ritorno non nullo dal tuo metodo, anche quando non c'è nulla di ritorno. Ciò è particolarmente potente se utilizzato insieme a strumenti che rilevano quando null può o non può essere restituito, ad es. le annotazioni di Eclipse @NonNull e @Nullable.