MINT lernen

Übungen: Lokale und globale Variablen

Zehn interaktive Übungen zu lokalen und globalen Variablen, Verdecken und Seiteneffekten — von AFB I bis AFB III.

Dein Fortschritt:
0 / 0 Aufgaben
1

Übungsaufgaben

Zehn interaktive Übungen zum Klicken, Ziehen und Knobeln — von AFB I bis AFB III. Jede Übung gibt dir sofort Rückmeldung.

A1
Global, lokal oder Parameter?
AFB I

Eine Ladenkasse ist als Java-Klasse programmiert:

Java
public class Kasse {
    double umsatz = 0;
    int kunden = 0;

    double kassieren(double betrag, int anzahl) {
        double gesamt = betrag * anzahl;
        umsatz = umsatz + gesamt;
        kunden = kunden + 1;
        return gesamt;
    }

    double schnitt() {
        double d = umsatz / kunden;
        return d;
    }
}

Ordne jede Variable ein.

Ziehe jede Karte in den passenden Korb — oder wähle sie mit Enter aus und drücke dann die Ziffer des Korbs (0 legt sie zurück).
1global (Attribut)
2lokal
3Parameter
Entscheidend ist der Ort der Deklaration: in der Klasse außerhalb aller Operationen → global; im Rumpf einer Operation → lokal; in den Klammern des Kopfs → Parameter.
A2
Stimmt's? — Gültigkeit und Lebensdauer
AFB I

Fünf Aussagen über lokale und globale Variablen.

5 Aussagen nacheinander. Eine falsche Einschätzung reicht — dann startest du die Serie mit „Neue Runde“ neu.
Aussage 1 von 5

Lokal = nur im eigenen Rumpf und nur während des Aufrufs. Python braucht global, um eine globale Variable zu ändern.
A3
Lückentext: Fachbegriffe
AFB I

Setze die Fachbegriffe ein — ein Wort bleibt übrig.

Wort anklicken, dann Lücke anklicken (oder umgekehrt) — mit Tab und Enter geht es genauso. Ein Klick auf eine gefüllte Lücke legt das Wort zurück.

Der Programmteil, in dem eine Variable bekannt ist, heißt ihr . Eine in einer Operation deklarierte Variable ist ; sie entsteht bei jedem Aufruf neu. Trägt sie denselben Namen wie eine globale Variable, sie diese innerhalb der Operation. Ändert eine Operation eine globale Variable, spricht man von einem . In Python braucht man dafür das Schlüsselwort .

„Parameter“ bleibt übrig. Er ist zwar auch nur lokal gültig, gehört aber in die Klammern des Kopfs — hier ist nach Begriffen für Gültigkeit und Nebenwirkungen gefragt.
A4
Rechenkette: Der Mähroboter
AFB II

Ein Mähroboter verwaltet seinen Akkustand:

Java
public class Roboter {
    int akku = 80;

    void laden(int akku) {
        akku = akku + 15;
    }

    void fahren(int strecke) {
        int bedarf = strecke * 2;
        akku = akku - bedarf;
    }
}

Nacheinander werden laden(50), fahren(12), laden(akku) und fahren(5) aufgerufen. Welchen Wert hat das Attribut akku jeweils danach?

Rechne die Kette Schritt für Schritt: Erst wenn ein Schritt stimmt, wird der nächste freigeschaltet. Enter prüft.
  1. nach laden(50) %
  2. nach fahren(12) %
  3. nach laden(akku) %
  4. nach fahren(5) %
Der Parameter akku von laden verdeckt das Attribut: Erhöht wird nur die Kopie, die am Ende der Operation verschwindet — das Laden wirkt nie. fahren hat keinen gleichnamigen Parameter und ändert das Attribut: 80 − 24 = 56, 56 − 10 = 46. Korrekt wäre this.akku = this.akku + akku;.
A5
Lebenslauf einer lokalen Variable
AFB II

Gegeben ist ein Ausschnitt einer Java-Klasse; danach werden bonus(3) und bonus(5) aufgerufen.

Java
int gesamt = 0;          // Attribut

int bonus(int stufe) {
    int extra = stufe * 10;
    gesamt = gesamt + extra;
    return extra;
}

Bringe die Vorgänge in die richtige Reihenfolge.

Ziehe die Karten in die richtige Reihenfolge — mit der Tastatur: ↑/↓ verschiebt, Shift+↑/↓ wechselt nur den Fokus.
1Aufruf bonus(5): stufe und extra entstehen neu — ohne alte Werte; gesamt wird 80.
2Das Attribut gesamt wird auf 30 erhöht.
3Aufruf bonus(3): Der Parameter stufe entsteht mit dem Wert 3.
4bonus endet: stufe und extra werden gelöscht, gesamt bleibt 30.
5Die lokale Variable extra entsteht mit dem Wert 30.
6return liefert 30 an den Aufrufer.
Parameter und lokale Variablen leben nur während eines Aufrufs. Das Attribut überdauert alle Aufrufe und sammelt: 30 + 50 = 80.
A6
Fehlersuche: Guthabenkarte in Python
AFB II

Das Programm verwaltet das Guthaben einer Mensakarte. Die Funktionen sollen später alle aufgerufen werden. Drei Zeilen führen zu einem Fehler, sobald sie ausgeführt werden.

Klicke genau die fehlerhaften Zeilen an — die richtigen musst du stehen lassen.
Die Python-Regel: Wer in einer Funktion einer Variable etwas zuweist, macht sie lokal — außer mit global. Parameter und lokale Variablen sind außerhalb ihrer Funktion nicht bekannt. Zeile 4 ist korrekt, weil Zeile 3 global erklärt.
A7
Trickaufgabe: Gleicher Name, andere Variable
AFB II

Welche Zahl gibt dieses Python-Programm aus?

Python
stufe = 1

def aufsteigen():
    stufe = 5
    return stufe + 1

x = aufsteigen()
print(stufe + x)
Rechne selbst und trage das Ergebnis ein — Enter prüft direkt.
Die Falle: stufe = 5 in der Funktion erzeugt eine neue lokale Variable — die globale stufe bleibt 1. Die Funktion liefert 5 + 1 = 6, ausgegeben wird 1 + 6 = 7 (nicht 5 + 6 = 11).
A8
Seiteneffekte durchschauen
AFB III

Ein Kartenspiel nimmt Karten von einem Stapel:

Java
int stapel = 10;      // Attribut

int nimm(int n) {
    stapel = stapel - n;
    return stapel;
}

Jedes Szenario beginnt wieder mit stapel = 10. Welche Aussagen sind richtig?

Mehrere Antworten sind richtig. Markiere alle zutreffenden und klicke dann auf „Prüfen“.
Der erste Aufruf liefert 7, der zweite 4 — zusammen 11. Weil nimm das Attribut verändert, hängt jedes Ergebnis davon ab, wie oft vorher genommen wurde (8, dann 6). Mit einer lokalen Variable startet jeder Aufruf wieder bei 10 — dann gäbe es aber auch keinen Stapel mehr, der sich merkt, was genommen wurde.
A9
Mix: Aufruf und Ergebnis
AFB III

In einer Java-Klasse stehen ein Attribut und vier Operationen:

Java
int basis = 4;

int plus(int basis) { return basis + 1; }
int mal(int x)      { return basis * x; }
double teil(int x)  { return x / 2.0; }
boolean gross(int x) { return x > basis; }

Verbinde jeden Ausdruck mit seinem Wert.

A10
this und das Verdecken
AFB III

Welchen Wert hat r nach der letzten Zeile? Java wertet die Summe von links nach rechts aus.

Java
int gesamt = 0;      // Attribut

int schritt(int k) {
    int gesamt = k * 2;
    this.gesamt = this.gesamt + k;
    return gesamt + this.gesamt;
}

int r = schritt(1) + schritt(2) + schritt(3) + schritt(4);
Schiebe den Regler auf deine Antwort — Pfeiltasten bewegen ihn feiner. Nach dem Prüfen siehst du den Trefferbereich.
080
Die lokale Variable gesamt ist jedes Mal 2k, das Attribut this.gesamt wächst über alle Aufrufe: 1, 3, 6, 10. Rückgaben: 2 + 1 = 3, 4 + 3 = 7, 6 + 6 = 12, 8 + 10 = 18. Summe: 3 + 7 + 12 + 18 = 40.