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 05

Zum Abschluss der inneren Klassen etwas einfacheres; die statisch eingebetteten inneren Klassen (englisch: static nested Classes):

public class Abteilung {

static class Zuständigkeiten { // Definition der statisch eingebetteten inneren Klasse

void getInfo (){

System.out.println(“Info Zuständigkeiten”);

}

}

public static void main(String args [ ]){

Gruppe.Aufgabengebiete ga = new Gruppe.Aufgabengebiete (); // Implementierung der statisch eingebetteten inneren KLasse
Zuständigkeiten z = new Zuständigkeiten(); // Implementierung der statisch eingebetteten inneren Klasse

ga.getInfo(); // kein Unterschied zu anderen Klassen bei Methodenaufruf
z.getInfo(); // kein Unterschied zu anderen Klassen bei Methodenaufruf

}

}
class Gruppe {

static class Aufgabengebiete{ // ebenfalls eine Definition einer statisch eingebetteten inneren Klasse

void getInfo (){

System.out.println(“Info Aufgabengebiete”);

}

}

}

Bis dahin relativ einfach; solange die Klassen als statisch deklariert sind und entsprechende Zugriffsrechte haben, können sie wie jede andere Klassen einfach eingebettet werden.

Ein paar Tücken gibt es aber leider doch:

statische Klassen haben keinen Zugriff auf Instanz-Variablen und nicht-statische Methoden der äußeren Klasse.

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

}

}

Nov 23

Bei statischen Methoden bitte beachten, dass nur statische Variablen außerhalb der Methode aufgerufen werden können:

public class Abteilung {

final String name3 =”Test3″;
static String name4 = “Test4″;
String name5 = “Test5″;

static void doSomething(){

String name1 =”Test1″;
final String name2 =”Test2″;
class newClass{

void getName() {

System.out.println(name1); // CompilerFehler, da innerhalb der Methode und nicht final
System.out.println(name2);
// ok, da final
System.out.println(name3); // CompilerFehler, da evtl. noch nicht intialisiert
System.out.println(name4);
// ok, statische Methoden können nur (äußere) statische Variablen aufrufen, alle anderen sind evtl. zu dem Zeitpunkt des Aufrufes nicht initialisiert
System.out.println(name5); // CompilerFehler

}

}
newClass a = new newClass();
a.getName();

}
public static void main(String args [ ]){

Abteilung a = new Abteilung();
a.doSomething();

}

}

Tagged with:
Nov 21

Ich hatte ja schon erläutert, das eine innere Klasse auf alle Variablen/Objekte der äußeren Klasse zugreifen kann. Ist aber eine Klasse innerhalb einer Methode der Oberklasse definiert, verhält sich dies für die Variablen/ Objekte der Methode nicht so:

public class Abteilung {

String name =”Finance”;

void doSomething(){

String name1 =”Test1″;
final String name2 =”Test2″;
class newClass{

void getName() {

System.out.println(name1); //CompilerFehler, da nicht final
System.out.println(name2); // Ausgabe: Test2

System.out.println(name); // Auf die Variablen der Klasse kann wie gewohnt zugegriffen werden; Ausgabe ist: “Finance”

}

}
newClass a = new newClass();
// Erzeugen einer Instanz von newClass
a.getName(); // Aufruf der Methode getName von newClass

}
public static void main(String args [ ]){

Abteilung a = new Abteilung();
a.doSomething();

}

}

Klassen innerhalb von Methoden (auch lokale Klassen genannt) können auf deren Variablen/Objekte nur zugreifen, wenn diese als final und damit als unveränderlich deklariert sind.

Tagged with:
Nov 19

Auch in einer Methode der Oberklasse kann eine innere Klasse definiert werden:

public class Abteilung {

void doSomething(){

class newClass{ } // Nur Definition keine Instantiierung
newClass a = new newClass();
// erst hier erfolgt die Instantiierung

}
public static void main(String args [ ]){

Abteilung a = new Abteilung();
a.doSomething();

}

}

Die Klasse newClass ist außerhalb der Methode doSomething nicht bekannt und kann daher auch nur innerhalb dieser Methode verwendet werden.

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