¿Cómo pasar parámetros a la clase anónima?

¿Es posible pasar parámetros o acceder a parámetros externos a una clase anónima? Por ejemplo:

int myVariable = 1;

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

¿Hay alguna forma para que el oyente acceda a myVariable o se le pase myVariable sin crear el oyente como una clase con nombre real?

Técnicamente, no, porque las clases anónimas no pueden tener constructores.

Sin embargo, las clases pueden hacer referencia a variables que contienen ámbitos. Para una clase anónima, estas pueden ser variables de instancia de las clases que lo contienen o variables locales que están marcadas como finales.

editar : como señaló Peter, también puede pasar parámetros al constructor de la superclase de la clase anónima.

Sí, agregando un método de inicializador que devuelve 'this' e inmediatamente llamando a ese 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)  );

No se necesita declaración 'final'.

si. Puede capturar variables, visibles para la clase interna. la única limitación es que tiene que ser final

Me gusta esto:

final int myVariable = 1;

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

Esto hará la magia

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));

Como se muestra en http://www.coderanch.com/t/567294/java/java/declare-constructor-anonymous-class , puede agregar un inicializador de instancia. Es un bloque que no tiene nombre y se ejecuta primero (como un constructor).

Parece que también se discuten en ¿Por qué inicializadores de instancias de Java? y ¿Cómo es un inicializador de instancia diferente de un constructor? discute las diferencias de los constructores.

Mi solución es usar un método que devuelva la clase anónima implementada. Se pueden pasar argumentos regulares al método y están disponibles dentro de la clase anónima.

Por ejemplo: (de algún código GWT para manejar un cambio de cuadro 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 ejemplo, se haría referencia al nuevo método de clase anónimo con:

textBox.addChangeHandler(newNameChangeHandler(myAxisName, myLogger))

O , utilizando los requisitos del 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);

Otras personas ya han respondido que las clases anónimas solo pueden acceder a las variables finales. Pero dejan abierta la pregunta de cómo mantener la variable original no final. Adam Mlodzinski dio una solución pero está bastante hinchado. Hay una solución mucho más simple para el problema:

Si no desea myVariableser definitivo, debe envolverlo en un nuevo ámbito donde no importa, si es definitivo.

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 no hace nada más en su respuesta, pero con mucho más código.

Puede usar lambdas simples ("las expresiones lambda pueden capturar variables")

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

o incluso una función

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

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

Usar Function es una excelente manera de refactorizar decoradores y adaptadores, consulte aquí

Acabo de empezar a aprender sobre lambdas, así que si ves un error, no dudes en escribir un comentario.

¡Una manera simple de poner algo de valor en una variable externa (no pertenece a la clase anonymus) es cómo sigue!

De la misma manera, si desea obtener el valor de una variable externa, ¡puede crear un método que devuelva lo que desea!

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

    });

 }

Pensé que las clases anónimas eran básicamente como lambdas pero con peor sintaxis ... esto resulta ser cierto, pero la sintaxis es aún peor y hace que (lo que deberían ser) las variables locales se desvanezcan en la clase que las contiene.

No puede acceder a ninguna variable final convirtiéndolas en campos de la clase principal.

P.ej

Interfaz:

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

clase:

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();
    }

No sé si lo resolvieron en Java 8 (estoy atrapado en el mundo EE y todavía no tengo 8), pero en C # se vería así:

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

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

            typeProcessor.doStuffThatUsesLambda();
        }
    }

No necesita una interfaz separada en C # tampoco ... ¡Lo extraño! Me encuentro haciendo diseños peores en Java y repitiéndome más porque la cantidad de código + complejidad que tiene que agregar en Java para reutilizar algo es peor que simplemente copiar y pegar la mayor parte del tiempo.