Fermeture dans Java 7 [fermé]

Qu'est-ce que la fermeture? Il est censé être inclus dans Java 7. (Les fermetures ont été discutées pour inclusion dans Java 7, mais à la fin n'ont pas été incluses. -Ed) Est-ce que quelqu'un peut me fournir des références fiables d'où je peux apprendre des choses sur les fermetures?

Voici le blog de Neal Gafter, l' un des pionniers de l'introduction des fermetures en Java. Son article sur les fermetures du 28 janvier 2007 s'intitule Une définition des fermetures. Sur son blog, il y a beaucoup d'informations pour vous aider à démarrer ainsi que des vidéos. Voici une excellente présentation de Google - Sujets avancés dans les langages de programmation - Fermetures pour Java avec Neal Gafter également.

Une fermeture est un bloc de code qui peut être référencé (et transmis) avec accès aux variables de la portée englobante.

Depuis Java 1.1, les classes internes anonymes ont fourni cette fonctionnalité de manière très verbeuse. Ils ont également une restriction de ne pouvoir utiliser final(et définitivement assignées) que des variables locales. (Notez que même finalles variables non locales sont dans la portée, mais ne peuvent pas être utilisées.)

Java SE 8 est destiné à en avoir une version plus concise pour les interfaces à méthode unique *, appelées «lambdas». Les lambdas ont à peu près les mêmes restrictions que les classes internes anonymes, bien que certains détails varient de manière aléatoire.

Les lambdas sont en cours de développement dans le cadre du projet Lambda et JSR 335 .

* À l'origine, la conception était plus flexible, autorisant les types de méthodes abstraites simples (SAM). Malheureusement, la nouvelle conception est moins flexible, mais tente de justifier l'autorisation de l'implémentation dans les interfaces.

Selon Tom Hawtin

Une fermeture est un bloc de code qui peut être référencé (et transmis) avec accès aux variables de la portée englobante.

J'essaie maintenant d'émuler l'exemple de fermeture JavaScript sur Wikipédia , avec une traduction « droite » en Java, dans l'espoir d'être 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"

Maintenant la partie java: Function1 est l'interface "Functor" avec arity 1 (un argument). Closure est la classe implémentant Function1, un Functor concret qui agit comme une fonction (int -> int). Dans la méthode main (), j'instancie simplement foo en tant qu'objet Closure, répliquant les appels de l'exemple JavaScript. La classe IntBox est juste un simple conteneur, il se comporte comme un tableau de 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());

    }
}

Il imprime:

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

Veuillez consulter cette page wiki pour la définition de la fermeture.

Et cette page de clôture en Java 8: http://mail.openjdk.java.net/pipermail/lambda-dev/2011-September/003936.html

Regardez également cette Q&A: Fermetures dans Java 7

Les fermetures Java feront partie de J2SE 8 et devraient être publiées d'ici la fin de 2012.

La prise en charge des fermetures de Java 8 inclut le concept d'expressions Lambda, de référence de méthode, de référence de constructeur et de méthodes par défaut.

Pour plus d'informations et des exemples de travail à ce sujet, veuillez visiter: http://amitrp.blogspot.in/2012/08/at-first-sight-with-closures-in-java.html

Oui, Closure (Lambda Expressions) est la nouvelle fonctionnalité de la prochaine version de Java SE 8. Vous pouvez obtenir plus d'informations à ce sujet à partir du lien ci-dessous: http://docs.oracle.com/javase/tutorial/java/javaOO/lambdaexpressions.html

Une implémentation de fermeture pour Java 5, 6 et 7

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

Il contient tout ce que l'on pourrait demander ...