# Unterschied innere Klasse/ anonyme innere Klasse



## drAb17 (12. Nov 2009)

Hallo zusammen. ich stehe vor einem Rätsel respektive mir ist der unterschied zwischen folgenden beiden programcodes nicht klar.


```
class SpeichernAction implements ActionListener{

			@Override
			public void actionPerformed(ActionEvent arg0) {
				saveFields(false);
				
			}	
		}
		speichern.addActionListener(new SpeichernAction());
```

und



```
speichern.addActionListener(new ActionListener(){

			@Override
			public void actionPerformed(ActionEvent arg0) {
				saveFields(false);
				
			}	
		});
```

beide bewirken dasgleiche. was bevorzug ihr?

greez und thx


----------



## javimka (12. Nov 2009)

Bei mir kommt es vor allem darauf an, wie es im Code aussieht, insbesondere, ob es übersichtlich ist. Wenn nur wenige Befehle in der actionPerfomed stehen, wie hier, würde ich zur zweiten Methode tendieren. Wenn aber mehr drin steht, vielleicht eine Fallunterscheidung oder Schleifen, dann ist die erste Variante eher besser. Entscheiden kann man sich dann noch, ob man die Klasse als innere Klasse schreiben will, so dass sie auch auf die privaten Attribute der äusseren Klasse Zugriff hat oder ob man sie total aleinstehen implementieren will.


----------



## Noctarius (13. Nov 2009)

Eine annonyme, innere Klasse nutze ich dann, wenn ich weiß, dass ich den Code wirklich nur genau einmal brauche (und wenn es sich sauber und vorallem verständlich in den Codeflow einbinden lässt). Sobald man den selben Code doppelt verwenden kann, kommt ne inner Klasse zum Einsatz, eventuell auch eine normale public Klasse, wenn man es noch in anderen Klassen braucht.


----------



## bygones (13. Nov 2009)

*vote* Closures... naja bygones

```
speichern.addActionListener { saveFields(false);}
```

sonsten wie Noctarius sagt... meistens kommen innere Klassen auch vor wenn ich zu faul bin mir gedanken ueber Name etc zu machen


----------



## Noctarius (13. Nov 2009)

Closures +1


----------



## Spacerat (13. Nov 2009)

Ich persönlich mag es gar nicht, wenn die Methoden von Listenern oder Runnables von ausserhalb einer Klasse erreichbar (sprich aufrufbar) sind. Ich ziehe deswegen innere bzw. anonyme innere Klassen auf jeden Fall vor. Im übrigen: der 1. deiner Codeschnipsel erweckt nicht den anschein einer inneren Klasse. Innere Klassen werden, wie der Name schon erahnen lässt stets innerhalb einer anderen deklariert.
	
	
	
	





```
class Outer
{
  public void aMethod()
  {
    // anonyme innere Klasse
    Thread anonymous = new Thread("Mr X")
    {
      public void run()
      {
        // run
      }
    }
  }

  private class Inner
  {
  }
}

class AnotherOuter
{
  private static class StaticInner
  {
  }
}
```
Im Gegensatz zu anonymen inneren Klassen, welche nur Instanzklassen sein können, können normale innere Klassen auch statisch sein. Instanz- und statische Klassen werden afaik auch noch mal namentlich unterschieden. Wie sie alledings bezeichnet werden, will mir zum Kuckuck grad' nicht einfallen.
@Edit: ... Na also da ist der Begriff den ich gesucht habe: statische innere Klassen werden als *nested* bezeichnet.


----------



## tfa (13. Nov 2009)

Spacerat hat gesagt.:


> Im Gegensatz zu anonymen inneren Klassen, welche nur Instanzklassen sein können, können normale innere Klassen auch statisch sein. Instanz- und statische Klassen werden afaik auch noch mal namentlich unterschieden. Wie sie alledings bezeichnet werden, will mir zum Kuckuck grad' nicht einfallen.


Innere Klassen ("Inner Classes") sind niemals statisch, sonst hätten sie ja kein äußeres, umschließendes Objekt. Allgemein werden solche Klassen, die in anderen Klassen oder Interfaces definiert sind, _nested classes_ genannt, also eingebettete Klassen. Die können dann auch statisch sein.


----------



## Spacerat (13. Nov 2009)

tfa hat gesagt.:


> Innere Klassen ("Inner Classes") sind niemals statisch, sonst hätten sie ja kein äußeres, umschließendes Objekt. Allgemein werden solche Klassen, die in anderen Klassen oder Interfaces definiert sind, _nested classes_ genannt, also eingebettete Klassen. Die können dann auch statisch sein.


bestätigt... hab's schon selbst rausgefunden, während du geantwortet hast.


----------

