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

Question

¿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 acceder myVariable o sea myVariable pasado sin crear la escucha como una clase llamada real?

Answer 1

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

Sin embargo, las clases pueden hacer referencia a variables que contengan ámbitos. Para una clase anónima, estas pueden ser variables de instancia de la (s) clase (s) contenedora (s) o variables locales que se marcan como finales.

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

Answer 2

sí. puedes capturar variables, visibles para la clase interna. la única limitación es que tiene que ser última

Answer 3

De esta manera:

final int myVariable = 1; 

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

Answer 4

Sí, mediante la adición de un método de inicialización que devuelve 'esto', e inmediatamente llamar a ese método: declaración de 'final'

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 es necesario.

Answer 5

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 están discutidos en Why java Instance initializers? y How is an instance initializer different from a constructor? discute las diferencias de constructores.

Answer 6

Mi solución es utilizar 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: (a partir de un cierto código GWT para manejar un cambio 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 a la nueva clase-método anónimo con:

textBox.addChangeHandler(newNameChangeHandler(myAxisName, myLogger)) 

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

Answer 7

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 que myVariable sea definitivo, debe envolverlo en un nuevo ámbito donde no importe, 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.

Answer 8

Una manera simple de poner un cierto valor en una variable externa (no pertenece a la clase anonymus) es cómo folow!

De la misma manera, si quiere 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 

    }); 

} 

Answer 9

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

Puede acceder a ninguna variable final al convertirlas en campos de la clase principal.

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 han ordenados esto en java 8 (estoy atascado en el mundo EE y no tiene 8 todavía) 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 peores diseños en Java y repitiéndome más porque la cantidad de código + complejidad que tienes que agregar en java para reutilizar algo es peor que simplemente copiar y pegar muchas veces.

Answer 10

Esto va a hacer que 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)); 

Answer 11

Puede utilizar plain lambdas ("expresiones lambda puede capturar las 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)); 

Uso de la función es una excelente forma de refactorizar decoradores y adaptadores, see here

Acabo de empezar a aprender sobre lambdas, por lo que si detecta un error, no dude en escribir un comentario.