Rückblick
Methoden bringen keine neue Fähigkeit – alles, was du mit ihnen schreibst, ginge auch ohne. Sie bringen Ordnung. Und Ordnung ist der Unterschied zwischen einem Programm, das man nach zwei Wochen noch ändern kann, und einem, das man wegwirft.
Das kann ich jetzt
- Ich kann eigene Methoden mit und ohne Parameter schreiben und aufrufen. (4.1)
- Ich kann Methoden mit Rückgabewert schreiben und den Unterschied zu
voiderklären. (4.2) - Ich weiß, was Überladen bedeutet und wonach Java die passende Methode auswählt. (4.2)
- Ich erkenne, wann ein Stück Programm eine eigene Methode werden sollte. (4.3)
- Ich kann begründen, warum eine Methode besser einen Zweck hat als drei. (4.3)
Gemischte Aufgaben
Aufgabe 1: Was gibt das Programm aus?
void main() {
int zahl = 5;
verdopple(zahl);
IO.println("nach verdopple: " + zahl);
zahl = gibVerdoppelt(zahl);
IO.println("nach gibVerdoppelt: " + zahl);
IO.println(rechne(3, 4));
IO.println(rechne(3.0, 4.0));
}
void verdopple(int pZahl) {
pZahl = pZahl * 2;
}
int gibVerdoppelt(int pZahl) {
return pZahl * 2;
}
int rechne(int pA, int pB) {
return pA + pB;
}
double rechne(double pA, double pB) {
return pA * pB;
}a) Sag die vier Ausgabezeilen voraus.
b) Warum ändert verdopple den Wert von zahl nicht? Erkläre mit dem Wort Kopie.
c) Woran entscheidet Java, welche der beiden rechne-Methoden aufgerufen wird?
d) Was passierte, wenn die zweite rechne-Methode int rechne(int pA, int pB) mit double-Rückgabe hieße?
Aufgabe 2: Vier Methodenköpfe beurteilen
Sag für jede Methode: Ist sie richtig? Wenn nicht, was fehlt?
// a)
int quadrat(int pZahl) {
IO.println(pZahl * pZahl);
}
// b)
void groesser(int pA, int pB) {
if (pA > pB) {
return pA;
}
return pB;
}
// c)
int maximum(int pA, int pB) {
if (pA > pB) {
return pA;
}
}
// d)
double mittelwert(int pA, int pB) {
return (pA + pB) / 2;
}Eine der vier übersetzt fehlerfrei und liefert trotzdem falsche Werte. Welche, und warum?
Tipp zu d)
Setz pA = 3 und pB = 4 ein und rechne von Hand nach, in welcher Reihenfolge Java arbeitet. Welchen Typ hat der Ausdruck in der Klammer?
Aufgabe 3: Ein Programm aufräumen
Dieses Programm funktioniert, ist aber schlecht gebaut.
void main() {
IO.println("=================");
IO.println(" Notenspiegel ");
IO.println("=================");
int p1 = 88;
double n1 = 1.0 + 5.0 * (100 - p1) / 100.0;
IO.println("Amira: " + p1 + " Punkte, Note " + n1);
int p2 = 64;
double n2 = 1.0 + 5.0 * (100 - p2) / 100.0;
IO.println("Ben: " + p2 + " Punkte, Note " + n2);
int p3 = 41;
double n3 = 1.0 + 5.0 * (100 - p3) / 100.0;
IO.println("Chiara: " + p3 + " Punkte, Note " + n3);
IO.println("=================");
}a) Nenne die drei Stellen, an denen sich etwas wiederholt.
b) Bau das Programm um: Schreib eine Methode für die Notenberechnung, eine für die Ausgabe einer Zeile und eine für die Trennlinie. Das Hauptprogramm soll danach höchstens acht Zeilen lang sein.
c) Die Notenformel soll geändert werden: Ab jetzt gibt es für 100 Punkte die Note 1,0 und für 0 Punkte die Note 6,0. An wie vielen Stellen musst du in deiner Fassung ändern, an wie vielen in der ursprünglichen?
d) Erkläre an diesem Beispiel, was mit „eine Methode hat genau einen Zweck" gemeint ist.
Tipp 1: Welche Methoden?
Drei Köpfe, mehr brauchst du nicht:
double berechneNote(int pPunkte) { ... }
void zeigeZeile(String pName, int pPunkte) { ... }
void zeigeTrennlinie() { ... }Überleg bei jedem: Welche Angaben braucht die Methode von außen? Genau die werden Parameter.
Tipp 2: Wer ruft wen?
zeigeZeile braucht die Note – aber sie soll sie nicht selbst ausrechnen, sondern berechneNote aufrufen. Methoden dürfen einander benutzen, und genau dadurch bleibt jede einzelne kurz.