Comment passer des paramètres à une classe anonyme?

Est-il possible de passer des paramètres ou d'accéder à des paramètres externes à une classe anonyme? Par exemple:

int myVariable = 1;

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

Existe-t-il un moyen pour l'écouteur d'accéder à myVariable ou de se faire passer myVariable sans créer l'écouteur en tant que classe nommée réelle?

Techniquement, non, car les classes anonymes ne peuvent pas avoir de constructeur.

Cependant, les classes peuvent référencer des variables à partir d'étendues contenant. Pour une classe anonyme, il peut s'agir de variables d'instance de la ou des classes contenant ou de variables locales marquées comme finales.

edit : Comme l'a souligné Peter, vous pouvez également passer des paramètres au constructeur de la superclasse de la classe anonyme.

Oui, en ajoutant une méthode d'initialisation qui renvoie 'this', et en appelant immédiatement cette méthode:

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

Aucune déclaration «finale» nécessaire.

Oui. vous pouvez capturer la variable, visible par la classe interne. la seule limitation est qu'il doit être définitif

Comme ça:

final int myVariable = 1;

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

Cela fera la magie

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

Comme indiqué sur http://www.coderanch.com/t/567294/java/java/declare-constructor-anonymous-class, vous pouvez ajouter un initialiseur d'instance. C'est un bloc qui n'a pas de nom et qui est exécuté en premier (tout comme un constructeur).

On dirait qu'ils sont également abordés dans Pourquoi les initialiseurs d'instance Java? et En quoi un initialiseur d'instance est-il différent d'un constructeur? discute des différences par rapport aux constructeurs.

Ma solution consiste à utiliser une méthode qui retourne la classe anonyme implémentée. Des arguments réguliers peuvent être passés à la méthode et sont disponibles dans la classe anonyme.

Par exemple: (à partir d'un code GWT pour gérer un changement de zone de texte):

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

Pour cet exemple, la nouvelle méthode de classe anonyme serait référencée avec:

textBox.addChangeHandler(newNameChangeHandler(myAxisName, myLogger))

OU , en utilisant les exigences du 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);

D'autres personnes ont déjà répondu que les classes anonymes ne peuvent accéder qu'aux variables finales. Mais ils laissent la question ouverte de savoir comment garder la variable d'origine non définitive. Adam Mlodzinski a donné une solution mais c'est assez gonflé. Il existe une solution beaucoup plus simple au problème:

Si vous ne voulez myVariablepas être définitif, vous devez l'envelopper dans une nouvelle portée où cela n'a pas d'importance, si elle est définitive.

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 ne fait rien d'autre dans sa réponse mais avec beaucoup plus de code.

Vous pouvez utiliser des lambdas simples ("les expressions lambda peuvent capturer des variables")

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

ou même une fonction

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

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

Utiliser Function est un excellent moyen de refactoriser les décorateurs et les adaptateurs, voir ici

Je viens de commencer à en apprendre davantage sur les lambdas, donc si vous repérez une erreur, n'hésitez pas à écrire un commentaire.

Un moyen simple de mettre de la valeur dans une variable externe (n'appartient pas à la classe anonymus) est de savoir comment suivre!

De la même manière, si vous voulez obtenir la valeur d'une variable externe, vous pouvez créer une méthode qui retourne ce que vous voulez!

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

    });

 }

Je pensais que les classes anonymes étaient fondamentalement comme des lambdas mais avec une syntaxe pire ... cela s'avère être vrai mais la syntaxe est encore pire et provoque (ce qui devrait être) des variables locales à saigner dans la classe contenant.

Vous ne pouvez accéder à aucune variable finale en les transformant en champs de la classe parent.

Par exemple

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

Je ne sais pas s'ils ont réglé cela en java 8 (je suis coincé dans le monde EE et je n'ai pas encore 8) mais en C #, cela ressemblerait à ceci:

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

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

            typeProcessor.doStuffThatUsesLambda();
        }
    }

Vous n'avez pas non plus besoin d'une interface séparée en c # ... ça me manque! Je me surprends à faire de pires conceptions en java et à me répéter davantage parce que la quantité de code + la complexité que vous devez ajouter en java pour réutiliser quelque chose est pire que de simplement copier et coller la plupart du temps.