Encerramento em Java 7 [fechado]

105

O que é fechamento? Deve ser incluído no Java 7. (Os closures foram discutidos para inclusão no Java 7, mas no final não foram incluídos. -Ed) Alguém pode me fornecer algumas referências confiáveis ​​de onde eu possa aprender coisas sobre os encerramentos?

Swaranga Sarma
fonte

Respostas:

59

Aqui está o blog de Neal Gafter, um dos pioneiros a introduzir encerramentos em Java. Sua postagem sobre fechamentos de 28 de janeiro de 2007 é chamada de Uma definição de fechamentos. Em seu blog, há muitas informações para você começar, assim como vídeos. Aqui está uma excelente palestra do Google - Tópicos Avançados em Linguagens de Programação - Fechamentos para Java com Neal Gafter, também.

Bartzilla
fonte
2
Você tem um link mais específico do que o blog geral?
I82Much
1
Se alguém é burro como eu e está batendo a cabeça na parede só para saber que hack é esse Closure ... então aqui está .. youtube.com/watch?v=Nj3_DMUXEbE
Piyush Kukadiya
não consigo imaginar a implementação de encerramentos em uma linguagem que inicialmente não os tivesse ... meio louco
Alexander Mills
Alexander Mills apenas curioso .. por quê?
Bartzilla
84

Um fechamento é um bloco de código que pode ser referenciado (e transmitido) com acesso às variáveis ​​do escopo envolvente.

Desde Java 1.1, a classe interna anônima fornece esse recurso de uma maneira altamente detalhada. Eles também têm a restrição de apenas serem capazes de usar final(e definitivamente atribuídas) variáveis ​​locais. (Observe que mesmo finalas variáveis não locais estão no escopo, mas não podem ser usadas.)

O Java SE 8 pretende ter uma versão mais concisa disso para interfaces de método único *, chamadas de "lambdas". Lambdas têm praticamente as mesmas restrições que classes internas anônimas, embora alguns detalhes variem aleatoriamente.

Lambdas estão sendo desenvolvidos sob o Projeto Lambda e JSR 335 .

* Originalmente, o design era mais flexível, permitindo tipos de métodos abstratos únicos (SAM). Infelizmente, o novo design é menos flexível, mas tenta justificar a permissão da implementação nas interfaces.

Tom Hawtin - tackline
fonte
7

De acordo com Tom Hawtin

Um fechamento é um bloco de código que pode ser referenciado (e transmitido) com acesso às variáveis ​​do escopo envolvente.

Agora estou tentando emular o exemplo de fechamento de JavaScript na Wikipedia , com uma tradução " direta " para Java, na esperança de ser útil:

//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"

Agora a parte java: Function1 é a interface "Functor" com arity 1 (um argumento). Closure é a classe que implementa a Function1, um Functor concreto que atua como função (int -> int). No método main (), apenas instanciarei foo como um objeto Closure, replicando as chamadas do exemplo de JavaScript. A classe IntBox é apenas um contêiner simples, ela se comporta como uma matriz 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());

    }
}

Ele imprime:

inside foo, call to f.apply(): 2
call to foo.g.apply(): 1
call to foo.f.apply(): 2 
Rob Rosetti
fonte
2
IMO além do nome, isso não tem nada a ver com fechamentos
n00b
4

Java Closures fará parte do J2SE 8 e está previsto para ser lançado no final de 2012.

O suporte a fechamentos do Java 8 inclui o conceito de Expressões Lambda, Referência de Método, Referência de Construtor e Métodos Padrão.

Para obter mais informações e exemplos de trabalho para isso, visite: http://amitrp.blogspot.in/2012/08/at-first-sight-with-closures-in-java.html

Amit Phaltankar
fonte
1
Hmm, entretanto o Java 8 não permite modificação da variável de fechamento. Bom artigo.
nawfal
0

Uma implementação de encerramento para Java 5, 6 e 7

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

Ele contém tudo o que se poderia pedir ...

mmm
fonte
O link leva a algum texto que o descreve, mas o código vinculado a partir dessa página não existe. Onde está a implementação?
Jerry Jeremiah
@JerryJeremiah Aqui está, ele tem um nome diferente agora, também todas as versões originalmente presentes não estão lá (para suportar acesso não final e mais por meio de classes abstratas, pode ser adicionado novamente para <versões Java 8, qual plataforma você está procurando?): bitbucket.org/momomo/opensource/src
mmm
2
Links estão quebrando!
sunleo
recebi um 404, o link está inativo
Alexander Mills
link quebrado (é por isso que não devemos colocar links como respostas ...)
OhadR