Como passar parâmetros para classe anônima?

É possível passar parâmetros ou acessar parâmetros externos para uma classe anônima? Por exemplo:

int myVariable = 1;

myButton.addActionListener(new ActionListener() {
    public void actionPerformed(ActionEvent e) {
        // How would one access myVariable here?
    }
});

Existe alguma maneira de o ouvinte acessar myVariable ou passar para myVariable sem criar o ouvinte como uma classe nomeada real?

Tecnicamente, não, porque classes anônimas não podem ter construtores.

No entanto, as classes podem fazer referência a variáveis ​​que contêm escopos. Para uma classe anônima, essas podem ser variáveis ​​de instância das classes que contêm ou variáveis ​​locais marcadas como finais.

edit : Como Peter apontou, você também pode passar parâmetros para o construtor da superclasse da classe anônima.

Sim, adicionando um método inicializador que retorna 'this' e chamando imediatamente esse método:

int myVariable = 1;

myButton.addActionListener(new ActionListener() {
    private int anonVar;
    public void actionPerformed(ActionEvent e) {
        // How would one access myVariable here?
        // It's now here:
        System.out.println("Initialized with value: " + anonVar);
    }
    private ActionListener init(int var){
        anonVar = var;
        return this;
    }
}.init(myVariable)  );

Nenhuma declaração 'final' é necessária.

sim. você pode capturar variável visível para a classe interna. a única limitação é que deve ser final

Como isso:

final int myVariable = 1;

myButton.addActionListener(new ActionListener() {
    public void actionPerformed(ActionEvent e) {
        // Now you can access it alright.
    }
});

Isso fará a mágica

int myVariable = 1;

myButton.addActionListener(new ActionListener() {

    int myVariable;

    public void actionPerformed(ActionEvent e) {
        // myVariable ...
    }

    public ActionListener setParams(int myVariable) {

        this.myVariable = myVariable;

        return this;
    }
}.setParams(myVariable));

Conforme mostrado em http://www.coderanch.com/t/567294/java/java/declare-constructor-anonymous-class, você pode adicionar um inicializador de instância. É um bloco que não tem nome e é executado primeiro (como um construtor).

Parece que eles também são discutidos em Por que inicializadores de instância java? e Como um inicializador de instância é diferente de um construtor? discute as diferenças dos construtores.

Minha solução é usar um método que retorne a classe anônima implementada. Argumentos regulares podem ser passados ​​para o método e estão disponíveis na classe anônima.

Por exemplo: (de algum código GWT para lidar com uma alteração na caixa de texto):

/* Regular method. Returns the required interface/abstract/class
   Arguments are defined as final */
private ChangeHandler newNameChangeHandler(final String axisId, final Logger logger) {

    // Return a new anonymous class
    return new ChangeHandler() {
        public void onChange(ChangeEvent event) {
            // Access method scope variables           
            logger.fine(axisId)
        }
     };
}

Para este exemplo, o novo método de classe anônimo seria referenciado com:

textBox.addChangeHandler(newNameChangeHandler(myAxisName, myLogger))

OU , usando os requisitos do OP:

private ActionListener newActionListener(final int aVariable) {
    return new ActionListener() {
        public void actionPerformed(ActionEvent e) {
            System.out.println("Your variable is: " + aVariable);
        }
    };
}
...
int myVariable = 1;
newActionListener(myVariable);

Outras pessoas já responderam que classes anônimas podem acessar apenas variáveis ​​finais. Mas eles deixam a questão em aberto como manter a variável original não final. Adam Mlodzinski deu uma solução, mas é bastante inchada. Existe uma solução muito mais simples para o problema:

Se você não quiser myVariableser final, precisará envolvê-lo em um novo escopo, onde isso não importa, se for final.

int myVariable = 1;

{
    final int anonVar = myVariable;

    myButton.addActionListener(new ActionListener() {
        public void actionPerformed(ActionEvent e) {
            // How would one access myVariable here?
            // Use anonVar instead of myVariable
        }
    });
}

Adam Mlodzinski não faz mais nada em sua resposta, mas com muito mais código.

Você pode usar lambdas simples ("expressões lambda podem capturar variáveis")

int myVariable = 1;
ActionListener al = ae->System.out.println(myVariable);
myButton.addActionListener( al );

ou mesmo uma função

Function<Integer,ActionListener> printInt = 
    intvar -> ae -> System.out.println(intvar);

int myVariable = 1;
myButton.addActionListener( printInt.apply(myVariable) );

Usar a Função é uma ótima maneira de refatorar decoradores e adaptadores, veja aqui

Acabei de começar a aprender sobre lambdas, por isso, se você encontrar um erro, fique à vontade para escrever um comentário.

Uma maneira simples de colocar algum valor em uma variável externa (não pertence à classe anonymus) é como segue!

Da mesma forma, se você deseja obter o valor de uma variável externa, pode criar um método que retorne o que deseja!

public class Example{

    private TypeParameter parameter;

    private void setMethod(TypeParameter parameter){

        this.parameter = parameter;

    }

    //...
    //into the anonymus class
    new AnonymusClass(){

        final TypeParameter parameterFinal = something;
        //you can call setMethod(TypeParameter parameter) here and pass the
        //parameterFinal
        setMethod(parameterFinal); 

        //now the variable out the class anonymus has the value of
        //of parameterFinal

    });

 }

Eu pensei que classes anônimas eram basicamente como lambdas, mas com sintaxe pior ... isso acaba sendo verdade, mas a sintaxe é ainda pior e faz com que (o que deveria ser) variáveis ​​locais vazem na classe que o contém.

Você não pode acessar nenhuma variável final transformando-a em campos da classe pai.

Por exemplo

Interface:

public interface TextProcessor
{
    public String Process(String text);
}

classe:

private String _key;

public String toJson()
{
    TextProcessor textProcessor = new TextProcessor() {
        @Override
        public String Process(String text)
        {
            return _key + ":" + text;
        }
    };

    JSONTypeProcessor typeProcessor = new JSONTypeProcessor(textProcessor);

    foreach(String key : keys)
    {
        _key = key;

        typeProcessor.doStuffThatUsesLambda();
    }

Eu não sei se eles resolveram isso em java 8 (eu estou preso no mundo EE e ainda não tenho 8), mas em c # ficaria assim:

    public string ToJson()
    {
        string key = null;
        var typeProcessor = new JSONTypeProcessor(text => key + ":" + text);

        foreach (var theKey in keys)
        {
            key = theKey;

            typeProcessor.doStuffThatUsesLambda();
        }
    }

Você não precisa de uma interface separada em c # também ... Eu sinto falta! Eu me pego criando designs piores em java e me repetindo mais porque a quantidade de código + complexidade que você precisa adicionar em java para reutilizar algo é pior do que apenas copiar e colar a maior parte do tempo.