Jak przekazać parametry do anonimowej klasy?

Czy można przekazać parametry lub uzyskać dostęp do parametrów zewnętrznych do anonimowej klasy? Na przykład:

int myVariable = 1;

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

Czy istnieje sposób, aby detektor uzyskał dostęp do myVariable lub został przekazany do myVariable bez tworzenia detektora jako rzeczywistej nazwanej klasy?

Technicznie nie, ponieważ klasy anonimowe nie mogą mieć konstruktorów.

Jednak klasy mogą odwoływać się do zmiennych z zakresów zawierających. W przypadku klasy anonimowej mogą to być zmienne instancji z klas zawierających je lub zmienne lokalne, które są oznaczone jako końcowe.

edycja : Jak zauważył Peter, możesz również przekazać parametry do konstruktora nadklasy klasy anonimowej.

Tak, przez dodanie metody inicjującej, która zwraca „this” i natychmiastowe wywołanie tej metody:

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

Nie jest wymagana deklaracja „końcowa”.

tak. możesz przechwycić zmienną, widoczną dla klasy wewnętrznej. jedynym ograniczeniem jest to, że musi być ostateczna

Lubię to:

final int myVariable = 1;

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

To zrobi magię

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

Jak pokazano na http://www.coderanch.com/t/567294/java/java/declare-constructor-anonymous-class , możesz dodać inicjator instancji. Jest to blok, który nie ma nazwy i jest wykonywany jako pierwszy (tak jak konstruktor).

Wygląda na to, że są one również omówione w artykule Dlaczego inicjatory instancji Java? i czym różni się inicjator wystąpienia od konstruktora? omawia różnice od konstruktorów.

Moim rozwiązaniem jest użycie metody, która zwraca zaimplementowaną klasę anonimową. Do metody można przekazywać zwykłe argumenty, które są dostępne w klasie anonimowej.

Na przykład: (z jakiegoś kodu GWT do obsługi zmiany pola tekstowego):

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

W tym przykładzie do nowej anonimowej metody klasy będzie odwoływać się:

textBox.addChangeHandler(newNameChangeHandler(myAxisName, myLogger))

LUB , korzystając z wymagań 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);

Inni ludzie już odpowiedzieli, że klasy anonimowe mają dostęp tylko do zmiennych końcowych. Ale pozostawiają otwarte pytanie, jak zachować oryginalną zmienną jako nieostateczną. Adam Mlodziński podał rozwiązanie, ale jest dość rozdęty. Istnieje znacznie prostsze rozwiązanie tego problemu:

Jeśli nie chcesz myVariablebyć ostateczny, musisz umieścić go w nowym zakresie, w którym nie ma znaczenia, czy jest ostateczny.

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 Mlodziński nie robi nic więcej w swojej odpowiedzi, ale z dużo większym kodem.

Możesz używać zwykłych wyrażeń lambda („wyrażenia lambda mogą przechwytywać zmienne”)

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

lub nawet funkcja

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

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

Korzystanie z funkcji to świetny sposób na refaktoryzację dekoratorów i adapterów, patrz tutaj

Właśnie zacząłem się uczyć o lambdach, więc jeśli zauważysz błąd, napisz komentarz.

Prosty sposób na umieszczenie wartości w zmiennej zewnętrznej (nie należy do klasy anonymus) jest następujący!

W ten sam sposób, jeśli chcesz uzyskać wartość zmiennej zewnętrznej, możesz utworzyć metodę, która zwraca to, co chcesz!

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

    });

 }

Myślałem, że anonimowe klasy są w zasadzie podobne do lambd, ale z gorszą składnią ... okazuje się, że jest prawdą, ale składnia jest jeszcze gorsza i powoduje (co powinno być) lokalne zmienne wyciekające do klasy zawierającej.

Nie możesz uzyskać dostępu do żadnych zmiennych końcowych, przekształcając je w pola klasy nadrzędnej.

Na przykład

Berło:

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

klasa:

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

Nie wiem, czy załatwili to w Javie 8 (utknąłem w świecie EE i jeszcze nie mam 8), ale w C # wyglądałoby to tak:

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

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

            typeProcessor.doStuffThatUsesLambda();
        }
    }

Nie potrzebujesz też osobnego interfejsu w c # ... Tęsknię za tym! Uważam, że robię gorsze projekty w Javie i powtarzam się częściej, ponieważ ilość kodu + złożoność, którą trzeba dodać w Javie, aby ponownie użyć czegoś, jest gorsza niż zwykłe kopiowanie i wklejanie dużo czasu.