Fermeture en Java 7

Question

Qu'est-ce que la fermeture ? Elle est censée être incluse dans Java 7. (Les fermetures ont été discutées pour être incluses dans Java 7, mais n'ont finalement pas été incluses. -ed) Quelqu'un peut-il me fournir des références fiables où je peux apprendre des choses sur les fermetures ?

Answer 1

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

Depuis Java 1.1, les classes internes anonymes offrent cette possibilité d'une manière très verbeuse. Elles sont également limitées par le fait qu'elles ne peuvent utiliser que les éléments suivants final (et définitivement affectées) des variables locales. (Remarque : même les variables non final les variables locales sont dans la portée, mais ne peuvent pas être utilisées).

Java SE 8 est censé disposer d'une version plus concise de ceci pour les interfaces à méthode unique*, appelée "lambdas". Les lambdas ont à peu près les mêmes restrictions que les classes internes anonymes, bien que certains détails varient de façon aléatoire.

Les lambdas sont en cours de développement sous Projet Lambda y JSR 335 .

*À l'origine, la conception était plus souple et permettait l'utilisation de types SAM (Single Abstract Methods). Malheureusement, la nouvelle conception est moins flexible, mais tente de justifier l'autorisation de l'implémentation dans les interfaces.

Answer 2

Voici Le blog de Neal Gafter l'un des pionniers de l'introduction des closures en Java. Son article sur les fermetures du 28 janvier 2007 est intitulé Une définition des fermetures Sur son blog, vous trouverez de nombreuses informations pour vous aider à démarrer ainsi que des vidéos. Voici également un excellent exposé sur Google. Sujets avancés en langages de programmation - Closures pour Java avec Neal Gafter, également.

Answer 3

Según Tom Hawtin

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

Maintenant, j'essaie d'émuler l'exemple de fermeture JavaScript sur Wikipedia avec un " droiture " 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 une interface "Functor" d'arité 1 (un argument). Closure est la classe qui implémente 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, reproduisant les appels de l'exemple JavaScript. La classe IntBox est juste un simple conteneur, elle 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

Answer 4

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

Et cette page pour la fermeture en Java 8 : http://mail.openjdk.java.net/pipermail/lambda-dev/2011-September/003936.html

Regardez aussi cette question-réponse : Les fermetures en Java 7

Answer 5

Les fermetures Java feront partie de J2SE 8, dont la sortie est prévue pour la fin 2012.

La prise en charge des fermetures de Java 8 comprend le concept d'expressions lambda, la référence aux méthodes, la référence aux constructeurs et les méthodes par défaut.

Pour de plus amples informations et des exemples de travail, veuillez consulter le site suivant : http://amitrp.blogspot.in/2012/08/at-first-sight-with-closures-in-java.html