Klassenmethoden
Häufig verwendete Algorithmen werden zu so genannten Methoden zusammengefasst, die unter Nennung ihres Namens und ggf. mit Übergabe von aktuellen Parametern aufgerufen werden.
Methoden sind entweder objektbezogen (siehe später) oder klassenbezogen. Klassenbezogene Methoden werden durch das Schlüsselwort static deklariert und können innerhalb oder außerhalb derselben Klasse aufgerufen werden. Die Zugriffsrechte werden über sogenannte Modifizierer geregelt. Mit dem Modifizierer private wird der Zugriff nur von der eigenen Klasse ermöglicht, mit dem Modifizierer public darf von einer beliebigen anderen Klasse zugegriffen werden.
Gibt eine Methode einen Wert zurück, so steht sein Typ vor dem Methodennamen, andernfalls steht dort void. Als Aufrufmechanismus wird in der Programmiersprache Java call-by-value verwendet. D.h., ein im Methodenrumpf benutzter formaler Parameter wird beim Methodenaufruf mit dem Wert des aktuellen Parameters versorgt und innerhalb der Methode kann nur auf den Wert, nicht auf den ursprünglichen Speicherbereich, zugegriffen werden.
Methoden können durch verschiedene Parametersätze überladen werden, d.h. der Name einer Methode wird mehrmals verwendet, wobei sich die formalen Parameter unterscheiden müssen. Die Kombination aus Methodenname und den formalen Parametern bezeichnet man auch als Signatur einer Methode. - Der Rückgabedatentyp zählt nicht zur Signatur.
Eine mit dem Schlüsselwort static versehene Deklaration einer Klassenvariablen führt eine klassenbezogene Variable ein, welche in allen Methoden dieser Klasse sichtbar ist. Auch eine Klassenvariable kann mit unterschiedlichen Modifizierern versehen werden. Mit dem Modifizierer private wird der Zugriff nur von der eigenen Klasse ermöglicht, mit dem Modifier public darf auch von einer beliebigen anderen Klasse zugegriffen werden.
Methodenaufrufe
Die Implementierung von Methoden hat einen ganz entscheidenden Einfluss auf das Design einer Anwendung. Wenn immer Sie eine klar identifizierbare Aufgabe in Ihren Programmcodes erkennen, sollten Sie diese als eigenständige Methode implementieren!
Das Programm Methods.java definiert einige beispielhafte Methoden, um deren Syntax und Nutzung zu zeigen.
import StdLib.StdIn;
import StdLib.StdOut;
/**
* Demonstration der Definition und Nutzung statischer Methoden.
*/
public class Methods {
/**
* Ausgabe einer Eingabeaufforderung.
*/
private static void prompt() {
StdOut.print("Bitte eine ganze Zahl: ");
}
/**
* Interaktives Einlesen einer ganzen Zahl.
*
* @return eingelesene Zahl
*/
private static int inputInt() {
prompt();
return StdIn.readlnInt();
}
/**
* Ausgabe einer Anzahl von Sternen.
*
* @param n Anzahl der Sterne
*/
public static void printStars(int n) {
for (int i = 0; i < n; i++)
StdOut.print("*");
StdOut.println();
}
/**
* Ausgabe einer Anzahl von Sternen unter Nutzung
* von aufgerufenen Methoden.
*
* @param args nicht genutzt
*/
public static void main(String[] args) {
StdOut.println("n Sterne ausgeben:");
int n = inputInt();
printStars(n);
}
}Methoden strukturieren den Programmcode in kleine Funktionseinheiten, die jeweils eine bestimmte Aufgabe erfüllen. Der Code wird dadurch übersichtlicher und ist einfacher zu warten. Methoden können nicht nur innerhalb eines Programms von verschiedenen Stellen im Code aufgerufen (wiederverwendet) werden, sie können sich untereinander aufrufen. Wenn der jeweilige Zugriffsmodifizierer es erlaubt, kann eine Methode auch von anderen Klassen genutzt werden.
Die Methode printStars() im obigen Beispiel ist öffentlich. Das bedeutet, dass andere Klassen (Programme) darauf zugreifen können.
Unter der Voraussetzung, Methods.java und PrintStars.java befinden sich im gleichen Verzeichnis, kann die Klasse PrintStars auf die öffentliche Methode printStars() von Methods zugreifen und sie aufrufen.
/**
* {@code PrintStars} demonstriert den Aufruf der
* Methode {@link Methods#printStars} in der Klasse
* {@link Methods}.
*/
public class PrintStars {
/**
* {@link Methods#printStars} aufrufen und ausführen.
*
* @param args nicht genutzt
*/
public static void main(String[] args) {
for (int i = 1; i <= 10; i++)
// verwende printStars() aus Methods
Methods.printStars(i);
}
}Parameterübergabe via call-by-value
Bereits eingangs habe ich Wertübergabe (call-by-value) dahingehend erläutert, dass eine Methode lediglich den Wert eines Parameters erhält. Wir müssen uns darüber Klarheit verschaffen, was das bedeutet. Hierzu haben wir zwischen primitiven Datentypen und Referenzdatentypen zu differenzieren.
Wertübergabe bei primitiven Datentypen
import StdLib.StdOut;
/**
* {@code SwapImpossible} zeigt, dass Methoden keine
* Werte primitiver Datentypen manipulieren können.
*/
public class SwapImpossible {
private static void swap(int a, int b) {
StdOut.printf("swap - a: %2d, b: %2d\n", a, b);
int tmp = a;
a = b;
b = tmp;
StdOut.printf("swap - a: %2d, b: %2d\n", a, b);
}
/**
* Der Versuch, {@code int}-Werte in einer aufgerufenen
* Methode zu modifizieren, gelingt nicht.
*
* @param args nicht genutzt
*/
public static void main(String[] args) {
int x = 1, y = 42;
StdOut.printf("main - x: %2d, y: %2d\n", x, y);
StdOut.println("... versuche zu tauschen ...");
swap(x, y);
StdOut.printf("main - x: %2d, y: %2d\n", x, y);
}
}Aufgrund der Wertübergabe erhält swap() nur die Werte von x und y, arbeitet also auf einer Kopie. Ein Vertauschen der Variableninhalte von x und y ist daher nicht möglich.
Merke: In Java können keine Methoden implementiert werden, die primitive Übergabeparameter für den Aufrufer modifizieren!
Wertübergabe bei Referenzdatentypen
Bei Referenzdatentypen, wie beispielsweise einem Array sieht das anders aus. Sie erinnern sich: Eine Array-Variable ist eine Referenz auf einen Speicherbereich, in welchem die Daten des jeweiligen Arrays abgelegt sind.
Bei der Wertübergabe wird nicht das Array als solches übergeben, es wird der Wert der Array-Variablen übergeben. Das ist lediglich eine Speicheradresse. Auf üblichen Computersystem sind das 64 Bits. Weil es sich um eine Speicheradresse handelt, bekommt die Methode Zugriff auf den Speicherbereich. Den kann sie dann ändern.
In Bezug auf Referenzdatentypen ist die so realisierte Wertübergabe sowohl Fluch als auch Segen. Auf der einen Seite müssen wir Obacht geben, als Seiteneffekt nicht aus Versehen, ein Referenzobjekt (hier ein Array) zu verändern. Auf der anderen Seite erspart es uns, große Datenmengen „in eine Methode zu kopieren”. Auch die Übergabe riesiger Arrays mit einer Million und mehr Datensätzen reduziert sich auf die Übergabe einer Speicheradresse.
import StdLib.StdOut;
/**
* {@code SwapPossible} zeigt, dass Methoden Werte
* von veränderbaren Referenzdatentypen manipulieren können.
*/
public class SwapPossible {
private static void printArray(int[] a) {
for (int i = 0; i < a.length; i++)
StdOut.printf("%3d ", a[i]);
StdOut.println();
}
private static void swap(int[] a, int i, int j) {
StdOut.print("swap - a: "); printArray(a);
int tmp = a[i];
a[i] = a[j];
a[j] = tmp;
StdOut.print("swap - a: "); printArray(a);
}
/**
* Der Versuch, die Werte in einem {@code int}-Array in einer
* aufgerufenen Methode zu modifizieren, gelingt.
*
* @param args nicht genutzt
*/
public static void main(String[] args) {
int[] x = {1, 2, 3, 4};
StdOut.print("main - x: "); printArray(x);
StdOut.println("... tausche Position 1 und 3 ...");
swap(x, 0, 3);
StdOut.print("main - x: "); printArray(x);
}
}Achtung: Referenzdatentypen sind nicht zwangsläufig veränderlich (mutable). Der Datentyp String ist unveränderlich (immutable). Das ist eine Java-Designentscheidung. Alle nicht veränderlichen Datentypen können, analog zu den primitiven Datentypen, in Methoden nicht modifiziert werden. Zwar wird auch bei Ihnen nur eine Kopie der Speicheradresse an eine Methode übergeben, sodass theoretisch auf den Speicherbereich des Objekts zugegriffen werden könnte, das ist jedoch aufgrund des Designs, wie solche Datentypen konstruiert sind, nicht möglich.
Sichtbarkeit
Innerhalb einer Methode verdecken formale Parameter und lokale Variablen gleichlautende Identifizierer aus der umschließenden Klasse. So kann ein Variablenname mehrmals innerhalb einer Klasse erscheinen, z.B. als Klassenvariable, lokale Variable oder als formaler Parameter.
Soll innerhalb einer Methode auf eine Variable zugegriffen werden, wird diese erst innerhalb der Methode gesucht (lokale Variable oder formaler Parameter). Ist dort die entsprechende Variable nicht vorhanden wird nach einer entsprechenden Klassenvariable gesucht.
import StdLib.StdOut;
/**
* Demonstration von Sichtbarkeiten innerhalb einer Klasse.
*/
public class Visibility {
public static int V; // Klassenvariable V
public static void V() { // Klassenmethode V
V = 42; // referenziert klassenbezogenes V
}
public static int V(int n) {
int V = 1; // lokales V verdeckt klassenbezogenes V
for (int i = 1; i <= n; i++)
V *= i;
return V;
}
public static void set(int newValue) {
V = newValue; // verändert klassenbezogenes V
}
public static int get() {
return V; // klassenbezogenes V liefern
}
/**
* Treiber-Methode, um die Sichtbarkeiten auf den Ebenen Klasse
* (Klassenvariablen) und Methoden (lokale Variablen, Parameter)
* zu zeigen.
*
* @param args nicht genutzt
*/
public static void main(String[] args) {
int V = 5; // lokale V
StdOut.println(V); // lokales V ausgeben
V(); // klassenbezogenes V auf 42 setzen
StdOut.println(get()); // klassenbezogenes V ausgeben
StdOut.println(V(V)); // V(5) - lokales V wird übergeben
set(21); // klassenbezogenes V auf 21 setzen
StdOut.println(get()); // globales V ausgeben
}
}Die Regeln zur Sichtbarkeit sind in Java streng aber intuitiv verständlich. Dennoch sollte man sich als Programmierer bemühen, klare Bezeichner für Variablen und Methoden zu benutzen. Das obige Beispielprogramm erfordert viel Konzentration, um es korrekt nachzuvollziehen. - Es ist insoweit ein klassisches Beispiel für schlechten und unübersichtlichen Code, was hier aber beabsichtigt ist, um Ihnen sie Sichtbarkeitsbereiche und deren Abgrenzung demonstrieren zu können.
Fehlerbehandlung
Generell ist jeder Programmierer verpflichtet seine Methoden robust zu implementieren. Darunter versteht man, dass eine Methode mit allen Werten, die ihr übergeben werden können, sinnvolle Resultate liefert.
Man betrachte folgende Klassenmethode faculty(), die alle positiven Zahlen von 1 bis zum übergebenen Wert aufmultipliziert und das Ergebnis zurückliefert.
public static int faculty(int n) {
int f = 1;
for (int i=1;i<=n;i++)
f = f * i;
return f;
} Falls für n ein Wert kleiner als 0 übergeben wird, liefert die Methode das (offenbar falsche) Ergebnis 1 zurück. Falls für n ein zu großer Wert übergeben wird, entsteht ein Integer-Overflow. Korrekt wäre es, wenn die Methode dem Benutzer mitteilen könnte, ob der übergebene Parameter im korrekten Wertebereich liegt. Dies könnte über den Rückgabewert geschehen (z.B. -1); besser ist es jedoch, das Ergebnis der Berechnung von der Fehlermeldung zu trennen. Hierzu kann in Java eine Methode eine RuntimeException werfen. Wird diese RuntimeException nicht weiter behandelt, führt sie zu einem Programmabbruch. Dies ist eine recht drastische Maßnahme. Allerdings ist ein Programmabbruch immer noch besser als eine Berechnung mit fehlerhaften Werten, ohne dies dem Benutzer mitzuteilen.
Die Fehlerbehandlung mit einer RuntimeException kann wie folgt aussehen.
public static int faculty(int n) {
if (n < 0) throw new RuntimeException("Fehler: Parameter negativ");
if (n > 12) throw new RuntimeException("Fehler: Parameter zu groß");
int f = 1;
for (int i=1;i<=n;i++)
f = f * i;
return f;
} Bei der Erzeugung einer RuntimeException kann eine Fehlermeldung angegeben werden. Diese wird bei Programmabbruch auf der Konsole ausgegeben. Die erzeugte Ausnahme vom Typ RuntimeException wird dann mit dem Schlüsselwort throw aus der Methode zum Aufrufer der Methode geworfen und die Abarbeitung der Methode endet an dieser Stelle.
Generell sollte eine Methode fehlerhafte Eingaben ablehnen, aber auch der Benutzer der Methode sollte vorher sicherstellen, dass erst gar keine fehlerhaften Werte an eine Methode übergeben werden.
Hinweis: RuntimeException ist eine sehr allgemeine Ausnahme. Java kann verschiedenste Arten von Ausnahmen differenzieren. Mithilfe der objektorientierten Programmierung (dazu später) können wir sogar eigene problemspezifische Ausnahmen definieren.