Klassen und Methoden in Java

Wichtig für Smartphonebenutzer

Klassen sind wie Felder Referenzdatentypen. Eine Klasse ist sozusagen eine Ansammlung von Variablen von verschiedenen Datentypen, die Klasse kann auch Methoden enthalten (z.B. zur Manipulation des Inhalts der Variablen in der Klasse). Mit einer Klasse ist es uns möglich verschiedene Datentypen zu einer Komponentenvariable (Datentyp) zusammenzufügen. Diese Komponentenvariable bezeichnet man als Objekt oder Instanz.

Um es etwas verständlicher zu machen habe ich das Programm "Namensliste" neu geschrieben. Hier ist nun unser Programm:

1.  public class Namensliste {
3.         public static class Liste {
4.                 public String vorname;
5.                 public String nachname;
6.                 public String geburtsdatum;
7.         }
8.        
9.         public static void main(String[] args) {
10.                
11.                 // Erzeuge ein Objekt person
12.                 Liste person = new Liste();
13.                
14.                 // Initialisiere Werte
15.                 person.vorname = "Franz";
16.                 person.nachname = "Mustermaier";
17.                 person.geburtsdatum = "22.06.1976";
18.                
19.                 // Gib die Person auf der Konsole aus
20.                 System.out.println("Vorname     : "                                                      + person.vorname);
21.                 System.out.println("Nachname    : "                                                      + person.nachname);
22.                 System.out.println("Geburtsdatum: "                                                      + person.geburtsdatum);
23.                
24.         }
25.        
26. }

In dieser Zeile:

1. public static class Liste {

Erstellen wir die Klasse "Liste" das Schlüsselwort public steht für eine öffentliche Klasse, auf die jeder Zugriff hat. Da es eine innere Klasse ist. kann nur in der Klasse "Namensliste" darauf zugegriffen werden. Das Schlüsselwort static gibt dem Kompiler an dass es eine innere Klasse ist. Mit dem Schlüsselwort class und dem Bezeichner erstellen wir eine Klasse (Bei dem Bezeichner gelten alle Regeln wie bei den Variablenbezeichner auch, nur dass hier der Bezeichner mit einem Großbuchstaben beginnt. Die Variablen der Klasse stehen im zugehörigen Anweisungsblock {}.

In diesen Zeilen deklarieren wir die Objektvariablen der Klasse:

1. public String vorname;
2. public String nachname;
3. public String geburtsdatum;

Mit dem Schlüsselwort public sind die Variablen öffentlich, damit hat man außerhalb der Klasse die Möglichkeit die Werte der Variablen z.B. zu ändern.

Jetzt deklarieren und erzeugen mit dem new-Operator das Objekt "person".

1. Liste person = new Liste();

             
In den nächste Zeilen übergeben wir Werte an die Variablen des Objektes "person":

1. person.vorname = "Franz";
2. person.nachname = "Mustermaier";
3. person.geburtsdatum = "22.06.1976";

Mit dem Objektbezeichner gefolgt von dem .-Operator und dem Bezeichner der gewünschten Variable übergeben wir einen Wert mit dem =-Operator der Variable.

Hier geben wir die Werte auf der Konsole aus:

1. System.out.println("Vorname     : "                                                       + person.vorname);
2. System.out.println("Nachname    : "                                                      + person.nachname);
3. System.out.println("Geburtsdatum: "                                                      + person.geburtsdatum);

Eine Klasse verfügt immer über  einen Konstruktor (Default-Konstruktor), wenn wir keinen erstellen, erstellt der Compiler selber einen Default-Konstruktor. Im Konstruktor können wir z.B. Standardwerte initialisieren oder Objekte und Felder erzeugen. Erweitern wir unser Beispiel mit einem Default-Konstruktor:

1. ...
2. public String geburtsdatum;
3.                
4. public Liste() {
5.         vorname = "leer";
6.         nachname = "leer";
7.         geburtsdatum = "leer";
8. }
9. ...

Mit public geben wir an dass auf dem Konstruktor öffentlich ist und mit dem new-Operator darauf zugegriffen werden kann (ein Konstruktor wird nur einmal beim erzeugen des Objektes durch den new-Operator aufgerufen. Der Bezeichner des Konstruktors muss exakt den selben Bezeichner wie den der Klasse haben. In den beiden () steht die Parameterliste, weil es sich hier um den Default-Konstruktor handelt ist die Parameterliste leer.

Es wird schon aufgefallen sein, wenn ein Objekt erzeugt dass nach dem new-Operator der Konstruktor der Klasse steht.

Nehmen wir an, wir wollen unsere Klasse "Liste" in mehreren Programmen nutzen. Dann sollten wir diese in eine externe Datei schreiben. Dafür erstellen wir eine neu Datei im Projekt mit dem Klassennamen und kopieren unser Klasse Liste hinein:

1. public class Liste {
2.        
3.         public String vorname;
4.         public String nachname;
5.         public String geburtsdatum;
6.        
7.         public Liste() {
8.                 vorname = "leer";
9.                 nachname = "leer";
10.                 geburtsdatum = "leer";
11.         }
12. }

Da es jetzt keine innere Klasse ist, müssen wir das Schlüsselwort static vor class weg lassen.

Jetzt schreiben wir einen Konstruktor mit einer Parameterliste:

1. ...
2.         geburtsdatum = "leer";
3. }
4.        
5. public Liste(String vorname,
6.         String nachname, String geburtsdatum) {
7.         this.vorname = vorname;
8.         this.nachname = nachname;
9.         this.geburtsdatum = geburtsdatum;
10. }
11. ...

Nun haben wir einen Konstruktor mit drei Parameter. Wie wir sehen, haben die Parameter genau die selben Namen (Bezeichner) wie die Objektvariablen. Jetzt haben wir ein Problem, wie weiß der Compiler welche Variable gemeint ist? Mit dem this Schlüsselwort haben wir eine elegant Lösung. Das this Schlüsselwort zeigt immer auf das Objekt und damit ist es uns dann auch möglich die Variablen richtig zuzuweisen. Die Variablen in der Parameterliste sind nur im Anweisungsblock des Konstruktors gültig.

Jetzt bleibt es uns überlassen mit welchem Konstruktor wir das Objekt erzeugen:

1. Liste person = new Liste();

oder

1. Liste person = new Liste("Bernd", "Huber", "11.9.1955");

In der Objektorientierten Programmierung (OOP), ist es nicht gerne gesehen seine Objektvariablen öffentlich zu deklarieren, deshalb setzen wir alle drei Objektvariablen auf private. Damit kann man einen unbefugten Zugriff auf die Objektvariablen verhindern.

1. public class Liste {
2.        
3.         private String vorname;
4.         private String nachname;
5.         private String geburtsdatum;
6.                
7. ...

Damit wir jetzt außerhalb der Klasse auf die Variablen zugreifen können, müssen wir und die passenden get- und set-Methoden schreiben. Die get-Methode gibt die dazugehörige Variable des Objektes mit dem Schlüsselwort return zurück (mit return wird die Methode sofort beendet, deshalb sollte return immer am Ende des Methodenblocks sein). In der set-Methode wird ein Wert der dazugehörigen Variable des Objektes übergeben. Ergänzen wir unsere Klasse "Liste" damit:

1. ...
2.         this.geburtsdatum = geburtsdatum;
3. }
4.        
5. public String getVorname() {
6.         return vorname;
7. }
8.        
9. public void setVorname(String vorname) {
10.         this.vorname = vorname;
11. }
12.        
13. public String getNachname() {
14.         return nachname;
15. }
16.        
17. public void setNachname(String nachname) {
18.         this.nachname = nachname;
19. }
20.        
21. public String getGeburtsdatum() {
22.         return geburtsdatum;
23. }
24.        
25. public void setGeburtsdatum(String geburtsdatum) {
26.         this.geburtsdatum = geburtsdatum;
27. }
28.        
29. ...

Schauen wir uns eine get-Methode genauer an:

1. public String getVorname() {
2.         return vorname;
3. }

Mit dem Schlüsselwort public legen wir fest dass die Methode öffentlich ist. Wenn die Methode einen Rückgabewert haben soll, müssen wir den Datentyp angeben, hier ist es ein String. Bei einer Methode wie die set-Methode hat man keinen Rückgabewert und gibt dafür das Schlüsselwort void an. Der Methodenname sollte mit einem Kleinbuchstaben anfangen. Für eine get-Methode muss nicht unbedingt ein get am Anfang stehen, das Selbe gilt auch für die set-Methode, get und set dient nur um den Code übersichtlicher zu machen. Es wäre auch möglich "wievieleBratwürsteHabIch()" zu nennen. Eine Methode darf mehrere Werte in der Parameterliste enthalten, aber nur ein Rückgabewert.

Jetzt ändern wir noch den Code in der Klasse "Namensliste" ab damit der wieder kompatibel mit der Klasse "Liste" ist:

1. ...
2.                
3. // Erzeuge ein Objekt person
4. Liste person = new Liste();
5.                
6. // Initialisiere Werte
7. person.setVorname("Franz");
8. person.setNachname("Mustermaier");
9. person.setGeburtsdatum("22.06.1976");
10.                
11. // Gib die Person auf der Konsole aus
12. System.out.println("Vorname     : "                                                      + person.getVorname());
13. System.out.println("Nachname    : "                                                      + person.getNachname());
14. System.out.println("Geburtsdatum: "                                                       + person.getGeburtsdatum());
15.                
16. ...

Wie man sehen kann ist der Code mit get- und set-Methoden viel verständlicher geworden.

Jetzt wollen wir unser Programm eine Menü und eine Eingabeaufforderung spendieren. Da wir jetzt Klassen kennen schreiben wir uns gleich mal eine für die Eingabeaufforderung. Wir erstellen uns eine neue Klasse Namens "Input". Hier ist einfach mal der ganze Programmcode dazu:

1. import java.util.Scanner;
3. public class Input {
4.        
5.         // Mit private wird das Erzeugen eines
6.         // Objektes verhindert
7.         private Input() {
8.                 ;
9.         }
10.        
11.         // Scanner fängt die Tastatureingabe ab
12.         private static Scanner extrahieren() {
13.                 return new Scanner(System.in);
14.         }
15.                
16.         // Tastatureingabe wird als int übergeben
17.         public static int inputInt() {
18.                 return extrahieren().nextInt();
19.         }
20.        
21.         // Tastatureingabe wird als String übergeben
22.         public static String inputString() {
23.                 return extrahieren().nextLine();
24.         }
25.                
26. }

Als erstes fällt der leere Default-Konstruktor auf:

1. private Input() {

2. ;

3. }

Da ein Default-Konstruktor vom Compiler normalerweise einen öffentlichen Konstruktor mit public erzeugt, müssen wir uns einen Default-Konstruktor selber schreiben, da unserer Klasse kein Objekt erzeugt werden soll verwenden wir das Schlüsselwort private. Wenn der Konstruktor nicht öffentlich ist kann auch kein Objekt der Klasse "Input" mit dem new-Operator außerhalb der Klasse erzeugt werden.

1. private static Scanner extrahieren() {

2. return new Scanner(System.in);

3. }

Auf die Methode "extrahieren()" soll von außen nicht zugreifbar sein, deshalb verwenden wir wieder das Schlüsselwort private. Die Methode soll als Rückgabewert ein namenloses Objekt vom Datentypen Scanner zurückgeben. Dieses Objekt braucht keinen Bezeichner da es erzeugt wird und dessen Referenz einfach weiter übergeben wird und danach nicht mehr verwendet wird. Das Schlüsselwort static teilt dem Compiler mit dass die Methode eine Klassenmethode ist und kein Objektmethode ist. Bei Objektmethoden muss ein Objekt mit dem new-Operator erzeugt werden, um Zugriff auf die Methoden zu bekommen. Eine Klassenmethode wird durch die Klasse aufgerufen und nicht durch den Bezeichner des Objektes.

1. public static int inputInt() {

2. return extrahieren().nextInt();

3. }

Die beiden Methoden "inputInt()" und "inputString()" sind auch Klassenmethoden, auf die aber öffentlich zugegriffen werden kann. Der Rückgabewert ist ein int Wert oder ein String. Die Methode "extrahieren()" hat als Rückgabewert ein namenloses Objekt dessen Datentyp Scanner ist. Mit der Methode "nextInt()" oder "nextLine()" übergeben wir die Tastatureingabe als int-Wert oder String als Rückgabewert der Methoden "inputInt()" oder "inputString()".

Jetzt erstellen wir uns noch eine neue Klasse "Menue". Hier ist die gesamte Klasse "Menue":

1. public class Menue {
2.        
3.         // Deklariere ein Feld
4.         private Liste[] personen;
5.         // Deklariere ein Objekt
6.         private Liste person;
7.        
8.         // Default-Konstruktor
9.         public Menue() {
10.                 // Erzeuge ein Feld mit 100 Elementen
11.                 personen = new Liste[100];
12.                 // Initialisiert die Standardwerte der Felder
13.                 for(int i = 0; i < personen.length; i++) {
14.                         personen[i] = new Liste("--", "--", "--");
15.                 }
16.                 // Übergibt die Referenz des ausgewählten Feldes
17.                 // dem Objekt person
18.                 setPerson(personen[0]);
19.         }
20.        
21.         public boolean hauptMenue() {
22.                 // Gebe das Menü auf der Konsole aus          
23.                 System.out.println("+-----------------------+");
24.                 System.out.println("|     Namensliste       |");
25.                 System.out.println("+-+---------------------+");
26.                 System.out.println("|1| Namen eingeben      |");
27.                 System.out.println("|2| Namen anzeigen      |");
28.                 System.out.println("|3| Eintrag wechseln    |");
29.                 System.out.println("|4| Beenden             |");
30.                 System.out.println("+-+---------------------+");
31.                 System.out.print(" > ");
32.                 // Liest die Tastatureingabe aus und gibt den
33.                 // Rückgabewert der Methode pruefeEingabe
34.                 return pruefeEingabe(Input.inputInt()) ;
35.         }
36.        
37.         private boolean pruefeEingabe(int eingabe) {
38.                 // Entscheidungsanweisungen des Menüs
39.                 if(eingabe == 1) {
40.                         // Eingabe wird aufgerufen
41.                         namenEingabe();
42.                 }
43.                 else if(eingabe == 2) {
44.                         // Ausgabe wird aufgerufen
45.                         namenAusgabe();
46.                 }
47.                 else if(eingabe == 3) {
48.                         // Eintrag wird gewechselt
49.                         eintragWechseln();
50.                 }
51.                 else if(eingabe == 4) {
52.                         // Rückgabewert für die Hauptschleife
53.                         // mit dessen das Programm beendet wird
54.                         return false;
55.                 }
56.                 else {
57.                         // Bei fehlerhafter eingabe wird
58.                         // eine Warnung auf der Konsole ausgegeben
59.                         eingabeFehler();
60.                 }
61.                 // Rückgabewert für die Hauptschleife
62.                 // das Programm läuft weiter
63.                 return true;
64.         }
65.        
66.         private void namenEingabe() {
67.                 // Eingabe
68.                 System.out.println("-------------------------");
69.                 System.out.print("Vorname      : ");
70.                 person.setVorname(Input.inputString());
71.                 System.out.println("-------------------------");
72.                 System.out.print("Nachnamer    : ");
73.                 person.setNachname(Input.inputString());
74.                 System.out.println("-------------------------");
75.                 System.out.print("Geburtsdatum : ");
76.                 person.setGeburtsdatum(Input.inputString());
77.                 System.out.println("-------------------------");
78.         }
79.        
80.         private void namenAusgabe() {
81.                 // Ausgabe
82.                 System.out.println("-------------------------");
83.                 System.out.println("Vorname      : "                                                      + person.getVorname());
84.                 System.out.println("-------------------------");
85.                 System.out.println("Nachnamer    : "                                                     + person.getNachname());
86.                 System.out.println("-------------------------");
87.                 System.out.println("Geburtsdatum : "                                                      + person.getGeburtsdatum());
88.                 System.out.println("-------------------------");
89.         }
90.        
91.         private void eintragWechseln() {
92.                 // Wiederholungsanweisung für das Menüpunkt
93.                 // eintragWechseln
94.                 while (true) {
95.                
96.                         System.out.println("+-----------------------+");
97.                         System.out.println("|Es können Eintrage von |");
98.                         System.out.println("|1-100 ausgewählt werden|");
99.                         System.out.println("+-----------------------+");
100.                         System.out.print("> ");
101.                         int eingabe = (Input.inputInt());
102.                        
103.                         // Bei richtiger Eingabe wird die
104.                         // Wiederholungsanweisung mit brake
105.                         // verlassen
106.                         if (eingabe > 0 && eingabe < 100) {
107.                                 person = personen[eingabe-1];
108.                                 break;
109.                         }
110.                         // Bei fehlerhafter Eingabe wird eine
111.                         // Warnung auf der Konsole ausgegeben
112.                         else {
113.                                 eingabeFehler();
114.                         }
115.                 }
116.                                
117.         }
119.         private void setPerson(Liste person) {
120.                 // Referenz wird übergeben
121.                 this.person = person;
122.         }
124.         private void eingabeFehler() {
125.                 // Warnung wird in der Konsole ausgegeben
126.                 System.out.println("+-----------------------+");
127.                 System.out.println("|Fehler bei der Eingabe!|");
128.                 System.out.println("+-----------------------+");
129.         }
130. }

Gehen wir den Code einfach mal durch:

1. private Liste[] personen;

Hier deklarieren wir ein Feld mit private, in dem die Einträge gespeichert werden.

1. private Liste person;

In der Zeile deklarieren wir ein Objekt das auch private ist.

1. public Menue() {
2. 
   

   // Erzeuge ein Feld mit 100 Elementen

3.      personen = new Liste[100];
4.      // Initialisiert die Standardwerte der Felder
5.      for(int i = 0; i < personen.length; i++) {
6. 
   

        personen[i] = new Liste("--", "--", "--");

7.      }
8.      // Übergibt die Referenz des ausgewählten Feldes
9.      // dem Objekt person
10.      setPerson(personen[0]);
11. }

Im Default-Konstruktor wird in Zeile 3 für das Feld "personen" 100 Elemente mit dem new-Operator erzeugt. Da bisher die einzelnen Referenzen der Elemente des Feldes auf null zeigen (eine null-Referenz zeigt auf keinen Speicheradresse), wird mit der for-Wiederholungsanweisung den Referenzen eine Speicheradresse übergeben und Standardwerte initialisiert. In Zeile 10 wird dem Objekt "person" eine Referenz des Feldes "personen" durch die "setPerson()" Methode übergeben, mit dieser Methode wird das aktuelle Element festgelegt in dem die Eingaben übergeben werden sollen. Das Objekt "person" ist sozusagen zuständig die Eingaben in dem ausgewählten Element des Feldes "personen" zu übergeben.

1. public boolean hauptMenue() {
2. 
   

    // Gebe das Menü auf der Konsole aus          

3.       System.out.println("+-----------------------+");
4.       System.out.println("|     Namensliste       |");
5.       System.out.println("+-+---------------------+");
6.       System.out.println("|1| Namen eingeben      |");
7.       System.out.println("|2| Namen anzeigen      |");
8.       System.out.println("|3| Eintrag wechseln    |");
9.       System.out.println("|4| Beenden             |");
10.       System.out.println("+-+---------------------+");
11.       System.out.print(" > ");
12.       // Liest die Tastatureingabe aus und gibt den
13.       // Rückgabewert der Methode pruefeEingabe
14.       return pruefeEingabe(Input.inputInt()) ;
15. }

Die Methode" hauptMenue()" gibt das Menü auf der Konsole aus und erwartet eine Tastatureingabe. In Zeile 14 sind einige Informationen die auf Anhieb nicht gleich sichtbar sind. Mit "Input.inputInt()" erwarten wir einen Ganzzahligen Wert als Eingabe (wie wir sehen können ist diese Methode eine Klassenmethode, da wir sie mit dem Klassennamen gefolgt mit dem .-Operator und dem Methodennamen aufrufen. Wie wir wissen hat die" inputInt()" Methode einen Rückgabewert der der Methode "pruefeEingabe" durch die Parameterliste übergeben wird diese Methode hat den Rückgabewert boolean der gleichzeitig auch der Rückgabewert der Methode "hauptMenue()" ist.

1. private boolean pruefeEingabe(int eingabe) {
2.         // Entscheidungsanweisungen des Menüs
3.         if(eingabe == 1) {
4.                 // Eingabe wird aufgerufen
5.                 namenEingabe();
6.         }
7.         else if(eingabe == 2) {
8.                 // Ausgabe wird aufgerufen
9.                 namenAusgabe();
10.         }
11.         else if(eingabe == 3) {
12.                 // Eintrag wird gewechselt
13.                 eintragWechseln();
14.         }
15.         else if(eingabe == 4) {
16.                 // Rückgabewert für die Hauptschleife
17.                 // mit dessen das Programm beendet wird
18.                 return false;
19.         }
20.         else {
21.                 // Bei fehlerhafter eingabe wird
22.                 // eine Warnung auf der Konsole ausgegeben
23.                 eingabeFehler();
24.         }
25.         // Rückgabewert für die Hauptschleife
26.         // das Programm läuft weiter
27.         return true;
28. }

In der Methode "pruefeEingabe" wird die Variable aus der Parameterliste in einer if-Entscheidungsanweisung überprüft und bei zutreffenden Wert die dazugehörige Methode aufgerufen. Als Rückgabewert wird true zurückgegeben oder wenn die If-Anweisung den korrekten Wert in Zeile 15 erhält und damit den Rückgabewert false bekommt.

1. private void namenEingabe() {
2.         // Eingabe
3.         System.out.println("-------------------------");
4.         System.out.print("Vorname      : ");
5.         person.setVorname(Input.inputString());
6.         System.out.println("-------------------------");
7.         System.out.print("Nachnamer    : ");
8.         person.setNachname(Input.inputString());
9.         System.out.println("-------------------------");
10.         System.out.print("Geburtsdatum : ");
11.         person.setGeburtsdatum(Input.inputString());
12.         System.out.println("-------------------------");
13. }

In der Methode" namenEingeben()", werden nacheinander drei Eingabeauforderungen  in der Konsole erstellt. "Input.inputString()" gibt die Eingabe als String zurück, mit der set-Methode wird der String durch das Objektes "person" ein Element des Feldes "personen" übergeben, auf das die Referenz "person" zeigt.

1. private void namenAusgabe() {
2.         // Ausgabe
3.         System.out.println("-------------------------");
4.         System.out.println("Vorname      : " + person.getVorname());
5.         System.out.println("-------------------------");
6.         System.out.println("Nachnamer    : " + person.getNachname());
7.         System.out.println("-------------------------");
8.         System.out.println("Geburtsdatum : " + person.getGeburtsdatum());
9.         System.out.println("-------------------------");
10. }

Diese Methode gibt den Inhalt des aktuellen Elements durch das Objekt "person" aus.

1. private void eintragWechseln() {
2.         // Wiederholungsanweisung für das Menüpunkt
3.         // eintragWechseln
4.         while (true) {
5.        
6.                 System.out.println("+-----------------------+");
7.                 System.out.println("|Es können Eintrage von |");
8.                 System.out.println("|1-100 ausgewählt werden|");
9.                 System.out.println("+-----------------------+");
10.                 System.out.print("> ");
11.                 int eingabe = (Input.inputInt());
12.                
13.                 // Bei richtiger Eingabe wird die
14.                 // Wiederholungsanweisung mit brake
15.                 // verlassen
16.                 if (eingabe > 0 && eingabe < 100) {
17.                         person = personen[eingabe-1];
18.                         break;
19.                 }
20.                 // Bei fehlerhafter Eingabe wird eine
21.                 // Warnung auf der Konsole ausgegeben
22.                 else {
23.                         eingabeFehler();
24.                 }
25.         }
26. }

Durch die Methode "eintragWechseln()" wird eine Eingabeaufforderung in der Konsole erstellt. Eine If-Anweisung überprüft ob die Variable "eingabe" größer ist als 0 und kleiner als 101 ist, damit die Variable als Index des Feldes" personen" verwendet werden kann, wenn nicht wird eine Fehlermeldung auf der Konsole ausgegeben und die Eingabeaufforderung wird nochmal wiederholt. Weil der Index des Feldes "personen" mit 0 beginnt aber wir mit der 1 als ersten Eintrag angeben müssen wir bei der Indexangabe in Zeile 18 die Variable"eingabe" mit 1 subtrahieren, damit es keinen Fehler gibt.

1. private void setPerson(Liste person) {
2.      // Referenz wird übergeben
3.      this.person = person;
4. }
5. 
   

Die Methode "setPersonen()" übergibt dem Objekt "person"eine Referenz.

1. private void eingabeFehler() {
2.       // Warnung wird in der Konsole ausgegeben
3.       System.out.println("+-----------------------+");
4.       System.out.println("|Fehler bei der Eingabe!|");
5.       System.out.println("+-----------------------+");
6. }

Die Methode "eingabeFehler()" gibt eine Fehlermeldung auf der Konsole aus.

Jetzt ändern wir noch den Code in der Klasse Namensliste. Hier ist der Code:

1. public class Namensliste {
2.        
3.         public static void main(String[] args) {
4.                 // Deklariere Variable
5.                 boolean wiederholen = true;
6.                 // Deklariere und erzeuge eine Objekt
7.                 Menue menue = new Menue();
8.                
9.                 // Hauptschleife des Programms
10.                 while (wiederholen) {
11.                         // Menu auf der Konsole ausgeben
12.                         wiederholen = menue.hauptMenue();
13.                 }      
14.         }
15. }

In Zeile 5 wird eine Variable mit dem Datentyp boolean deklariert und mit true initialisiert. In der Zeile 7 wird das Objekt "menue" deklariert und initialisiert. Die while-Anweisung wird solange wiederholt, bis die Variable den Rückgabewert true von der Objektmethode "hauptMenue()" erhällt.

Jetzt haben wir unser Programm fertig und können es ausführen.