mengembalikan objek Void

Apa cara yang benar untuk mengembalikan sebuah Voidtipe, jika itu bukan primitif? Misalnya. Saat ini saya menggunakan null seperti di bawah ini.

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

class A implements B<Void>{

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

Kelas Void adalah kelas tempat penampung yang tidak dapat dibuktikan untuk menyimpan referensi ke objek Kelas yang mewakili kata kunci Java void.

Jadi, salah satu dari berikut ini sudah cukup:

• parameterisasi dengan Objectdan kembali new Object()ataunull
• parameterisasi dengan Voiddan kembalinull
• parameterizing dengan NullObjectmilik Anda

Anda tidak dapat membuat metode ini void, dan yang lainnya mengembalikan sesuatu . Karena sesuatu itu diabaikan, Anda dapat mengembalikan apapun.

Java 8 telah memperkenalkan kelas baru Optional<T>, yang dapat digunakan dalam kasus seperti itu. Untuk menggunakannya, Anda akan sedikit mengubah kode sebagai berikut:

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

class A implements B<Void>{

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

Ini memungkinkan Anda untuk memastikan bahwa Anda selalu mendapatkan nilai pengembalian bukan nol dari metode Anda, bahkan ketika tidak ada yang dikembalikan. Itu sangat kuat ketika digunakan bersama dengan alat yang mendeteksi kapan nullbisa atau tidak bisa dikembalikan, misalnya Eclipse @NonNulldan @Nullableanotasi.

Jika Anda tidak membutuhkan apa pun sebagai tipe Anda, Anda dapat menggunakan void. Ini dapat digunakan untuk mengimplementasikan fungsi, atau tindakan. Anda kemudian dapat melakukan sesuatu seperti ini:

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

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

    abstract void executeInternal();
}

Atau Anda bisa menghilangkan kelas abstrak, dan melakukan pengembalian null dalam setiap tindakan yang tidak memerlukan nilai pengembalian sendiri.

Anda kemudian dapat menggunakan tindakan seperti ini:

Diberikan metode

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

Anda bisa menyebutnya seperti

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

atau, untuk tindakan void (perhatikan bahwa Anda tidak menetapkan hasilnya untuk apa pun)

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

Hanya demi itu, tentu saja ada kemungkinan untuk membuat Voidinstance menggunakan refleksi:

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

Anda mungkin tidak akan melakukannya dalam produksi.

Tidak ada tipe generik yang akan memberi tahu kompiler bahwa sebuah metode tidak mengembalikan apa-apa.

Saya percaya konvensi adalah menggunakan Object saat mewarisi sebagai parameter tipe

ATAU

Sebarkan parameter type ke atas dan kemudian biarkan pengguna kelas Anda membuat instance menggunakan Object dan menugaskan objek ke variabel yang diketik menggunakan jenis-wildcard ?:

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

class A<T> implements B<T>{

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

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