Parametreler anonim sınıfa nasıl aktarılır?

Anonim bir sınıfa parametreler iletmek veya harici parametrelere erişmek mümkün mü? Örneğin:

int myVariable = 1;

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

Dinleyicinin, dinleyiciyi gerçek bir adlandırılmış sınıf olarak oluşturmadan myVariable'a erişmesinin veya myVariable'ı geçirmesinin herhangi bir yolu var mı?

Teknik olarak hayır, çünkü anonim sınıfların kurucuları olamaz.

Bununla birlikte, sınıflar, içeren kapsamlardan değişkenlere başvurabilir. Anonim bir sınıf için bunlar, içeren sınıflardan örnek değişkenler veya son olarak işaretlenmiş yerel değişkenler olabilir.

düzenleme : Peter'ın da belirttiği gibi, parametreleri anonim sınıfın üst sınıfının yapıcısına da aktarabilirsiniz.

Evet, 'this' döndüren bir başlatıcı yöntemi ekleyerek ve hemen bu yöntemi çağırarak:

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

'Nihai' beyana gerek yok.

Evet. iç sınıfa görünür olan değişkeni yakalayabilirsiniz. tek sınırlama, nihai olması gerektiğidir

Bunun gibi:

final int myVariable = 1;

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

Bu sihri yapacak

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

Http://www.coderanch.com/t/567294/java/java/declare-constructor-anonymous-class adresinde gösterildiği gibi bir örnek başlatıcı ekleyebilirsiniz. Adı olmayan ve önce çalıştırılan bir bloktur (bir kurucu gibi).

Görünüşe göre neden java Örneği başlatıcılar da tartışılıyor. ve Bir örnek başlatıcının bir yapıcıdan farkı nedir? Yapıcılardan farklılıkları tartışır.

Benim çözümüm, uygulanan anonim sınıfı döndüren bir yöntem kullanmak. Normal argümanlar yönteme geçirilebilir ve anonim sınıf içinde kullanılabilir.

Örneğin: (Metin kutusu değişikliğini işlemek için bazı GWT kodlarından):

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

Bu örnek için, yeni anonim sınıf yöntemine şununla başvurulacaktır:

textBox.addChangeHandler(newNameChangeHandler(myAxisName, myLogger))

VEYA OP'nin gerekliliklerini kullanarak:

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

Diğer insanlar, anonim sınıfların yalnızca son değişkenlere erişebileceğini zaten yanıtladı. Ancak asıl değişkeni nihai olmayan şekilde nasıl koruyacakları sorusunu açık bırakırlar. Adam Mlodzinski bir çözüm sundu ama oldukça şişkin. Sorun için çok daha basit bir çözüm var:

myVariableNihai olmak istemiyorsanız , son olup olmadığı önemli olmayan yeni bir kapsamda sarmalamanız gerekir.

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 cevabında başka bir şey yapmıyor, çok daha fazla kodla.

Düz lambdalar kullanabilirsiniz ("lambda ifadeleri değişkenleri yakalayabilir")

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

hatta bir İşlev

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

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

Fonksiyonu kullanmak, Dekoratörleri ve Adaptörleri yeniden düzenlemek için harika bir yoldur, buraya bakın

Lambdalar hakkında yeni bir şeyler öğrenmeye başladım, bu yüzden bir hata görürseniz, yorum yazmaktan çekinmeyin.

Harici bir değişkene bir değer koymanın basit bir yolu (anonymus sınıfına ait değildir), işte budur!

Aynı şekilde, harici bir değişkenin değerini almak istiyorsanız, istediğinizi döndüren bir yöntem oluşturabilirsiniz!

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

    });

 }

Anonim sınıfların temelde lambdalar gibi olduğunu sanıyordum, ancak daha kötü sözdizimiyle ... bu doğru çıkıyor ama sözdizimi daha da kötü ve yerel değişkenlerin (ne olması gerektiği) kapsayıcı sınıfa sızmasına neden oluyor.

Hiçbir nihai değişkene, onları ana sınıfın alanları haline getirerek erişemezsiniz.

Örneğin

Arayüz:

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

sınıf:

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

Bunu java 8'de mi çözdüler bilmiyorum (EE dünyasında sıkışıp kaldım ve henüz 8'im yok) ama C #'da şöyle görünecek:

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

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

            typeProcessor.doStuffThatUsesLambda();
        }
    }

C # da ayrı bir arayüze ihtiyacınız yok ... Özledim! Kendimi java'da daha kötü tasarımlar yaparken buluyorum ve kendimi daha çok tekrar ediyorum çünkü bir şeyi yeniden kullanmak için java'ya eklemeniz gereken kod + karmaşıklık miktarı, çoğu zaman kopyalayıp yapıştırmaktan daha kötü.