🔧

Methoden – Schreibtischtest

Informatik · Gymnasium · Klassen 9–13 · PRIMM-Methode

Methoden Interaktiv Kl. 9–13

🎯 Worum geht's? Klasse 10–13 · 1 Unterrichtsstunde

Nach dieser Seite kannst du …

verfolgen, welche Werte als Parameter an eine Methode übergeben werden
den Rückgabewert einer Methode bestimmen
den Programmablauf mit mehreren Methodenaufrufen nachvollziehen

Vorwissen: Variablen, Bedingungen, Schleifen

📝 Aufgaben

Jede Aufgabe hat fünf Schritte: Predict › Run › Investigate › Modify › Make. Wähle eine Aufgabe aus – oder nutze oben die Leiste „Aufgaben: 1, 2, 3 …“.

0

⚡ XP

0

✅ Gelöst

0

🔥 Streak

–

🎯 Genauigkeit

📖 Themenübersicht

Konzept	Beispiel	Bedeutung
Methodensignatur	`int add(int a, int b)`	Rückgabetyp, Name, Parameterliste
void-Methode	`void drucke(String s)`	Kein Rückgabewert
return	`return x * 2;`	Gibt Wert zurück, beendet Methode
Aktualparameter	`add(3, 7)`	Werte beim Aufruf
Formalparameter	`int a, int b`	Namen in der Definition
Call-by-Value	`f(x)` – x bleibt unverändert	Kopie wird übergeben
Überladen	`add(int,int)` und `add(double,double)`	Gleicher Name, andere Parameter
Rekursion	`f(n) = n * f(n-1)`	Methode ruft sich selbst auf
Lokale Variable	`int x = 5;` (in Methode)	Nur im eigenen Block sichtbar
Globale Variable	`static int z;` (in Klasse)	In allen Methoden sichtbar

🏅 Zuletzt verdiente Badges

🔮 Predict

Aufgabe 1 – Methodensignaturen lesen

💡 Aufbau einer Methodensignatur

Rückgabetyp methodenName ( Typ param1, Typ param2, … )

Der Rückgabetyp steht ganz links. void bedeutet: kein Rückgabewert. Die Parameterliste enthält immer Typ und Name.

Welchen Rückgabetyp hat double berechne(int n, double x)?

Wie viele Parameter hat void druckeMatrix(int[][] m, boolean header)?

Welche Signatur ist in Java ungültig?

▶️ Run – Signatur zuordnen

Trage für jede Methode den korrekten Rückgabetyp und die Anzahl der Parameter ein.

Signatur	Rückgabetyp	Anzahl Param.
int max(int a, int b)
void reset()
String join(String a, String b, char sep)
boolean istPrim(int n)
double[] normiere(double[] v)

Der Rückgabetyp ist das erste Wort. Kommas trennen Parameter – zähle die Kommas + 1 (außer bei void mit leerem ()).

🔍 Investigate

Darf eine Methode denselben Namen wie ein Parameter haben?

Was ist der Unterschied zwischen Signatur und Kopf einer Methode?

✏️ Modify

Die Signatur ist falsch. Korrigiere Rückgabetyp und Parameternamen so, dass die Methode zwei int-Werte addiert und das Ergebnis zurückgibt.

void add(int, int) {   // Signatur korrigieren
    return a + b;
}

Eine Methode, die etwas zurückgibt, braucht statt void einen Rückgabetyp. Jeder Parameter braucht Typ und Namen.

🛠️ Make

Schreibe die vollständige Signatur und Implementierung von potenz: Basis (double) hoch Exponent (int), Rückgabe double. Für potenz(2.0, 3) → 8.0.

// Implementierung hier

Rückgabetyp double, Parameter double basis, int exp. Starte mit 1 und multipliziere exp-mal mit der Basis.

🔮 Predict

Aufgabe 2 – Rückgabewerte

Aufruf: int r = geheim(12); – Welchen Wert hat r?

▶️ Run – Rückgabe-Trace

Bestimme den Rückgabewert für jeden Aufruf.

Aufruf	Rückgabewert
geheim(1)
geheim(6)
geheim(10)
geheim(15)
geheim(20)

Zähle für jede Zahl, durch welche Zahlen von 1 bis n sie ohne Rest teilbar ist.

🔍 Investigate

Was passiert, wenn eine nicht-void-Methode kein return hat?

Darf nach einem return noch Code stehen?

✏️ Modify

Ergänze ein frühzeitiges return: Wenn n <= 0, soll sofort 0 zurückgegeben werden.

int geheim(int n) {
    // früh zurückgeben wenn n <= 0
    int count = 0;
    for (int i = 1; i <= n; i++) {
        if (n % i == 0) count++;
    }
    return count;
}

Ganz am Anfang der Methode: Wenn n kleiner oder gleich 0 ist, sofort mit return zurückgeben.

🛠️ Make

Implementiere stellenSumme: Gibt die Quersumme einer nicht-negativen ganzen Zahl zurück. stellenSumme(123) → 6.

int stellenSumme(int n) {
    // Implementierung hier
}

n % 10 liefert die letzte Ziffer, n / 10 entfernt sie. Wiederhole das, solange n größer als 0 ist.

🔮 Predict

Aufgabe 3 – Parameterübergabe

Aufruf: System.out.println(kombiniere("Ha", "llo", 3));

▶️ Run – Parametertrace

Bestimme die Ausgabe für jeden Aufruf.

Aufruf	Ausgabe
kombiniere("A","B",1)
kombiniere("xy","!",2)
kombiniere("","Z",4)

prefix wird n-mal hintereinander gehängt, danach kommt einmal suffix.

🔍 Investigate

Was sind Aktualparameter?

Müssen Aktual- und Formalparameternamen übereinstimmen?

✏️ Modify

Ergänze einen vierten Parameter trennzeichen (char), der zwischen je zwei Wiederholungen eingefügt wird. kombiniere("Ha","!",3,'-') → Ha-Ha-Ha!

String kombiniere(String prefix, String suffix, int n) {
    String erg = "";
    for (int i = 0; i < n; i++) {
        erg += prefix;
    }
    return erg + suffix;
}

Ergänze den Parameter char trennzeichen. Das Trennzeichen kommt nach jeder Wiederholung – außer nach der letzten.

🛠️ Make

Implementiere wiederhole: Gibt einen String zurück, der aus n Kopien von s besteht, mit sep (String) dazwischen. wiederhole("ho",3,"!") → ho!ho!ho

String wiederhole(String s, int n, String sep) {
    // Implementierung hier
}

Wie in Modify: sep nur zwischen zwei Wiederholungen einfügen, also nicht nach der letzten.

🔮 Predict

Aufgabe 4 – Call-by-Value

Was gibt main aus?

💡 Call-by-Value

Java übergibt primitive Datentypen immer als Kopie. Änderungen im Parameter haben keinen Einfluss auf die ursprüngliche Variable.

▶️ Run – Call-Stack Trace

Bestimme für jede Phase den Wert der Variablen.

Zeitpunkt	main: a	main: b	verdopple: x
Vor Aufruf			–
In verdopple (Start)
In verdopple (nach x*=2)
Nach Rückkehr			–

Beim Aufruf bekommt x eine Kopie von a. Was ändert x *= 2 an a?

🔍 Investigate

Beschreibe, wie Java ein Array an eine Methode übergibt.

Wie kann man einen berechneten Wert aus einer Methode herausgeben?

✏️ Modify

Modifiziere verdopple so, dass der verdoppelte Wert zurückgegeben wird und in main korrekt aufgefangen wird.

void verdopple(int x) {
    x *= 2;
}

void main() {
    int a = 5;
    verdopple(a);
    System.out.println(a);  // soll 10 ausgeben
}

Die Methode muss den verdoppelten Wert zurückgeben (Rückgabetyp!), und main muss ihn in a speichern.

🛠️ Make

Implementiere skalar: Gibt ein neues Array zurück, bei dem jedes Element von a mit faktor multipliziert wurde. Originale Array bleibt unverändert.

int[] skalar(int[] a, int faktor) {
    // Implementierung hier
}

Lege ein neues Array gleicher Länge an und fülle es in einer Schleife – so bleibt das Original unverändert.

🔮 Predict

Aufgabe 5 – Methoden überladen

Welche Variante wird aufgerufen?

Aufruf: flaeche(4)

Aufruf: flaeche(3, 7)

Aufruf: flaeche(2.5)

▶️ Run – Überladung Trace

Trage den Rückgabewert ein.

Aufruf	Aufgerufene Variante	Rückgabewert
flaeche(5)
flaeche(4, 6)
flaeche(3.0)

Welche Variante passt zu Anzahl und Typ der Argumente? Bei C ist das Ergebnis ein double.

🔍 Investigate

Woran erkennt Java, welche überladene Methode aufzurufen ist?

Darf man Methoden nur durch den Rückgabetyp überladen?

✏️ Modify

Ergänze eine vierte Überladung: flaeche(double basis, double hoehe) für das allgemeine Dreieck: basis * hoehe / 2.

int flaeche(int s)         { return s * s; }
int flaeche(int b, int h)  { return b * h; }
double flaeche(double r)   { return r * r; }

// Neue Überladung hier hinzufügen

Eine Überladung hat denselben Namen, aber andere Parameter – hier zwei double-Werte.

🛠️ Make

Implementiere drei überladene Versionen von minimum: für zwei int, drei int und zwei double.

// minimum(int a, int b)
// minimum(int a, int b, int c)
// minimum(double a, double b)

Nutze a < b ? a : b (Ternary). Für drei: vergleiche erst zwei, dann mit dritten.

🔮 Predict

Aufgabe 6 – Rekursion

Aufruf: fak(4)

💡 Rekursion

Jeder rekursive Aufruf erzeugt einen neuen Stack-Frame. Der Basisfall stoppt die Rekursion.

▶️ Run – Rekursions-Trace

Ermittle den Call-Stack für fak(4).

Aufruf	n	Rückgabe (berechnet)
fak(4)	4
fak(3)	3
fak(2)	2
fak(1)	1
fak(0)	0

Arbeite von unten nach oben: zuerst der Basisfall fak(0), dann jeder Aufruf mit dem Ergebnis des darunterliegenden.

🔍 Investigate

Beschreibe, was ohne Basisfall geschieht.

Wie viele Stack-Frames entstehen bei fak(5)?

✏️ Modify

Schreibe fak als iterative Variante (ohne Rekursion).

int fak(int n) {
    // iterativ – kein rekursiver Aufruf!
}

Statt sich selbst aufzurufen, multipliziert eine Schleife nacheinander alle Zahlen von 2 bis n.

🛠️ Make

Implementiere fib rekursiv: Fibonacci-Zahl an Position n. fib(0)=0, fib(1)=1, fib(n)=fib(n-1)+fib(n-2).

int fib(int n) {
    // Implementierung hier
}

Basisfall: Für n = 0 und n = 1 ist das Ergebnis n selbst. Sonst ist fib(n) die Summe der beiden Vorgänger.

🔮 Predict

Aufgabe 7 – Gültigkeitsbereiche (Scope)

Was gibt das Programm aus?

💡 Scope-Regeln

Lokale Variablen existieren nur in ihrem Block { … }. Klassenvariablen (static) sind in allen Methoden sichtbar. Lokale Variablen verdecken gleichnamige Klassenvariablen.

▶️ Run – Scope-Trace

Welche Variable ist an welcher Stelle sichtbar/aktiv?

Ausgabe-Anweisung	Aktiver Wert von x	Grund
1. print(x) in zeigeX()
2. print(x) in aendereX()
3. print(x) in zeigeX() danach

Gibt es in der Methode eine lokale Variable x? Dann gilt sie – sonst die Klassenvariable.

🔍 Investigate

Wie kann man innerhalb von aendereX auf die Klassenvariable x zugreifen (nicht die lokale)?

Wann wird eine lokale Variable aus dem Speicher entfernt?

✏️ Modify

Ändere aendereX so, dass keine neue lokale Variable angelegt, sondern die Klassenvariable x auf 5 gesetzt wird (kein Verdecken mehr). Die Ausgabe soll dann 10 5 5 lauten.

static int x = 10;

static void zeigeX()  { System.out.println(x); }

static void aendereX() {
    int x = 5;   // verdeckt Klassenvariable – umbenennen!
    System.out.println(x);
}

Mit int x = … entsteht eine neue lokale Variable. Wie weist du stattdessen der Klassenvariable einen Wert zu?

🛠️ Make

Implementiere einen einfachen Zähler mit Klassenvariable: erhoehe() erhöht den Zähler, reset() setzt ihn auf 0, gibWert() gibt ihn zurück.

static int zaehler = 0;

static void erhoehe() {
    // Implementierung hier
}

static void reset() {
    // Implementierung hier
}

static int gibWert() {
    // Implementierung hier
}

Alle drei Methoden arbeiten mit der Klassenvariable zaehler: erhöhen, auf 0 setzen, zurückgeben.

🔮 Predict

Aufgabe 8 – Vererbung & Überschreiben

💡 Was gibt new Hund().laut() aus?

▶️ Run – Trace

Welche Ausgabe erzeugt jeder Aufruf?

Aufruf	Ausgabe
`new Tier().laut()`
`new Hund().laut()`
`new Hund().laut(3)`

Ein Hund-Objekt nutzt seine eigene laut()-Methode. laut(3) ist eine Überladung mit Schleife.

🔍 Investigate

Was ist der Unterschied zwischen Überschreiben (Override) und Überladen (Overload)?

Welche Java-Annotation zeigt eine bewusste Überschreibung an?

✏️ Modify

Ergänze eine Klasse Katze hinzu, die Tier erweitert und laut() so überschreibt, dass sie "Miau" ausgibt.

class Tier {
    void laut() { System.out.println("..."); }
}

class Hund extends Tier {
    @Override
    void laut() { System.out.println("Wuff"); }
    void laut(int n) {
        for (int i = 0; i < n; i++) System.out.print("Wuff");
        System.out.println();
    }
}

// Hier Katze ergänzen:

Die neue Klasse erweitert Tier (extends) und schreibt laut() mit gleicher Signatur neu.

🛠️ Make

Implementiere eine statische Methode alleRufen(Tier[] tiere), die für jedes Tier-Objekt im Array laut() aufruft. Nutze Polymorphismus.

static void alleRufen(Tier[] tiere) {
    // Implementierung hier

}

Eine for-each-Schleife über das Array – für jedes Tier laut() aufrufen. Java wählt automatisch die passende Version.

🔮 Predict

Aufgabe 9 – Statische Methoden & Hilfsmethoden

💡 Was gibt MathHelper.abs(-7) zurück?

▶️ Run – Trace

Berechne die Rückgabe jedes Aufrufs.

Ausdruck	Ergebnis
`MathHelper.abs(-4)`
`MathHelper.abs(3)`
`MathHelper.max(MathHelper.abs(-4), MathHelper.abs(3))`
`MathHelper.kgZuPfund(1.0)` (auf 1 Stelle)

Setze die Werte in die Methoden ein. Bei verschachtelten Aufrufen zuerst die inneren auswerten.

🔍 Investigate

Warum werden Hilfsmethoden häufig als static deklariert?

Welche Einschränkung gilt für static-Methoden?

✏️ Modify

Ergänze die Klasse um eine statische Methode clamp(int wert, int min, int max), die wert auf den Bereich [min, max] begrenzt.

class MathHelper {
    static int abs(int x) { return x < 0 ? -x : x; }
    static int max(int a, int b) { return a > b ? a : b; }
    static double kgZuPfund(double kg) { return kg * 2.20462; }

    // clamp hier ergänzen:

}

Drei Fälle: Liegt der Wert unter min, über max oder dazwischen? Gib jeweils den passenden Wert zurück.

🛠️ Make

Schreibe eine statische Methode istPalindrom(String s), die true zurückgibt, wenn s vorwärts und rückwärts gleich lautet (Groß-/Kleinschreibung ignorieren). Für "Racecar" → true, für "Hallo" → false.

static boolean istPalindrom(String s) {
    // Implementierung hier

}

Klein schreiben, dann von außen nach innen vergleichen: erstes mit letztem Zeichen, zweites mit vorletztem …

🔮 Predict

Aufgabe 10 – Rekursion & Call-Stack

💡 Was gibt quersumme(493) zurück?

▶️ Run – Call-Stack-Trace

Ermittle den rekursiven Abstieg und Aufstieg für quersumme(493).

Aufruf	n	n % 10
quersumme(493)	493	3
quersumme(49)	49	9
quersumme(4)	4	–

Von unten nach oben: Der Basisfall gibt die Zahl selbst zurück, jede Ebene addiert ihre letzte Ziffer.

🔍 Investigate

Wie viele Stack-Frames erzeugt quersumme(493)?

Was passiert, wenn der Basisfall if (n < 10) return n; fehlt?

✏️ Modify

Schreibe eine iterative Version von quersumme ohne Rekursion. Das Ergebnis soll identisch sein.

int quersumme(int n) {
    if (n < 10) return n;            // rekursiv – umschreiben!
    return n % 10 + quersumme(n / 10);
}

Mit einer while-Schleife: letzte Ziffer zur Summe addieren und abschneiden, solange n größer als 0 ist.

🛠️ Make

Schreibe eine rekursive Methode potenz(int basis, int exp), die basis^exp berechnet. Basisfall: exp == 0 → 1. Für potenz(2, 10) soll 1024 zurückkommen.

int potenz(int basis, int exp) {
    // Implementierung hier

}

Basisfall exp == 0. Sonst gilt: basis^exp = basis · basis^exp−1.

🏅 Deine Badges

📊 Statistik

↺ Zurücksetzen

Alle gespeicherten Daten werden gelöscht.

📄 Arbeitsblatt erstellen

Wähle aus, welche Bereiche auf das Arbeitsblatt kommen. Es enthält dann alle … Aufgaben dieser Seite aus diesen Bereichen – mit Kästchen zum Ankreuzen, leeren Tabellen und Platz zum Schreiben, ohne Lösungen und Tipps.

Bereiche für das Arbeitsblatt 🔮 Predict – vorhersagen, was der Code macht ▶️ Run – Werte Zeile für Zeile in die Tabelle eintragen 🔍 Investigate – untersuchen, warum der Code so arbeitet ✏️ Modify – Code gezielt verändern 🛠️ Make – eigene Methode schreiben

Aufgabe gelöst!

Methoden – Schreibtischtest

📝 Aufgaben

📖 Themenübersicht

🏅 Zuletzt verdiente Badges

💡 Aufbau einer Methodensignatur

💡 Call-by-Value

💡 Rekursion

💡 Scope-Regeln

🏅 Deine Badges

📊 Statistik

↺ Zurücksetzen

📄 Arbeitsblatt erstellen