streamalism.org

1. Áttekintés

Java fejlesztőként találkozhattunk a Üres gépelt valamikor, és azon tűnődött, mi a célja.

Ebben a gyors bemutatóban megismerhetjük ezt a sajátos osztályt, és megtudhatjuk, mikor és hogyan kell használni, valamint hogyan lehet elkerülni a használatát, ha lehetséges.

2. Mi a helyzet Üres típus

A JDK 1.1 óta a Java biztosítja nekünk a Üres típus. Célja egyszerűen a üres return típus osztályként és tartalmazzon egy a-t Osztály közérték. Nem azonnal kivitelezhető, mivel egyetlen kivitelezője privát.

Ezért az egyetlen érték, amelyet hozzárendelhetünk a Üres változó az nulla. Kicsit haszontalannak tűnhet, de most meglátjuk, mikor és hogyan kell használni ezt a típust.

3. Használatok

Vannak olyan helyzetek, amikor a Üres típus érdekes lehet.

3.1. Visszaverődés

Először is használhatnánk reflexió során. Valóban, bármelyik visszatérési típusa üres módszer illeszkedik a Érvénytelen. TÍPUS változó, amely a Osztály korábban említett érték.

Képzeljünk el egy egyszerűt Számológép osztály:

public class Calculator {privát int eredmény = 0; public int add (int szám) {return result + = szám; } public int sub (int szám) {return result - = szám; } public void clear () {eredmény = 0; } public void print () {System.out.println (eredmény); }}

Egyes módszerek egész számot adnak vissza, vannak, amelyek semmit sem adnak vissza. Most tegyük fel, hogy muszáj visszaverődéssel beolvassa az összes olyan módszert, amely semmilyen eredményt nem ad vissza. Ezt a Érvénytelen. TÍPUS változó:

@Test void givenCalculator_whenGettingVoidMethodsByReflection_thenOnlyClearAndPrint () {Method [] calculatorMethods = Calculator.class.getDeclaredMethods (); List calculatorVoidMethods = Tömbök.stream (calculatorMethods). Szűrő (módszer -> method.getReturnType (). Egyenlő (Void.TYPE)) .collect (Collectors.toList ()); assertThat (calculatorVoidMethods) .allMatch (metódus -> Tömbök.asList ("törlés", "nyomtatás"). tartalmazza (metódus.nevet ())); }

Mint láthatjuk, csak a egyértelmű() és nyomtatás() módszereket beolvasták.

3.2. Generikusok

A Üres típus általános osztályokkal van. Tegyük fel, hogy olyan módszert hívunk, amely a Hívható paraméter:

public class Halaszt {public static V defer (Hívható hívható) dobja a Kivételt {return callable.call (); }}

De a Hívható át akarunk menni, nem kell semmit visszaadni. Ezért átmehetünk egy Hívható:

@Test void givenVoidCallable_whenDiffer_thenReturnNull () dobja a Kivételt {Callable callable = new Callable () {@Orride public Void call () {System.out.println ("Hello!"); return null; }}; assertThat (Halaszt. halaszt (meghívható)). isNull (); }

Vagy használhatnánk véletlenszerű típust (pl. Hívható) és visszatér nulla vagy egyáltalán nincs típus (Hívható), de felhasználásával Üres világosan kimondja szándékainkat.

Ezt a módszert alkalmazhatjuk lambdákra is. Ami azt illeti, a mi Hívható lambdának írhatták volna. Képzeljünk el egy olyan módszert, amely a-t igényel Funkció, de szeretnénk használni a Funkció az nem hoz semmit. Akkor csak vissza kell térítenünk Üres:

public static R defer (Function function, T arg) {return function.apply (arg); }

@Test void givenVoidFunction_whenDiffer_thenReturnNull () {Function function = s -> {System.out.println ("Hello" + s + "!"); return null; }; assertThat (Halasztás. halasztás (függvény, "Világ")). isNull (); }

4. Hogyan kerülhető el a használata?

Most láttunk néhány alkalmazást a Üres típus. Még akkor is, ha az első használat teljesen rendben van, érdemes elkerülni a használatát Üres ha lehetséges, a generikus gyógyszerekben. Valóban, olyan visszatérési típussal találkozni, amely az eredmény hiányát jelenti, és csak tartalmazhat nulla nehézkes lehet.

Most meglátjuk, hogyan lehet elkerülni ezeket a helyzeteket. Először is vegyük fontolóra módszerünket a Hívható paraméter. Annak elkerülése érdekében, hogy a Hívható, javasolhatunk egy másik módszert a Futható paraméter helyett:

public static void defer (Futható futható) {futható.run (); }

Tehát átadhatjuk a Futható ami semmilyen értéket nem ad vissza és így megszabadul a haszontalanoktól return null:

Futható futható = új Futható () {@Orride public void run () {System.out.println ("Hello!"); }}; Halaszt. Halaszt (futható);

De akkor mi van, ha a Elhalasztja osztály nem a miénk, hogy módosítsunk? Akkor vagy ragaszkodhatunk a Hívható opció vagy hozzon létre egy másik osztályt a Futható és a hívás elhalasztása a Elhalasztja osztály:

public class MyOwnDefer {public static void defer (Runnable futtatható) dobja a Kivételt {Defer.defer (new Callable () {@Override public Void call () {runnable.run (); return null;}}); }}

Ezzel a nehézkes részt egyszer és mindenkorra beillesztjük a saját módszerünkbe, lehetővé téve a jövőbeli fejlesztők számára egy egyszerűbb API használatát.

Természetesen ugyanez érhető el Funkció. Példánkban a Funkció nem ad semmit, így egy másik módszert nyújthatunk a Fogyasztó helyette:

public static void defer (Fogyasztói fogyasztó, T arg) {fogyasztó.fogad (arg); }

Akkor mi van, ha a függvényünk nem vesz be semmilyen paramétert? Vagy használhatjuk a Futható vagy hozzunk létre saját funkcionális interfészt (ha ez egyértelműbbnek tűnik):

nyilvános felület Művelet {void execute (); }

Aztán túlterheljük a elhalasztja() módszer ismét:

public static void halasztás (Action action) {action.execute (); }

Művelet művelet = () -> System.out.println ("Hello!"); Halasztás.halasztás (cselekvés);

5. Következtetés

Ebben a rövid cikkben a Java-t ismertettük Üres osztály. Láttuk, mi volt a célja és hogyan kell használni. Megtanultunk néhány alternatívát is a használatára.

Szokás szerint a cikk teljes kódja megtalálható a GitHub-on.