retornando um objeto vazio

Qual é a maneira correta de retornar um Voidtipo, quando não é um primitivo? Por exemplo. Atualmente, uso null como abaixo.

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

class A implements B<Void>{

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

A classe Void é uma classe de espaço reservado que não pode ser instanciada para conter uma referência ao objeto Class que representa a palavra-chave Java void.

Portanto, qualquer uma das opções a seguir seria suficiente:

• parametrizando com Objecte retornando new Object()ounull
• parametrizando com Voide retornandonull
• parametrizando com um NullObjectseu

Você não pode fazer este método voide qualquer outra coisa retorna algo . Como esse algo é ignorado, você pode retornar qualquer coisa.

Java 8 introduziu uma nova classe,, Optional<T>que pode ser usada em tais casos. Para usá-lo, você modificaria seu código ligeiramente da seguinte maneira:

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

class A implements B<Void>{

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

Isso permite que você garanta que sempre obterá um valor de retorno não nulo de seu método, mesmo quando não houver nada para retornar. Isso é especialmente poderoso quando usado em conjunto com ferramentas que detectam quando nullpode ou não pode ser retornado, por exemplo, o Eclipse @NonNulle @Nullableanotações.

Se você simplesmente não precisa de nada como seu tipo, pode usar void. Isso pode ser usado para implementar funções ou ações. Você poderia então fazer algo assim:

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

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

    abstract void executeInternal();
}

Ou você pode omitir a classe abstrata e retornar null em todas as ações que não exigem um valor de retorno.

Você pode então usar essas ações como esta:

Dado um método

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

você pode chamá-lo assim

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

ou, para a ação anular (observe que você não está atribuindo o resultado a nada)

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

Só por causa disso, é claro que existe a possibilidade de criar Voidinstância usando reflexão:

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

Você provavelmente não fará isso na produção.

Não existe um tipo genérico que diga ao compilador que um método não retorna nada.

Acredito que a convenção é usar Object ao herdar como um parâmetro de tipo

OU

Propague o parâmetro de tipo e deixe os usuários de sua classe instanciarem usando Object e atribuindo o objeto a uma variável digitada usando um caractere curinga ?:

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

class A<T> implements B<T>{

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

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