Wirtschaftsinformatik (Bachelor-Studiengang): Programmierung (1. Semester)
Sie sind hier: Startseite › Wirtschaftsinformatik › Programmierung Java (Kurs 1): Methoden, Parameter, Methodenrumpf
HB / CM, Kurs vom 01.04.2002 - 30.09.2002
Methoden
Die Deklaration von Methoden
Methoden legen das Verhalten der Objekte der Klassen
fest.
Methoden sind Operationen, die mit den Objekten der Klasse
ausgeführt werden.
- genauso, wie ×, ÷, + und − Operationen für ganze Zahlen oder Gleitkommazahlen sind
Bei den primitiven Datentypen sind die Operationen fest vorgegeben, bei Klassen können sie selbst gestaltet werden.
Jede Methode realisiert genau eine Operation. Komplexe Operationen sind gegebenenfalls so zu zerlegen, dass diese Aussage gilt.
Formal besteht die Deklaration von Methoden aus bis zu fünf Teilen:
- Methodenmodifizierer (kann fehlen)
- Ergebnistyp
- Signatur
throws
-Klausel (kann fehlen)- Methodenrumpf
Die Funktionsweise einer Methode kann man sich vorstellen, wie die eines Dienstleisters:
Bildbeschreibung "Methode": Input = Eingangsinformation (z.B. Informationen zur gesuchten Telefonnummer); Operationen = mit dem Input und lokaler Information wird genau eine Aufgabe erledigt (z.B. Finden der Telefonnummer); Output = Information als Ergebnis (z.B. Telefonnummer). Der Input enthält Methodenmodifizierer und teilweise Signatur, die Operationen bilden den Methodenrumpf und der Output stellt den Ergebnistypen dar.
Eine Methode hat entweder keinen Output oder genau einen.
Falls sie keinen hat, ist als Ergebnistyp
void
anzugeben. (void
Schlüsselwort
) Falls sie einen Output hat, ist als Ergebnistyp der Datentyp
dieses Wertes anzugeben.
Zulässig sind hierbei:
- alle primitiven Datentypen
- die Referenzdatentypen Array und Klasse
Die Signatur einer Methode besteht aus dem Namen der Methode und einer Parameterliste, die immer in runden Klammern zu stehen hat:
Methodenbezeichner(Parameterliste)
Der Methodenbezeichner kann frei gewählt. Empfehlung:
Verben!
Die Parameterliste kann fehlen.
Parameter
Die Parameter einer Methode dienen zur Aufnahme des
Input der Methode.
Wenn es keinen Input gibt,
dann kann die Parameterliste fehlen, die Klammer aber nicht!
Hinweis: Eine Parameterliste besteht aus einer oder mehreren Parameterdeklarationen. Wenn es mehrere sind, sind sie mit Komma zu trennen!
Jede Parameterdeklaration muss folgende Gestalt haben:
final
(kann fehlen)- Datentyp
- Bezeichner
Zulässige Datentypen sind alle primitiven Datentypen,
Klassen und Arrays. Der
Modifizierer final
hat zur Folge, dass der an den
Parameter übergebende Wert im Rumpf der Methode nicht
geändert werden kann.
Die Anzahl Parameter einer Methode ist im Prinzip beliebig, in der Praxis gibt es aber meistens maximal sieben.
Datentypen können beliebig gemischt werden.
Alle Parameter einer Methode müssen unterschiedliche Bezeichner haben.
Innerhalb einer Klasse darf es nicht zwei Methoden mit gleicher Signatur geben. Es ist aber möglich, sogar sehr häufig, dass mehrere gleichnamige Methoden einer Klasse vorhanden sind. Sie müssen sich in der Anzahl und der Art der Parameter unterscheiden. Man spricht "vom Überladen von Methoden" (overloading: wichtiges Konzept der objektorientierten Programmierung).
Methodenmodifizierer können in zwei Gruppen eingeteilt werden:
- Zugriffsmodifizierer
public
(im Normalfall verwendet)protected
(bei Vererbung relevant)private
(für "Hilfsmethoden", die nur von der eigenen Klasse benutzt werden)
- sonstige
abstract
static
final
synchronized
(bei Parallelverarbeitung benutzt)nativ
(nicht benötigt, ermöglicht Mitverwendung von anderen Programmiersprachen)strictfp
(leicht veränderte Art der Speicherung (Rundung) von Gleitkommazahlen)
Methoden, die als static
deklariert werden,
können auch dann aktiviert werden, wenn es noch keine
Objekte der Klasse gibt. Man spricht (daher) von
Klassenmethoden (im Gegensatz zu
Objektmethoden).
Die Methode main
muss immer
static
sein.
Wenn eine Klassenmethode eine andere Methode aktiviert, muss diese auch eine Klassenmethode sein.
Wenn eine Klassenmethode auf ein Attribut zugreift, muss dieser
ebenfalls static
sein.
Java-Beispiel: Demo6
class Demo6
{
private String artikelName;
private double artikelPreis;
private int artikelNr;
private int anzahl;
private static int naechsteArtikelNr = 100000;
Demo6(String name, double preis, int wieviel)
{
artikelName = name;
artikelPreis = preis;
anzahl = wieviel;
}
String liefereArtikelName()
{
return artikelName;
}
double liefereArtikelPreis()
{
return artikelPreis;
}
int liefereArtikelNr()
{
return artikelNr;
}
int liefereAnzahl()
{
return anzahl;
}
void setzeArtikelNr()
{
artikelNr = naechsteArtikelNr;
naechsteArtikelNr++;
}
static int liefereNaechsteArtikelNr()
{
return naechsteArtikelNr;
}
}
Beim Aktivieren von Klassenmethoden ist der Name der Klasse voranzustellen:
Java-Beispiel: Demo6Main
class Demo6Main
{
public static void main(String[] args)
{
Demo6 artikel1 = new Demo6("Goldener Feuerberg", 6.45, 20);
artikel1.setzeArtikelNr();
Demo6 artikel2 = new Demo6("Lauffener Gutedel", 3.14, 37);
artikel2.setzeArtikelNr();
Demo6 artikel3 = new Demo6("Goldener Feuerberg", 5.97, 73);
artikel3.setzeArtikelNr();
info(artikel1);
info(artikel2);
info(artikel3);
System.out.print("Naechste verfuegbare Artikelnummer: ");
System.out.println(Demo6.liefereNaechsteArtikelNr());
}
private static void info(Demo6 x)
{
double wert;
System.out.println("Artikelnummer: " + x.liefereArtikelNr());
System.out.println(x.liefereArtikelName());
System.out.println("Stueckpreis: " + x.liefereArtikelPreis());
System.out.println("Stueckzahl: " + x.liefereAnzahl());
wert = x.liefereAnzahl() × x.liefereArtikelPreis();
System.out.println("Gesamtwert: " + wert + "Euro\n");
}
}
Methodenrumpf
Der Methodenrumpf muss entweder
- nur aus einem Semikolon bestehen (nur:
abstract
/native
) oder - aus einem Block
Block:
Ein Block hat immer folgende Gestalt:
Bildbeschreibung "Block": Ein Block ist
eine Ansammlung aufeinander folgender Anweisungen. Beispiel:
{ Anweisung 1 ... Anweisung N }
.
In Java gibt es drei Arten von Anweisungen:
- Anweisungen zur Deklaration von Variablen
- gewöhnliche Anweisungen
- Anweisungen zur Deklaration lokaler Klassen
Sie können (fast) beliebig gemischt werden. Dabei ist zu beachten, dass Variablen oder Objekte erst ab ihrer Deklaration bis zum Ende des Blocks benutzt werden können.
Anweisungen zur Deklaration von Variablen
... müssen folgende Gestalt haben:
Variablendeklaration;
Beispiel: Demo6Main
double wert;
Eine einfache Variablendeklaration sieht genauso aus wie eine Parameterdeklaration:
final (kann fehlen) Datentyp
Bezeichner
Beispiel: Demo5Main
double wert;
Demo6 x;
Zulässige Datentypen sind
- alle primitiven Datentypen
- die Referenzdatentypen Array und Klasse
Der Modifizierer final
hat zur Folge, dass der
zugehörigen Variablen nur einmal ein Wert
zugewisen werden kann
- entweder durch Initialisierung oder
- durch spätere Wertzuweisung.
Hinweis: Jeder Versuch einer weiteren Wertzuweisung ist ein Fehler!
Programmierregel: Es ist üblich, als
final
deklarierte Variablen,
die initialisiert werden, vollständig groß zu schreiben.
Java-Beispiel: Demo7Main
class Demo7Main
{
public static void main(String[] args)
{
finalTest();
}
static void finalTest()
{
final int MAX_WERT = 100;
final double faktor;
System.out.println("Maxwert: " + MAX_WERT);
// System.out.println("Maxwert: " + faktor); Fehler: fehlender Wert
faktor = 1.95583; //Okay!
System.out.println("Maxwert: " + faktor);
// faktor = 1.0; Fehler: faktor ist final
}
}
Mit einer Variablendeklaration können gleichzeitig mehrere Variablen deklariert werden. Sie sind durch Kommata zu separieren.
Beispiel: So möglichst nicht!
int x, y, wert1, wert2;
Es ist möglich, Variablen im Rahmen ihrer Deklaration mit einem Initialwert (Anfangswert) zu versehen.
final (kann fehlen) Datentyp
Bezeichner = Ausdruck;
Innerhalb einer Variablendeklaration können initialisierte und nicht-initialisierte Variablen gemischt werden:
int x, y, wert1 = 100, wert2;
Hinweis: Der Versuch innerhalb des Geltungsbereiches einer Variablen eine gleichnamige zweite Variable zu deklarieren, führt zu einem Fehler!
Falls eine Variable einer Methode einer Klasse denselben Namen hat wie ein Attribut der Klasse, dann kann auf das Attribut innerhalb der Methode (ab dieser Variablen) nicht mehr zugegriffen werden.
Java-Beispiel: Xyz
class Xyz
{
private int i = 100; // Achtung: erstes mal i
void schreibe()
{
int i = 2; // Achtung: zweites mal i
double x = 6.4;
double y = Math.sqrt(i × x) + i;
System.out.println(y); // Ausgabe: 5.5777087
System.out.println(i); // Ausgabe: 2 (!!!)
}
}
Man sagt, dass das Attribut durch die (gleichnamige) lokale Variable ausgeblendet wird. (Möglichst vermeiden!!!)