Java [36] – Klasy anonimowe i wyrażenia lambda

Autor: Grzegorz, napisał dnia: 28 kwietnia, 2015

Z klasami anonimowymi spotkaliśmy się przy okazji pierwszego starcia z JavąFX. Teraz wyjaśnię krótko czym są a następnie poznamy wyrażenia lambda, które pozwalają m. in. na przekazywanie kodu do metod.

Klasy anonimowe

Kiedy zapoznawaliśmy się z podstawami JavyFX spotkaliśmy się z takim kodem:

Button btn = new Button();
btn.setText("Say ‘Hello World’");
btn.setOnAction(new EventHandler() {

   @Override
   public void handle(ActionEvent event) {
      System.out.println("Hello World!");
   }
});

Button btn = new Button();

btn.setText("Say ‘Hello World’");

btn.setOnAction(new EventHandler() {

@Override

public void handle(ActionEvent event) {

System.out.println("Hello World!");

}

});

Kod od trzeciej linii wyglądał nieco dziwnie. Zamiast przekazać metodzie setOnAction() obiekt, pojawiło się coś co z jednej strony przypomina tworzenie obiektu (słowo kluczowe new) a z drugiej kod klasy z metodą handle(). Nie stworzyliśmy tu obiektu, który posiadałby nazwę ale użyliśmy klasy anonimowej. Taka konstrukcja jest wygodna na przykład wtedy, gdy chcemy przekazać do metody obiekt, będący instancją klasy, którą użyjemy tylko raz w kodzie. W takiej sytuacji tworzenie klasy a następnie obiektu, który następnie przekazujemy metodzie jest niepotrzebnym mnożeniem kodu. Od razu deklarujemy klasę i tworzymy jej instancje (obiekt). W tym wypadku tworzymy klasę implementującą interfejs EventHandler.

Nie będę szerzej opisywać klas anonimowych, choć ich używanie jest wygodne w wielu sytuacjach, ponieważ począwszy od Javy 8 udostępniono jeszcze wygodniejsze wyrażenia lambda

Wyrażenia lambda

Wyrażenia lambda są w pewien sposób podobne do anonimowych klas, ponieważ można je określić jako anonimowe metody. Z tego wynika, że będą odpowiadały pojedynczym metodom, które można na przykład przekazać jako argument do innej metody. Rzeczywiście, wyrażenie lambda implementuje metodę zdefiniowaną w interfejsie funkcjonalnym. Czym zatem jest interfejs funkcjonalny? Jest to taki interfejs, który posiada tylko jedną metodę abstrakcyjną (niezaimplementowaną), może natomiast posiadać wiele metod domyślnych. Jeśli nie rozumiesz w czym rzecz, warto zajrzeć do lekcji poświęconej interfejsom. Przy tworzeniu takich interfejsów dobrze jest wyraźnie zaznaczyć, że są one funkcjonalne używając adnotacji @FunctionalInterface.

Generalnie struktura wyrażenia lambda wygląda tak:

(parametr1, parametr2,...) -> { ciało lambdy }

Przy czym możliwe są różne modyfikacje tego wzorca. Na przykład może nie być wcale parametrów:

() -> { ciało lambdy }

Jeśli ciało lambdy zawiera tylko jedną linię kodu, nawiasy klamrowe są zbędne:

(parametr1) -> polecenie;

Jeśli jest tylko jeden parametr, można ominąć nawiasy:

parametr -> polecenie;

Spróbujmy teraz stworzyć interfejs funkcjonalny a następnie użyć wyrażenia lambda.

Interfejs `Thinkable`

package wyrazenialambda;

@FunctionalInterface
public interface Thinkable {
    void mysl(String sentencja);
}

package wyrazenialambda;

@FunctionalInterface

public interface Thinkable {

void mysl(String sentencja);

}

Klasa `WyrazeniaLambda`

package wyrazenialambda;

public class WyrazeniaLambda {
    
    // Metoda, która przyjmie dwa argumenty: obiekt implementujący interfejs 
    // Thinkable oraz String
    public static void pomyslCos(Thinkable t, String s) {
        // Wywołanie metody mysl na obiekcie t
        t.mysl(s + "!!!");
    }
    
    public static void main(String[] args) {
        // Tworzymy obiekt, implementujemy metodę 
        // parametr m jest używany przez metodę println()
        Thinkable think = (m) -> System.out.println("Tak sobie pomyślałem: "+ m);
        // Wywołujemy metodę na obiekcie
        think.mysl("Myślę więc jestem.");
        
        // Teraz wyrażenie lambda ma kilka linii
        think = (m) -> {
            System.out.println("Starożytni filozofowie mówią, że:");
            System.out.println(m);
        };
        
        think.mysl("Pisanie nadmiaru kodu nie jest dobre.");
        
        // Wywołanie metody, jako pierwszy argument wpisujemy wyrażenie lambda
        // drugi jest String-iem, jego wartość jest przypisywana parametrowi,
        // czyli zmiennej st
        pomyslCos((st) -> { System.out.println("Dlatego "+ st);},
                            "używaj wyrażeń lambda");
    }  
}

package wyrazenialambda;

public class WyrazeniaLambda {

// Metoda, która przyjmie dwa argumenty: obiekt implementujący interfejs

// Thinkable oraz String

public static void pomyslCos(Thinkable t, String s) {

// Wywołanie metody mysl na obiekcie t

t.mysl(s + "!!!");

}

public static void main(String[] args) {

// Tworzymy obiekt, implementujemy metodę

// parametr m jest używany przez metodę println()

Thinkable think = (m) -> System.out.println("Tak sobie pomyślałem: "+ m);

// Wywołujemy metodę na obiekcie

think.mysl("Myślę więc jestem.");

// Teraz wyrażenie lambda ma kilka linii

think = (m) -> {

System.out.println("Starożytni filozofowie mówią, że:");

System.out.println(m);

};

think.mysl("Pisanie nadmiaru kodu nie jest dobre.");

// Wywołanie metody, jako pierwszy argument wpisujemy wyrażenie lambda

// drugi jest String-iem, jego wartość jest przypisywana parametrowi,

// czyli zmiennej st

pomyslCos((st) -> { System.out.println("Dlatego "+ st);},

"używaj wyrażeń lambda");

}

Zwróć uwagę, że w powyższych przykładach nie określaliśmy typu parametru, choć jest to możliwe:

pomyslCos((String st) -> { System.out.println("Dlatego "+ st);}, "używaj wyrażeń lambda");

Rodzaj argumentu został „wywnioskowany” z kodu interfejsu.

Predefinowane interfejsy funkcjonalne

Co ciekawe w wielu wypadkach wcale nie musimy tworzyć interfejsu aby używać wyrażeń lambda. Java dostarcza wielu funkcjonalnych interfejsów do których można dopasować wyrażenia lambda uwzględniając rodzaj argumentów i zwracanych wartości zadeklarowanych w nich metod abstrakcyjnych. Można ich szukać na przykład w dokumentacji pakietu java.util.function ale także w innych miejscach. Na przykład interfejs Runnable należy do podstawowego pakietu java.lang.

Wróćmy teraz do pakietu java.util.function. Można tam znaleźć na przykład interfejs Consumer, który, jak wynika z dokumentacji, deklaruje abstrakcyjną metodę accept(Object) i nie zwraca żadnej wartości. Biorąc pod uwagę, że łańcuch znaków też jest obiektem (typu String) to może zupełnie niepotrzebnie utworzyliśmy w poprzednim przykładzie interfejs?

Utwórz nowy program, który będzie bardzo podobny do poprzedniego ale zamiast interfejsu Thinkable użyjemy zaimportowanego Consumer i oczywiście nazwę wywoływanej metody należy zmienić z mysl() na accept():

package wyrazenialambda2;

import java.util.function.Consumer;

public class WyrazeniaLambda2 {
    

    public static void pomyslCos(Consumer t, String s) {
        t.accept(s + "!!!");
        
    }
    
    public static void main(String[] args) {

        Consumer think = (m) -> System.out.println("Tak sobie pomyślałem: "+ m);
        think.accept("Myślę więc jestem.");
        
        think = (m) -> {
            System.out.println("Starożytni filozofowie mówią, że:");
            System.out.println(m);
        };
        
        think.accept("Pisanie nadmiaru kodu nie jest dobre.");
        
        pomyslCos((st) -> { System.out.println("Dlatego "+ st);},
                            "używaj wyrażeń lambda");
    }  
}

package wyrazenialambda2;

import java.util.function.Consumer;

public class WyrazeniaLambda2 {

public static void pomyslCos(Consumer t, String s) {

t.accept(s + "!!!");

}

public static void main(String[] args) {

Consumer think = (m) -> System.out.println("Tak sobie pomyślałem: "+ m);

think.accept("Myślę więc jestem.");

think = (m) -> {

System.out.println("Starożytni filozofowie mówią, że:");

System.out.println(m);

};

think.accept("Pisanie nadmiaru kodu nie jest dobre.");

pomyslCos((st) -> { System.out.println("Dlatego "+ st);},

"używaj wyrażeń lambda");

}

Zauważ, że poza oszczędniejszym pisaniem kodu, zaletą wyrażeń lambda jest łatwe przekazywanie fragmentów kodu do metod. Pozwala to tworzyć metody, które są bardzo elastyczne nie tylko pod względem wartości przyjmowanych argumentów ale także kodu, który wykonują. W powyższym przykładzie zaimplementowaliśmy na przykład różne sposoby wypisywania tekstu przekazywanego metodzie, ale przecież można przekazać w ten sposób dużo bardziej złożony kod. W poniższym przykładzie metoda funkcja robi bardzo różne rzeczy z różnymi obiektami.

package wyrazenialambda3;
 
import java.util.Arrays;
import java.util.function.Function;
 
public class WyrazeniaLambda3 {
 
    public static void funkcja(Function f, Object o) {
        System.out.println("Obiekt typu: " + o.getClass());
        System.out.println(f.apply(o));
    }
 
    public static void main(String[] args) {
 
        // Tworzymy obiekt, który przekazujemy do metody funkcja
        Function<String, Integer> dlugoscSekwencji = (String ob) -> {
            Integer i = ob.length();
            return i;
        };

        funkcja(dlugoscSekwencji, "AAAGGAGGA");
 
        // Przekazujemy wyrażenie lambda bezpośrednio do metody funkcja.
        // Ten sposób jest częściej stosowany
        Function<Integer, Integer> podwojenieLiczby = (Integer ob) -> {
            return ob * 2;
        };
        funkcja((Object ob) -> {
            // Casting do typu Integer, aby można było wykonać obliczenia
            Integer liczba = (Integer) ob;
            return liczba * 2;
        }, 1234);
 
        // Przekazujemy wyrażenie lambda bezpośrednio do metody funkcja
        funkcja((Object ob) -> {
            System.out.println("Wejściowy : " + ob);
            // Casting do typu String aby wykorzystac metodę "split"
            String st = (String) ob;
            String[] tab = st.split(" ");
            System.out.println("Tablica: " + Arrays.toString(tab));
            st = st.toUpperCase();
            return st;
            }, 
                "Lambdy są coraz ciekawsze!");
    }
 
}

package wyrazenialambda3;

import java.util.Arrays;

import java.util.function.Function;

public class WyrazeniaLambda3 {

public static void funkcja(Function f, Object o) {

System.out.println("Obiekt typu: " + o.getClass());

System.out.println(f.apply(o));

}

public static void main(String[] args) {

// Tworzymy obiekt, który przekazujemy do metody funkcja

Function<String, Integer> dlugoscSekwencji = (String ob) -> {

Integer i = ob.length();

return i;

};

funkcja(dlugoscSekwencji, "AAAGGAGGA");

// Przekazujemy wyrażenie lambda bezpośrednio do metody funkcja.

// Ten sposób jest częściej stosowany

Function<Integer, Integer> podwojenieLiczby = (Integer ob) -> {

return ob * 2;

};

funkcja((Object ob) -> {

// Casting do typu Integer, aby można było wykonać obliczenia

Integer liczba = (Integer) ob;

return liczba * 2;

}, 1234);

// Przekazujemy wyrażenie lambda bezpośrednio do metody funkcja

funkcja((Object ob) -> {

System.out.println("Wejściowy : " + ob);

// Casting do typu String aby wykorzystac metodę "split"

String st = (String) ob;

String[] tab = st.split(" ");

System.out.println("Tablica: " + Arrays.toString(tab));

st = st.toUpperCase();

return st;

"Lambdy są coraz ciekawsze!");

}

Na koniec…

Wyrażenia lambda to kolejny dość szeroki temat, który zaledwie musnęliśmy. Na razie ważne jest, żebyś rozumiał ten rodzaj kodu a także potrafił go wykorzystywać przynajmniej w stopniu podstawowym, ponieważ przyda się w dalszych częściach kursu. Można je bowiem efektywnie wykorzystać m. in. przy tworzeniu interfejsu graficznego w JavieFX.

Przypomnij sobie kod, z od którego rozpoczęliśmy lekcję:

       btn.setOnAction(new EventHandler<ActionEvent>() {
            
            @Override
            public void handle(ActionEvent event) {
                System.out.println("Hello World!");
                kolko.setFill(Color.GREEN);
                
            }
        });

btn.setOnAction(new EventHandler<ActionEvent>() {

@Override

public void handle(ActionEvent event) {

System.out.println("Hello World!");

kolko.setFill(Color.GREEN);

}

});

Teraz zmieńmy go używając wyrażenia lambda:

        btn.setOnAction((event) -> {
            System.out.println("Hello World!");
            kolko.setFill(Color.GREEN);
        });

btn.setOnAction((event) -> {

System.out.println("Hello World!");

kolko.setFill(Color.GREEN);

});

Czyż nie jest krótszy i bardziej przejrzysty?

Grzegorz Góralski – strona własna

Sekcje

Szukaj:

Kategorie

Java [36] – Klasy anonimowe i wyrażenia lambda

Klasy anonimowe

Wyrażenia lambda

Interfejs `Thinkable`

Klasa `WyrazeniaLambda`

Predefinowane interfejsy funkcjonalne

Na koniec…

Related

Leave a Reply Cancel reply

Grzegorz Góralski – strona własna

Sekcje

Szukaj:

Kategorie

Tagi

Java [36] – Klasy anonimowe i wyrażenia lambda

Klasy anonimowe

Wyrażenia lambda

Interfejs Thinkable

Klasa WyrazeniaLambda

Predefinowane interfejsy funkcjonalne

Na koniec…

Podziel się:

Related

Leave a Reply Cancel reply

Interfejs `Thinkable`

Klasa `WyrazeniaLambda`