Espressioni Lambda

Vediamo di seguito due semplici programmi che realizzano la visualizzazzione di una finestra. Il primo facendo uso delle espressioni lambda il secondo con il metodo tradizionae delle classi anonime.

 1 package finestralambda;
 2 
 3 import javax.swing.*;
 4 
 5 public class FinestraLambda {
 6     public static void main(String[] args) {
 7         SwingUtilities.invokeLater(() -> {            
 8             JFrame frame = new JFrame("Finestra Vuota"); 
 9             frame.setSize(300, 200);
10             frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); 
11             frame.setVisible(true);
12         });
13     }
14 }     

 1 package finestrasenzalambda;
 2 
 3 import javax.swing.*;
 4 
 5 public class FinestraSenzaLambda {
 6     public static void main(String[] args) {
 7         SwingUtilities.invokeLater(new Runnable() {
 8             @Override
 9             public void run() {
10                 JFrame frame = new JFrame("Finestra Vuota Senza Lambda");
11                 frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
12                 frame.setSize(300, 200);
13                 frame.setVisible(true);
14             }
15         });
16     }
17 }

In Java, un’espressione lambda fornisce un modo per creare una funzione anonima, introducendo di fatto un nuovo tipo Java: il tipo funzione anonima. Questo tipo può essere passato come argomento o restituito in uscita nei metodi, simile a come si fa con gli oggetti. 

In poche parole, un'espressione lambda è un metodo senza una dichiarazione esplicita, una sorta di scorciatoia che consente di scrivere un metodo nello stesso posto dove ti serve.

Ecco alcuni punti chiave sulle espressioni lambda in Java:

1. Origine storica:

   • Le espressioni lambda sono arrivate a Java dalla programmazione funzionale e, a monte, dalla matematica.
   • Alonzo Church, un matematico, inventò il lambda calcolo negli Stati Uniti a metà del XX secolo. Questo concetto era inizialmente estraneo alla programmazione.
   • John McCarthy, anch’egli laureato alla Princeton University, si interessò alle idee di Church e contribuì allo sviluppo della programmazione funzionale.

2. Concetto di base:

   • Un’espressione lambda è una funzione anonima che può essere utilizzata per implementare metodi o passata come parametro.
   • È utile quando hai bisogno di scrivere una piccola funzione senza dover dichiarare un metodo completo.

3. Sintassi:

   • L’espressione lambda ha la seguente struttura:
     (parametri) -> espressione
     
   • Ad esempio, per creare una funzione che calcola il quadrato di un numero:
     (int x) -> x * x;
     

4. Utilizzo:

   • Le espressioni lambda sono spesso utilizzate con le interfacce funzionali.
   • Un esempio comune è l’interfaccia Runnable:
     Runnable task = () -> System.out.println("Hello, world!");
     

5. Esempio pratico:

   • Supponiamo di avere un’interfaccia MathOperation con un metodo astratto calculate.
   • Possiamo implementarla con un’espressione lambda:
     MathOperation addition = (a, b) -> a + b;
     

6. Compiti:

   • Scrivi un’implementazione di un’interfaccia che calcoli il discriminante di un’equazione quadratica (cioè (D = b^2 - 4ac)).
   • Utilizza un’espressione lambda per calcolare il risultato di (a \cdot b^c)

Le espressioni lambda sono uno strumento potente per scrivere codice più conciso e leggibile in Java.

L'osservazione da fare è questa: l'espressione lambda ha () -> {...} ossia tra le parentesi tonde vanno gli eventuali argometi, dopo la freccia entro le parentesi graffe va il corpo del metodo. In questo caso noi dobbiamo passare un oggetto runnable a:

vedi qui per approfondimenti

SwingUtilities.invokeLater(new Runnable() {

@Override

public void run() {

codice da eseguire

}

});

Quinndi la forma sarà:

SwingUtilities.invokeLater( () --> {codice da eseguire} );

Con l'espressione lambda ci siamo limitati ad inserire nel blocco { } solo il codiceda eseguire e vi chiederete e l'Override del metodo?

L'espressione lambda sa di essere argomento della funzione:

SwingUtilities.invokeLater( () --> {codice da eseguire} );

e quindi sa anche che c'è un unico metodo run e che bisogna sovrascriverlo ed inserire il codice da eseguire. E quindi fa tutto automaticamente, noi dobbiamo solo fornigli il codice da eseguire.