Verständnisfrage

[hdi]

Hey,

sry für den ungenauen Titel, kann's aber nicht so knapp zusammenfassen.

Die Frage stammt ursprünglich aus einem anderen Thread, dessen Frage eigentlich schon
lange gelöst ist. (Da schaut wohl keiner mehr rein) Jetz hatte der Ersteller mich aber noch eine Sache gefragt, und beim Versuch, ihm das zu erklären, habe ich gemerkt, dass ich es selber nicht so wirklich weiss..

Es ging um folgendes, der User hatte Probleme mit - sinngemäß - diesem Code:

for(int i = 0; i<10; i++){
     // ...
     something.addActionListener(new ActionListener(){
          @Override 
          public void actionPerformed(ActionEvent e){
                   doStuff (i);
          }
      }
}

Weil er i nicht in der doStuff() Methode übergeben kann, ohne es final zu machen. Und das geht ja
nicht, denn man inkrementiert i ja in der Schleife. So, ich hab ihm gesagt er soll sich einfach ne final
Variable innerhalb der Schleife machen und der den Wert i zuweisen, hab das wohl eher schwammig erklärt, warum
das so ist usw. ich muss das ja jetz nicht alles wiederholen.

Was ich jetzt wissen will:

1) erzeugt man mit

something.addActionListener(new ActionListener(){})

eine anonyme Klasse? Also nicht nur eine Instanz einer Klasse, sondern man definiert hier ne neue Klasse, oder?
Die halt dann das ActionListener Interface implementiert?

2) Wieso muss man eigentlich final Variablen übergeben? Wenn man sich ne eigene Klasse schreibt, die
das ActionListener Interface implementiert, mit nem Konstruktor dem man das i übergeben kann, geht
es ja auch ohne final:

for(int i = 0; i<10; i++){
     // ...
     something.addActionListener(new MyListener( i ));
}

Wieso also genau muss das final sein bei der ersten Variante? Bitte nur Antworten von echten Cracks,
die es komplett verstehen, und nicht nur Rumgerate Das hab ich selber schon gemacht als ich dem User
geantwortet hab, ich will's aber mal so richtig genau verstehen!

Danke

 

[Wildcard]

1. ja, man erzeugt eine anonyme innere Klasse die ActionListener implementiert.
2. Das ist so nicht richtig. Die innere Klasse hat Zugriff auf den kompletten Variablen Stack (sprich Member der Klasse können zB verwendet werden und müssen auch nicht final sein).
Bei lokalen Variablen ist die Sache aber anders. Beispiel an diesem Code Fragment:

int i = 5;
InnerClass c = new InnerClass(){
   public doSomethingWithI(){
        System.out.println(i);
   }
} 
i = 16;
c.doSomethingWithI();

Was soll ausgegeben werden? 5, oder 16? I zum Zeitpunkt der Erstellung, oder zum Zeitpunkt des Aufrufs?
Du vergleichst mit einem Konstruktor. Im Konstruktorfall wäre es 5, sieht man sich jedoch die Codereihenfolge an, wäre eher mit 16 zu rechnen.
Man umgeht dieses fehleranfällige Konstrukt in dem man final Variablen erzwingt.
Womöglich gibt es auch einen technischen Hintergrund, aber alleine schon von der Sprachdefinition wäre das eine sehr gefährliche Code Konstellation.

 

[hdi]

sry doppelpost

 

[hdi]

Soweit hatte ich mir das auch gedacht, und du hast das jetzt bestätigt. Aber ich dachte ich irre mich
in dieser Annahme, denn:

Wenn diese neu erstellte anonyme Klasse sich wirklich auf die übergebenen Variable bezieht,
macht es zwar in der Tat Sinn, diese Variable als final zu erzwingen, aber wieso funktioniert dann folgendes:

for(int i = 0; i<10; i++){
     button = new JButton(); // angenommen der Button ist als statische Klassen-Variable deklariert o.ä.
     final int a = i;
     button.addActionListener(new ActionListener(){
          @Override
          public void actionPerformed(ActionEvent e){
                   doStuff (a);
          }
      }
}

... und wenn ich das Programm starte und klick, passiert doStuff(). Gedanke: auch die final Variable "a" ist
doch nur innerhalb der Schleife sichtbar, und nach der for-Schleife weg! Aber es funzt trotzdem! Ergo:
Die Klasse erstellt sich ne Kopie der Variablen, aaaaaber dann wären wir wieder bei der Frage:
Wenn die Klasse sich den Wert eh in ner eigenen Variablen speichert, wofür dann überhaupt erst umständlich
ne final aus i ziehen, die dann kopiert wird, statt gleich ne Kopie von i zu machen?

:autsch:

 

[Wildcard]

Wie gesagt, durch das final ist klar definiert auf welchen Wert sich die innere Klasse bezieht.

 

[Murray]

Hier ist das ganz gut erklärt.

 

[hdi]

Hm... okay dann nehm ich das einfach so hin. Ich versteh aber noch immer nich ganz, wie diese inner class
sich die Variable abspeichert, weil sie ja eben eigentlich nach der for-schleife weg ist. Anscheinend ist final
die Bedingung dafür, dass er sie überhaupt speichern kann. Naja ok, danke

 

[musiKk]

Diese anonyme innere Klasse ist ein Ersatz für Closures, die es in verschiedenen anderen (vor allem funktionalen) Sprachen gibt. Eine Closure erhält Zugriff auf die Variablen, die im Moment der Definition im Scope sind.

Hier wird das auch nochmal im Zusammenhang erläutert.