public class Angestellter  {

int PersNr=10;
int getPersNr(){ return PersNr;}
public static void main (String args[]){

Buchhalter b = new Buchhalter();
System.out.println(b.getPersNr());

}

}
public class Buchhalter extends Angestellter {

int PersNr=12;

}

interface Arbeitsbereich{

String Bereich =”Finanzen”;
int AnzahlMitarbeiter=10;

}
public class Angestellter implements Arbeitsbereich {

public static void main (String args[]){

Angestellter a = new Angestellter();
/* Hier bitte Code eingeben */

}

}

interface PersNr{ void setPersNr (short PersNr); }

public class Angestellter implements PersNr {

void setPersNr(short PersNr){ System.out.println(“short”);}
void setPersNr(long PersNr){ System.out.println(“long”);}

static public void main(String[] Args){

Angestellter a = new Angestellter();
a.setPersNr(1);

}

}

1. AssertionError
2. ClassCastException
3. NullPointerException
4. IllegalStateException
5. ExceptionInInitializerError
6. StackOverflowError
7. NoClassDefFoundError
8. IllegalArgumentException
9. ArrayIndexOutOfBoundsException
10. NumberFormatException

und die Struktur:

a
|_

b
|_

c

|_ Example 1.java

|_ Example1.class

|_ Example 2.java

Example 1.java beinhaltet den text:

package c;

public class Example1 { }

Example2.java beinhaltet den text:

package c;

public class Example2 extends Example1 { }

Wie kann Example2.java compiliert werden?

1. Gehe zu c dann führe aus: javac Example2.java

2. Gehe zu c dann führe aus: javac -classpath . Example2.java

3. Gehe zu b dann führe aus: javac -classpath . c/Example2.java

4. Gehe zu b dann führe aus: javac -classpath c Example2.java

5. Gehe zu b dann führe aus: javac -classpath c:. Example2.java

String str = null;
try {

if (str.length() == 0) { System.out.print(“1″); }

System.out.print(” 2″);

} catch (Exception e) {

System.out.print(” 3″);
System.exit(0);

} finally {

System.out.print(” 4″);

}
System.out.println(” 5″);

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

}

}

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.

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

}

}

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() {};