# Wozu werden die anonyme Klassen verwendet?



## JavaAnfaenger (1. Feb 2010)

Hallo Leute,
eine Frage: wozu werden eigentlich die anonyme Klassen verwendet? Warum macht man sowas?

Bsp:


```
interface SpielStein{
int wert();
}

Class Spieler14{

Spielstein liefereStein(){
return new SpielStein(){   //hier beginnt die anonyme Klasse?
private int wert=99;

public int wert(){
return wert;
}
};
}
}
```


----------



## Michael... (1. Feb 2010)

JavaAnfaenger hat gesagt.:


> Warum macht man sowas?


Weil man zu faul ist ;-)

In diesem Fall nutzt man die anonyme Klasse um eine Instanz direkt von einem Interfaces zu erzeugen, was ja normalerweise nicht geht.


----------



## JavaAnfaenger (1. Feb 2010)

Michael... hat gesagt.:


> Weil man zu faul ist ;-)
> 
> In diesem Fall nutzt man die anonyme Klasse um eine Instanz direkt von einem Interfaces zu erzeugen, was ja normalerweise nicht geht.



hmm also ich habe das nicht so ganz verstanden :noe: also wo genau macht man das in dieser Code?


----------



## JavaAnfaenger (1. Feb 2010)

Michael... hat gesagt.:


> Weil man zu faul ist ;-)
> 
> In diesem Fall nutzt man die anonyme Klasse um eine Instanz direkt von einem Interfaces zu erzeugen, was ja normalerweise nicht geht.




also es entsteht Fehler:



```
package anonymeklasse;

public interface SpielStein {
int wert();
}

class Spieler14 {
Spielstein liefereStein(){    //Hier entsteht eine Fehler, SpielStein kann nicht gefunden werden?
    
return new SpielStein(){
private int wert=99;
public int wert(){
return wert;
}
};
}
}
```


----------



## Michael... (1. Feb 2010)

In dem Code macht man es da wo es im Kommentar steht.

Bsp: folgendes Interface:

```
interface DemoInterface {
	public int getSomething();
}
```


```
DemoInterface i = new DemoInterface();
```
Geht nicht, da man von einen Interface (ist ja nur eine Defintion) kein Objekt erstellen kann.

```
DemoInterface i = new DemoInterface() {
	public int getSomething() {
		return 1;
	}
};
```
Geht, da hier durch "überschreiben" von getSomething() das Interface in einer anonymen Klasse implementiert wird.


----------



## JavaAnfaenger (1. Feb 2010)

Michael... hat gesagt.:


> In dem Code macht man es da wo es im Kommentar steht.
> 
> Bsp: folgendes Interface:
> 
> ...



ach stimmt  vielen vielen Dank jetzt hab ich es verstanden!


----------



## Michael... (1. Feb 2010)

JavaAnfaenger hat gesagt.:


> ```
> Spielstein liefereStein(){
> //Hier entsteht eine Fehler, SpielStein kann nicht gefunden werden?
> ```


Das Interface heisst Spiel*S*tein und nicht Spiel*s*tein


----------



## JavaAnfaenger (1. Feb 2010)

```
interface DemoInterface {
    public int getSomething();
}

DemoInterface i = new DemoInterface() {
public int getSomething() {
return 1;
}
};
```

ehm eine Frage noch dazu: Wie schreibt man das ganze? Wenn man es z.B. programmiert?


----------



## Michael... (1. Feb 2010)

JavaAnfaenger hat gesagt.:


> ehm eine Frage noch dazu: Wie schreibt man das ganze? Wenn man es z.B. programmiert?


Verstehe leider nicht was Du meinst. Geht's um ein kompilierbares Bsp?

```
public class Demo {
	public static void main(String[]  args){
		DemoInterface i = new DemoInterface() {
			public int getSomething() {
				return 1;
			}
		};
		System.out.println(i.getSomething());
	}
}

interface DemoInterface {
	public int getSomething();
}
```


----------



## Semox (2. Feb 2010)

Hallo JavaAnfaenger

Es gibt einige Gründe, warum man anonyme Klassen anlegt. Die Erklärung mit der Faulheit greift etwas zu kurz. Kann aber durchaus ein Grund sein.

Interessante Gründe sind aber auch:


 Erreichbarkeit durch andere Klassen ist nicht möglich, kann ein Sicherheitsaspekt sein.
 Listener-Implementierung ist ein weiterer Grund
 Weil mit dem Aufruf einer Anonymen Klasse immer die Erzeugung eines Objekts verbunden ist, existieren die Informationen aus dieser inneren anonymen Klasse nur solange, bis das Objekt nicht weiter verwendet wir und der Garbage Collector kommt. Kann ein Vorteil bei einmalig verwendeten Aktionen sein, wonach Listener nie wieder im weiteren Programmverlauf benötigt werden.
 Das erzeugte Objekt ist das einzige seiner Art und kann nicht beliebig oft dupliziert werden. Es existiert genau einmal mit dem Aufruf und endet mit Abschluß seiner Funktion/Verwendung.

Hier ein Zitat von folgender Site:

Anonyme Klassen finden einen sinnvollen Einsatz im Zusammenhang mit der Auswertung von Ereignissen im Fenstersystem. Solche "Events" soll automatisch eine vorher angegebene Funktion beantworten. Da es keine Pointer auf Funktionen in JAVA gibt, benutzt man dort anonyme Klassen als Ersatz.​
Trotzdem sorgt eine Innere anonyme Klasse für schlechtere Wartbarkeit des Programms, wenn man diese mit Funktionen überfrachtet. Für diesen Zweck könnte man sich auch eine einfache abstrakte Klasse bereitstellen und einbinden.

Hoffe das hilft Dir etwas weiter.

Gruß,
Semo


----------

