Wirtschaftsinformatik (Bachelor-Studiengang): Programmierung (1. Semester)

Sie sind hier: StartseiteWirtschaftsinformatikProgrammierung Java (Kurs 1): Methoden, Parameter, Methodenrumpf

HB / CM, Kurs vom 01.04.2002 - 30.09.2002

Programmierung Java (Kurs 1): Methoden, Parameter, Methodenrumpf: Methoden (Die Deklaration von Methoden, Parameter, Methodenrumpf, Anweisungen zur Deklaration von Variablen).

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.

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:

  1. Methodenmodifizierer (kann fehlen)
  2. Ergebnistyp
  3. Signatur
  4. throws-Klausel (kann fehlen)
  5. Methodenrumpf

Die Funktionsweise einer Methode kann man sich vorstellen, wie die eines Dienstleisters:

Methode

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:

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:

  1. final (kann fehlen)
  2. Datentyp
  3. 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:

  1. Zugriffsmodifizierer
    • public (im Normalfall verwendet)
    • protected (bei Vererbung relevant)
    • private (für "Hilfsmethoden", die nur von der eigenen Klasse benutzt werden)
  2. 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.

Quelltext überspringen

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:

Quelltext überspringen

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

Block:

Ein Block hat immer folgende Gestalt:

Block

Bildbeschreibung "Block": Ein Block ist eine Ansammlung aufeinander folgender Anweisungen. Beispiel: { Anweisung 1 ... Anweisung N }.

In Java gibt es drei Arten von Anweisungen:

  1. Anweisungen zur Deklaration von Variablen
  2. gewöhnliche Anweisungen
  3. 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

Der Modifizierer final hat zur Folge, dass der zugehörigen Variablen nur einmal ein Wert zugewisen werden kann

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.

Quelltext überspringen

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.

Quelltext überspringen

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!!!)