Chiusura in Java 7 [chiuso]

Cos'è la chiusura? Dovrebbe essere incluso in Java 7. (Le chiusure sono state discusse per l'inclusione in Java 7, ma alla fine non sono state incluse. -Ed) Qualcuno può fornirmi alcuni riferimenti affidabili da cui posso imparare cose sulle chiusure?

Ecco il blog di Neal Gafter, uno dei pionieri che ha introdotto le chiusure in Java. Il suo post sulle chiusure del 28 gennaio 2007 si chiama A Definition of Closures Sul suo blog ci sono molte informazioni per iniziare così come i video. Ecco un eccellente discorso di Google - Argomenti avanzati nei linguaggi di programmazione - Anche le chiusure per Java con Neal Gafter.

Una chiusura è un blocco di codice che può essere referenziato (e passato in giro) con accesso alle variabili dell'ambito che lo racchiude.

A partire da Java 1.1, la classe interna anonima ha fornito questa funzionalità in modo estremamente dettagliato. Hanno anche la limitazione di poter usare solo final(e definitivamente assegnate) variabili locali. (Nota, anche finalle variabili non locali rientrano nell'ambito, ma non possono essere utilizzate.)

Java SE 8 è progettato per avere una versione più concisa di questo per interfacce a metodo singolo *, chiamate "lambda". I Lambda hanno più o meno le stesse restrizioni delle classi interne anonime, sebbene alcuni dettagli variano in modo casuale.

Le Lambda sono in fase di sviluppo nell'ambito del Progetto Lambda e JSR 335 .

* In origine il design era più flessibile consentendo i tipi Single Abstract Methods (SAM). Sfortunatamente il nuovo design è meno flessibile, ma cerca di giustificare l'implementazione all'interno delle interfacce.

Secondo Tom Hawtin

Una chiusura è un blocco di codice che può essere referenziato (e passato in giro) con accesso alle variabili dell'ambito che lo racchiude.

Ora sto cercando di emulare l'esempio di chiusura JavaScript su Wikipedia , con una traduzione " diretta " in Java, nella speranza di essere utile:

//ECMAScript
var f, g;
function foo() {
  var x = 0;
  f = function() { return ++x; };
  g = function() { return --x; };
  x = 1;
  print('inside foo, call to f(): ' + f()); // "2"  
}
foo();
print('call to g(): ' + g()); // "1"
print('call to f(): ' + f()); // "2"

Ora la parte java: Function1 è l'interfaccia "Functor" con arity 1 (un argomento). Closure è la classe che implementa la Function1, un Functor concreto che funge da funzione (int -> int). Nel metodo main () ho solo istanziato foo come oggetto Closure, replicando le chiamate dall'esempio JavaScript. La classe IntBox è solo un semplice contenitore, si comporta come un array di 1 int:

int a [1] = {0}

interface Function1   {
    public final IntBag value = new IntBag();
    public int apply();
}

class Closure implements Function1 {
   private IntBag x = value;
   Function1 f;
   Function1 g;

   @Override
   public int apply()  {
    // print('inside foo, call to f(): ' + f()); // "2"
    // inside apply, call to f.apply()
       System.out.println("inside foo, call to f.apply(): " + f.apply());
       return 0;
   }

   public Closure() {
       f = new Function1() {
           @Override
           public int apply()  {
               x.add(1);
                return x.get();
           }
       };
       g = new Function1() {
           @Override
           public int apply()  {
               x.add(-1);
               return x.get();
           }
       };
    // x = 1;
       x.set(1);
   }
}
public class ClosureTest {
    public static void main(String[] args) {
        // foo()
        Closure foo = new Closure();
        foo.apply();
        // print('call to g(): ' + g()); // "1"
        System.out.println("call to foo.g.apply(): " + foo.g.apply());
        // print('call to f(): ' + f()); // "2"
        System.out.println("call to foo.f.apply(): " + foo.f.apply());

    }
}

Stampa:

inside foo, call to f.apply(): 2
call to foo.g.apply(): 1
call to foo.f.apply(): 2 

Si prega di consultare questa pagina wiki per la definizione di chiusura.

E questa pagina per la chiusura in Java 8: http://mail.openjdk.java.net/pipermail/lambda-dev/2011-September/003936.html

Guarda anche questa domanda e risposta : chiusure in Java 7

Le chiusure Java faranno parte di J2SE 8 e saranno rilasciate entro la fine del 2012.

Il supporto per le chiusure di Java 8 include il concetto di espressioni Lambda, riferimento al metodo, riferimento al costruttore e metodi predefiniti.

Per ulteriori informazioni ed esempi di lavoro, visitare: http://amitrp.blogspot.in/2012/08/at-first-sight-with-closures-in-java.html

Sì, la chiusura (Lambda Expressions) è la nuova funzionalità della prossima versione di Java SE 8. Puoi ottenere maggiori informazioni su questo dal link sottostante: http://docs.oracle.com/javase/tutorial/java/javaOO/lambdaexpressions.html

Un'implementazione di chiusura per Java 5, 6 e 7

http://mseifed.blogspot.se/2012/09/bringing-closures-to-java-5-6-and-7.html

Contiene tutto ciò che si potrebbe chiedere ...