restituire un oggetto Void

Qual è il modo corretto per restituire un Voidtipo, quando non è una primitiva? Per esempio. Attualmente uso null come di seguito.

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

class A implements B<Void>{

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

La classe Void è una classe segnaposto non istanziabile per contenere un riferimento all'oggetto Class che rappresenta la parola chiave Java void.

Quindi una qualsiasi delle seguenti operazioni sarebbe sufficiente:

• parametrizzare con Objecte restituire new Object()onull
• parametrizzazione con Voide ritornonull
• parametrizzare con un NullObjecttuo

Non puoi creare questo metodo voide qualsiasi altra cosa restituisce qualcosa . Poiché quel qualcosa viene ignorato, puoi restituire qualsiasi cosa.

Java 8 ha introdotto una nuova classe Optional<T>, che può essere utilizzata in questi casi. Per usarlo, modifichi leggermente il tuo codice come segue:

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

class A implements B<Void>{

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

Ciò ti consente di assicurarti di ottenere sempre un valore restituito non nullo dal tuo metodo, anche quando non c'è nulla da restituire. È particolarmente potente se utilizzato insieme a strumenti che rilevano quando nullpuò o non può essere restituito, ad esempio Eclipse @NonNulle @Nullableannotazioni.

Se semplicemente non hai bisogno di nulla come tipo, puoi usare void. Può essere utilizzato per implementare funzioni o azioni. Potresti quindi 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 puoi omettere la classe astratta e restituire null in ogni azione che non richiede un valore di ritorno.

Puoi quindi usare quelle azioni in questo modo:

Dato un metodo

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

puoi chiamarlo come

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

oppure, per l'azione void (nota che non stai assegnando il risultato a nulla)

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

Solo per il gusto di farlo, c'è ovviamente la possibilità di creare Voidistanze usando la riflessione:

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

Probabilmente non lo farai in produzione.

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

Credo che la convenzione sia quella di utilizzare Object quando si eredita come parametro di tipo

O

Propaga il parametro di tipo verso l'alto e quindi consenti agli utenti della tua classe di creare un'istanza utilizzando Object e assegnando l'oggetto a una variabile digitata utilizzando un carattere jolly di tipo ?:

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

class A<T> implements B<T>{

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

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