Wie übergebe ich Parameter an eine anonyme Klasse?

Ist es möglich, Parameter zu übergeben oder auf externe Parameter an eine anonyme Klasse zuzugreifen? Beispielsweise:

int myVariable = 1;

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

Gibt es eine Möglichkeit für den Listener, auf myVariable zuzugreifen oder myVariable zu übergeben, ohne den Listener als tatsächlich benannte Klasse zu erstellen?

Technisch gesehen nein, da anonyme Klassen keine Konstruktoren haben können.

Klassen können jedoch auf Variablen verweisen, die Bereiche enthalten. Bei einer anonymen Klasse können dies Instanzvariablen aus den enthaltenden Klassen oder lokale Variablen sein, die als endgültig markiert sind.

edit : Wie Peter betonte, können Sie Parameter auch an den Konstruktor der Oberklasse der anonymen Klasse übergeben.

Ja, indem Sie eine Initialisierungsmethode hinzufügen, die 'this' zurückgibt, und diese Methode sofort aufrufen:

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

Keine "endgültige" Erklärung erforderlich.

Ja. Sie können Variablen erfassen, die für die innere Klasse sichtbar sind. Die einzige Einschränkung ist, dass es endgültig sein muss

So was:

final int myVariable = 1;

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

Dies wird die Magie tun

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

Wie unter http://www.coderanch.com/t/567294/java/java/declare-constructor-anonymous-class gezeigt , können Sie einen Instanzinitialisierer hinzufügen. Es ist ein Block, der keinen Namen hat und zuerst ausgeführt wird (genau wie ein Konstruktor).

Sieht so aus, als würden sie auch unter Warum Java-Instanz-Initialisierer besprochen ? und Wie unterscheidet sich ein Instanzinitialisierer von einem Konstruktor? diskutiert Unterschiede zu Konstruktoren.

Meine Lösung besteht darin, eine Methode zu verwenden, die die implementierte anonyme Klasse zurückgibt. Regelmäßige Argumente können an die Methode übergeben werden und sind in der anonymen Klasse verfügbar.

Zum Beispiel: (von einem GWT-Code zur Behandlung einer Textfeldänderung):

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

In diesem Beispiel wird auf die neue anonyme Klassenmethode verwiesen mit:

textBox.addChangeHandler(newNameChangeHandler(myAxisName, myLogger))

ODER unter Verwendung der Anforderungen des 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);

Andere Personen haben bereits geantwortet, dass anonyme Klassen nur auf endgültige Variablen zugreifen können. Sie lassen jedoch die Frage offen, wie die ursprüngliche Variable nicht endgültig bleiben soll. Adam Mlodzinski gab eine Lösung, ist aber ziemlich aufgebläht. Es gibt eine viel einfachere Lösung für das Problem:

Wenn Sie nicht myVariableendgültig sein möchten , müssen Sie es in einen neuen Bereich einschließen, in dem es keine Rolle spielt, ob es endgültig ist.

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 tut in seiner Antwort nichts anderes als viel mehr Code.

Sie können einfache Lambdas verwenden ("Lambda-Ausdrücke können Variablen erfassen")

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

oder sogar eine Funktion

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

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

Die Verwendung von Function ist eine großartige Möglichkeit, Dekorateure und Adapter umzugestalten. siehe hier)

Ich habe gerade angefangen, etwas über Lambdas zu lernen. Wenn Sie also einen Fehler entdecken, können Sie gerne einen Kommentar schreiben.

Eine einfache Möglichkeit, einer externen Variablen einen Wert zu geben (gehört nicht zur Anonymus-Klasse), ist wie folgt!

Auf die gleiche Weise können Sie eine Methode erstellen, die das zurückgibt, was Sie möchten, wenn Sie den Wert einer externen Variablen erhalten möchten!

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

    });

 }

Ich dachte, anonyme Klassen wären im Grunde genommen wie Lambdas, aber mit schlechterer Syntax ... dies stellt sich als wahr heraus, aber die Syntax ist noch schlechter und führt dazu, dass (was sollte) lokale Variablen in die enthaltende Klasse ausbluten.

Sie können auf keine endgültigen Variablen zugreifen, indem Sie sie in Felder der übergeordneten Klasse umwandeln.

Z.B

Schnittstelle:

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

Klasse:

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

Ich weiß nicht, ob sie das in Java 8 geklärt haben (ich stecke in der EE-Welt fest und habe noch keine 8), aber in C # würde es so aussehen:

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

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

            typeProcessor.doStuffThatUsesLambda();
        }
    }

Sie brauchen auch keine separate Schnittstelle in c # ... Ich vermisse es! Ich finde mich dabei, schlechtere Designs in Java zu erstellen und mich mehr zu wiederholen, weil die Menge an Code + Komplexität, die Sie in Java hinzufügen müssen, um etwas wiederzuverwenden, schlimmer ist, als viel zu kopieren und einzufügen.