Come passare i parametri alla classe anonima?

È possibile passare parametri o accedere a parametri esterni a una classe anonima? Per esempio:

int myVariable = 1;

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

Esiste un modo per l'ascoltatore di accedere a myVariable o passare myVariable senza creare l'ascoltatore come una vera classe denominata?

Tecnicamente no, perché le classi anonime non possono avere costruttori.

Tuttavia, le classi possono fare riferimento a variabili dal contenere ambiti. Per una classe anonima queste possono essere variabili di istanza dalle classi contenenti o dalle variabili locali contrassegnate come finali.

modifica : come ha sottolineato Peter, puoi anche passare i parametri al costruttore della superclasse della classe anonima.

Sì, aggiungendo un metodo di inizializzazione che restituisce 'this' e chiamando immediatamente quel metodo:

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

Nessuna dichiarazione "finale" necessaria.

sì. puoi acquisire variabili, visibili alla classe interna. l'unica limitazione è che deve essere definitiva

Come questo:

final int myVariable = 1;

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

Questo farà 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));

Come mostrato su http://www.coderanch.com/t/567294/java/java/declare-constructor-anonymous-class è possibile aggiungere un inizializzatore di istanza. È un blocco che non ha un nome e viene eseguito per primo (proprio come un costruttore).

Sembra che siano anche discussi su Perché gli inizializzatori dell'istanza java?e In che modo un inizializzatore di istanza è diverso da un costruttore? discute le differenze rispetto ai costruttori.

La mia soluzione è utilizzare un metodo che restituisce la classe anonima implementata. Argomenti regolari possono essere passati al metodo e sono disponibili all'interno della classe anonima.

Ad esempio: (da un codice GWT per gestire una modifica della casella di testo):

/* 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)
        }
     };
}

Per questo esempio, il nuovo metodo di classe anonimo verrebbe referenziato con:

textBox.addChangeHandler(newNameChangeHandler(myAxisName, myLogger))

OPPURE , utilizzando i requisiti del PO:

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

Altre persone hanno già risposto che le classi anonime possono accedere solo alle variabili finali. Ma lasciano aperta la domanda su come mantenere la variabile originale non definitiva. Adam Mlodzinski dato una soluzione ma è piuttosto gonfio. Esiste una soluzione molto più semplice per il problema:

Se non vuoi myVariableessere definitivo, devi avvolgerlo in un nuovo ambito in cui non ha importanza, se è 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 non fa nient'altro nella sua risposta ma con molto più codice.

Puoi usare semplici lambda ("le espressioni lambda possono catturare variabili")

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

o anche una funzione

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

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

L'uso della funzione è un ottimo modo per refactoring Decoratori e adattatori, vedi qui

Ho appena iniziato a conoscere lambda, quindi se noti un errore, sentiti libero di scrivere un commento.

Un modo semplice per mettere un po 'di valore in una variabile esterna (non appartiene alla classe anonima) è come folow!

Allo stesso modo se vuoi ottenere il valore di una variabile esterna puoi creare un metodo che restituisca quello che vuoi!

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

    });

 }

Pensavo che le classi anonime fossero fondamentalmente come lambda, ma con una sintassi peggiore ... questo risulta essere vero, ma la sintassi è ancora peggiore e causa la fuoriuscita delle variabili locali (che dovrebbero essere) nella classe contenente.

Non è possibile accedere a nessuna variabile finale facendole rientrare nei campi della classe genitore.

Per esempio

Interfaccia:

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

Non so se l'hanno risolto in Java 8 (sono bloccato nel mondo EE e non ne ho ancora 8) ma in C # sarebbe simile a questo:

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

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

            typeProcessor.doStuffThatUsesLambda();
        }
    }

Non hai nemmeno bisogno di un'interfaccia separata in c # ... Mi manca! Mi ritrovo a fare progetti peggiori in Java e ripetermi di più perché la quantità di codice + complessità che devi aggiungere in Java per riutilizzare qualcosa è peggiore della semplice copia e incolla del tempo.