Bagaimana cara mengirimkan parameter ke kelas anonim?

Apakah mungkin untuk melewatkan parameter, atau mengakses parameter eksternal ke kelas anonim? Sebagai contoh:

int myVariable = 1;

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

Apakah ada cara bagi pendengar untuk mengakses myVariable atau diteruskan myVariable tanpa membuat pendengar sebagai kelas bernama sebenarnya?

Secara teknis, tidak, karena kelas anonim tidak dapat memiliki konstruktor.

Namun, kelas dapat merujuk variabel dari yang berisi cakupan. Untuk kelas anonim, ini bisa berupa variabel instan dari kelas yang berisi atau variabel lokal yang ditandai sebagai final.

sunting : Seperti yang ditunjukkan Peter, Anda juga dapat meneruskan parameter ke konstruktor superclass dari kelas anonim.

Ya, dengan menambahkan metode penginisialisasi yang mengembalikan 'ini', dan segera memanggil metode itu:

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

Tidak diperlukan deklarasi 'final'.

Iya. Anda dapat menangkap variabel, terlihat oleh kelas dalam. satu-satunya batasan adalah harus final

Seperti ini:

final int myVariable = 1;

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

Ini akan melakukan keajaiban

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

Seperti yang ditunjukkan di http://www.coderanch.com/t/567294/java/java/declare-constructor-anonymous-class Anda dapat menambahkan instanceizer. Ini adalah blok yang tidak memiliki nama dan dieksekusi terlebih dahulu (seperti konstruktor).

Sepertinya mereka juga dibahas di inisialisasi Mengapa java Instance? dan Bagaimana penginisiasi instance berbeda dari konstruktor? membahas perbedaan dari konstruktor.

Solusi saya adalah menggunakan metode yang mengembalikan kelas anonim yang diimplementasikan. Argumen reguler dapat diteruskan ke metode dan tersedia dalam kelas anonim.

Misalnya: (dari beberapa kode GWT untuk menangani perubahan kotak teks):

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

Untuk contoh ini, metode kelas anonim baru akan dirujuk dengan:

textBox.addChangeHandler(newNameChangeHandler(myAxisName, myLogger))

ATAU , menggunakan persyaratan 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);

Orang lain sudah menjawab bahwa kelas anonim hanya dapat mengakses variabel akhir. Tetapi mereka membiarkan pertanyaan terbuka bagaimana menjaga variabel asli non-final. Adam Mlodzinski memberikan solusi tetapi cukup kembung. Ada solusi yang lebih sederhana untuk masalah ini:

Jika Anda tidak ingin myVariablemenjadi final, Anda harus membungkusnya dalam ruang lingkup baru di mana itu tidak masalah, jika itu final.

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 tidak melakukan hal lain dalam jawabannya tetapi dengan lebih banyak kode.

Anda dapat menggunakan lambda biasa ("ekspresi lambda dapat menangkap variabel")

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

atau bahkan sebuah Fungsi

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

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

Menggunakan Function adalah cara yang bagus untuk refactor Dekorator dan Adaptor, lihat di sini

Saya baru saja mulai belajar tentang lambdas, jadi jika Anda menemukan kesalahan, jangan ragu untuk menulis komentar.

Cara sederhana untuk menaruh beberapa nilai ke variabel eksternal (bukan milik kelas anonimus) adalah bagaimana caranya!

Dengan cara yang sama jika Anda ingin mendapatkan nilai dari variabel eksternal Anda dapat membuat metode yang mengembalikan apa yang Anda inginkan!

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

    });

 }

Saya pikir kelas anonim pada dasarnya seperti lambdas tetapi dengan sintaks yang lebih buruk ... ini ternyata benar tetapi sintaksnya bahkan lebih buruk dan menyebabkan (apa yang seharusnya) variabel lokal berdarah ke dalam kelas yang mengandung.

Anda tidak dapat mengakses variabel final dengan membuatnya menjadi bidang kelas induk.

Misalnya

Antarmuka:

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

kelas:

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

Saya tidak tahu apakah mereka sudah menyelesaikan ini di java 8 (saya terjebak di dunia EE dan belum mendapat 8) tetapi dalam C # akan terlihat seperti ini:

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

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

            typeProcessor.doStuffThatUsesLambda();
        }
    }

Anda tidak perlu antarmuka terpisah di c # baik ... Saya rindu itu! Saya menemukan diri saya membuat desain yang lebih buruk di java dan mengulangi diri saya sendiri lebih karena jumlah kode + kompleksitas yang harus Anda tambahkan di java untuk menggunakan kembali sesuatu lebih buruk daripada hanya menyalin dan menempel banyak waktu.