Zastosowania typu odwołania Java Void?

Jest Java Void- wielkie V-- rodzaj odniesienia . Jedyna sytuacja, jaką kiedykolwiek widziałem, to parametryzacja Callables

final Callable<Void> callable = new Callable<Void>() {
            public Void call() {
                foobar();
                return null;
            }
        };

Czy są jakieś inne zastosowania Voidtypu referencyjnego Java ? Czy kiedykolwiek można mu przypisać coś innego niż null? Jeśli tak, czy masz przykłady?

Voidstało się konwencją dla ogólnego argumentu, którym nie jesteś zainteresowany. Nie ma powodu, dla którego miałbyś używać innego typu, którego nie można utworzyć instancji, takiego jak System.

Jest również często używany na przykład w Mapwartościach (chociaż Collections.newSetFromMapużywa Booleanjako map nie musi akceptować nullwartości) i java.security.PrivilegedAction.

Napisałem wpis na bloguVoid kilka lat temu.

Możesz stworzyć instancję Void za pomocą odbić, ale nie są one przydatne do niczego. Void to sposób na wskazanie, że metoda ogólna nic nie zwraca.

Constructor<Void> constructor = Void.class.getDeclaredConstructor();
constructor.setAccessible(true);
Void v = constructor.newInstance();
System.out.println("I have a " + v);

drukuje coś w rodzaju

I have a java.lang.Void@75636731

Future<Void>działa jak urok. :)

Biorąc pod uwagę, że nie ma publicznych konstruktorów , powiedziałbym, że nie można mu przypisać niczego innego niż null. Użyłem go tylko jako symbolu zastępczego dla „Nie muszę używać tego ogólnego parametru”, jak pokazuje Twój przykład.

Można go również wykorzystać do refleksji, z tego, co mówi jego Javadoc :

Klasa Void jest nieinstanowalną klasą zastępczą, która zawiera odwołanie do obiektu Class reprezentującego słowo kluczowe void w języku Java.

Wszystkie pierwotne klasy osłony ( Integer, Byte, Boolean, Double, itd.) Zawierają odniesienia do odpowiedniej grupy pierwotnej w statycznym TYPEpolu, na przykład:

Integer.TYPE == int.class
Byte.TYPE == byte.class
Boolean.TYPE == boolean.class
Double.TYPE == double.class

Voidzostał początkowo utworzony jako miejsce, w którym można umieścić odniesienie do voidtypu:

Void.TYPE == void.class

Jednak tak naprawdę nic nie zyskujesz, używając Void.TYPE. Kiedy używasz void.class, jest znacznie wyraźniejsze, że robisz coś z voidtypem.

Na marginesie, kiedy ostatnio go próbowałem, BeanShell nie rozpoznał void.class, więc musisz Void.TYPEtam użyć .

Kiedy używasz wzorca gościa , bardziej przejrzystym może być użycie Void zamiast Object, gdy chcesz mieć pewność, że zwracana wartość będzie zerowa

Przykład

public interface LeavesVisitor<OUT>
{
   OUT visit(Leaf1 leaf);

   OUT visit(Leaf2 leaf);
}

Kiedy zaimplementujesz swojego gościa, możesz jawnie ustawić OUT jako Void, abyś wiedział, że twój gość zawsze zwróci wartość null, zamiast używać Object

public class MyVoidVisitor implements LeavesVisitor<Void>
{
    Void visit(Leaf1 leaf){
        //...do what you want on your leaf
        return null;
    }

    Void visit(Leaf2 leaf){
        //...do what you want on your leaf
        return null;
    }
}

Przed typami generycznymi został utworzony dla interfejsu API odbicia, aby przechowywać TYPE zwracany przez Method.getReturnType () dla metody void, odpowiadającej innym klasom typów pierwotnych.

EDYCJA: Z JavaDoc of Void: „Klasa Void jest nieinstanowalną klasą zastępczą, która zawiera odniesienie do obiektu Class reprezentującego słowo kluczowe Java void”. Przed pojawieniem się Generics nie zdaję sobie sprawy z niczego innego niż refleksja.

Ponieważ nie możesz utworzyć instancji Void, możesz użyć obiektu Apache commons Null , więc

Null aNullObject = ObjectUtils.Null;
Null noObjectHere = null;

w pierwszej linii masz obiekt, więc aNullObject != nulltrzyma się, podczas gdy w drugiej linii nie ma odniesienia, więc noObjectHere == nulltrzyma

Odpowiadając na pierwotne pytanie autora, celem tego jest odróżnienie „nic” od „niczego”, które są zupełnie różnymi rzeczami.

PS: Powiedz nie wzorowi obiektu o wartości Null

Pustka jest tworzona, aby owinąć jej prymitywny typ pustki. Każdy typ pierwotny ma odpowiadający mu typ referencyjny. Void służy do tworzenia instancji klasy ogólnej lub użycia metody ogólnej, argumentów ogólnych, którymi nie jesteś zainteresowany. A oto przykład ...

public void onNewRegistration() {
    newRegistrationService.createNewUser(view.getUsername(), view.getPassword(),
            view.getInitialAmount(), view.getCurrency(), new AsyncCallback<Void>() {
      @Override
      public void onFailure(Throwable caught) {

      }

      @Override
      public void onSuccess(Void result) {
        eventBus.fireEvent(new NewRegistrationSuccessEvent());
      }
    });
  } 

tutaj, jak widzisz, nie chcę niczego od serwera, o który proszę, aby utworzyć nowe rejestracje, ale public interface AsyncCallback<T> { .... }jest to interfejs ogólny, więc udostępniam Void, ponieważ typy generyczne nie akceptują typów pierwotnych

Jest również często używany w wywołaniach zwrotnych uzupełniania Async-IO, gdy nie potrzebujesz Attachmentobiektu. W takim przypadku określasz wartość null w operacji IO i implementujesz CompletionHandler<Integer,Void>.

Może to być rzadki przypadek, ale kiedyś użyłem Voidw klasach aspektów.

Był to aspekt, który działa po metodach, które mają @Logadnotację i rejestruje zwróconą metodę oraz pewne informacje, jeśli typ zwracanej metody nie jest nieważny.

 @AfterReturning(value = "@annotation(log)", 
       returning = "returnValue", 
       argNames = "joinPoint, log, returnValue"
      )
    public void afterReturning(final JoinPoint joinPoint, final Log log,
            final Object returnValue) {

            Class<?> returnType = ((MethodSignature) joinPoint.getSignature())
            .getReturnType();
           if (Void.class.isAssignableFrom (returnType)) ) {
            //Do some log
         }
}