Dez 20

Was ist der Output des folgenden Codes?

public class Abteilung {

public static void main(String args [ ]){

Gruppe g = new Gruppe (){

public String Name() {

return(“abc”);

}

};
Gruppe.Mitglieder gm = new Gruppe().new Mitglieder(){

public String Name() {

return(“def”);

}

};

}

}
class Gruppe {

public String Name (){

return (“ghi”);

}

abstract class Mitglieder {

public abstract String Name();

}

}


Antwort/ answer
Dez 03

Heute wird der Schwierigkeitsgrad nochmal erhöht :)

Bis jetzt haben wir nur relativ einfache innere Klassen anhand von Klassen/ interfaces implementiert…. heute werden nochmal zusätzlich Argumente ins Spiel gebracht. Gehen wir mal von folgenden Vorraussetzungen aus:

class Gruppe {

void setAufgabe(Aufgabe a) { }

}

interface Aufgabe {

void AufgabeInfo();

}

Wir haben hier die Klasse Gruppe, die für die Ausführung der Methode setAufgabe, das Interface Aufgabe (bzw. eine Instanz der Klasse, die dieses Interface implementiert) benötigt.

So, nun die Frage, wie man möglichst elegant von der Klasse Gruppe eine anonyme Klasse implementiert, die ja auch eine (anonyme) Instanz von Aufgabe benötigt?

public class Abteilung {

public static void main(String args [ ]){

Gruppe g = new Gruppe (); // Achtung: Hier keine Definition einer (anonymen) inneren Klasse
g.setAufgabe (new Aufgabe(){ // hier wird innerhalb der Argument-Übergabe das benötigte Argument als anonyme innere Klasse definiert

public void AufgabeInfo() { // Implementation der nötigen Methoden vom Interface Aufgabe

System.out.println(“AufgabeInfo”);

}

}); // Achtung: hier weichen wir von der üblichen Schreibweise }; ab und schliessen statt dessen  (da ja innerhalb der Argument-Überhabe) mit }); ab

}

}

Dez 01

Bitte beachten, dass immer nur ein Interface oder eine Klasse als Vorlage für eine anonyme innere Klasse dient.

Erst einmal – wie immer – ein Beispiel zur Verdeutlichung:

public class Abteilung {

public static void main(String args [ ]){

Gruppe g = new Gruppe () {};

}

}
class Gruppe{}

interface Gruppe2 {}

bei der Klassendefinition class Gruppe { } können auch andere Klassen erweitert oder interfaces implementiert werden, z.B:

  • class Gruppe implements Gruppe2{}
  • class Gruppe implements Gruppe2, Gruppe3{}
  • class Gruppe extends Abteilung {}

Auch die Interfaces können entsprechend den üblichen Regeln erweitert werden, z.B.

  • interface Gruppe3 extends Gruppe2 {}

Dies dürfte alles schon bekannt, sein. Der Aufruf, die Compilierung und Ausführung einer inneren anonymen Klasse ändert sich bei den vorangegangenen Abänderungen nicht.

Die anonyme innere Klasse kann nur selbst nicht mehrere Klassen oder interfaces erweitern bzw. implementieren. Hier ein paar Beispiele, die zu CompilerFehlern führen:

  • Gruppe g = new Gruppe () implements Gruppe2  {};
  • Gruppe g = new Gruppe implements Gruppe2, Gruppe3 () {};
  • Gruppe g = new Gruppe extends Abteilung() {};
Nov 29

Heute ein Beispiel einer anonymen inneren Klasse mit interfaces anstatt einer Oberklasse:

public class Abteilung {

public static void main(String args [ ]){

Gruppe g = new Gruppe () {

public void getInfo(){

System.out.println(“anonyme Gruppe”);

}

};

g.getInfo();

}

}

interface Gruppe {

public void getInfo();

}

Es gibt also nur wenige Änderungen im Vergleich zur Anwendung mit Oberklassen.

Es mag den einen oder anderen verwirren, da es ja so aussieht, ob ein Interface instanziiert wird – was natürlich nicht möglich ist;  es wird ein anonymes Objekt initiiert, welches das interface Gruppe implementiert.

Nov 27

Eigene Methoden (Methoden, die nicht in der Oberklasse vorhanden sind) innerhalb der anonymen inneren Klasse sind nicht legal.

public class Abteilung {

public static void main(String args [ ]){

Gruppe g = new Gruppe () {

public void getInfo(){

System.out.println(“anonyme Gruppe”);

}
public void doSomething(){
// nicht legal, da die Oberklasse diese Methode nicht hat, aber kein CompilerFehler an dieser Stelle

System.out.println(“Hier bin ich”);

}

};

g.getInfo(); //Ausgabe: anonyme Gruppe
g.doSomething();// CompilerFehler bei Implementierung der Methoden-Nutzung

}

}
class Gruppe {

public void getInfo(){

System.out.println(“nicht-anonyme Gruppe”);

}

}

Nov 25

Bei der Verwendung von anonymen inneren Klassen werden Klassen an ein und derselben Stelle deklariert und instanziiert. Es wird also automatisch ein Objekt erzeugt, welches nur für streng lokale Zwecke genutzt werden kann. Da hierbei kein Klassenname vergeben wird (die Klasse somit namenlos ist), spricht man von einer anonymen Klasse.

Um anonyme innere Klassen verwenden zu können, braucht man entweder ein einfaches interface oder eine Superklasse, die den Hauptteil der benötigten Implementierung bereitstellt.

Jetzt erst einmal ein Beispiel zum besseren Verständnis:

public class Abteilung {

public static void main(String args [ ]){

Gruppe g = new Gruppe () { //  Es wird eine Art Unterklasse von Gruppe deklariert und erzeugt, die aber keinen eigenen Namen hat

// Definition der anonymen Klasse

public void getInfo(){ // Überschreibung der Methode getInfo()

System.out.println(“anonyme Gruppe”);

}

}; // Ende der anonymen inneren Klasse welche zwingend mit ‘;’ abgeschlossen werden muss

}

}

class Gruppe { // Definition der eigentlichen Klasse

public void getInfo(){ // Ursprüngliche Methode der Klasse Gruppe

System.out.println(“nicht-anonyme Gruppe”);

}

}

preload preload preload
http://www.wikio.de Blog Top Liste - by TopBlogs.de Blogverzeichnis - Blog Verzeichnis bloggerei.de Bloggeramt.de Software
Webbhotell Top Blogs