ÜbersichtErklärheftLernheftJava-Trainer herunterladen

Java verstehen

Erklärheft für die KA am Dienstag, 17.11.

Erst verstehen, dann üben

Hallo! Bevor du Aufgaben rechnest, erkläre ich dir alles einmal in Ruhe. Zu jedem Befehl sage ich, was er macht, wann du ihn nimmst und warum. Du musst nichts auswendig lernen, was du nicht verstanden hast. Wenn du ein Kapitel gelesen hast, machst du die passenden Aufgaben im Lernheft und im Java-Trainer. Dann sitzt es.

Dein Zeitplan

Die Reihenfolge ist kein Zufall. Im Test vom 14.10.2024 gab es 45 Punkte. Davon gingen 23 Punkte an Eingabe (Scanner, BufferedReader), 10 an switch, 7 an ++/-- und Rechnen und 5 an static. Darum lernst du das zuerst.

Heute: 30 Minuten

MinutenWas
0–5Kapitel 1: Aufbau eines Programms lesen
5–20Kapitel 2: Eingabe lesen. Das wichtigste Kapitel, lies es langsam.
20–30Kapitel 3: Rechnen und Typecasting und Kapitel 4: ++ und --

Danach schlafen. Im Schlaf sortiert dein Gehirn, was du gelesen hast. Das ist kein Witz, das hilft wirklich.

Morgen: 4 bis 5 Stunden

ZeitWas
0:00–0:20Kapitel 2 bis 4 kurz wiederholen (nur die „Merke“-Kästen), dann im Lernheft Themen 4, 5 und 7 rechnen
0:20–0:50Kapitel 5: static, 6: Methoden, 10: switch lesen, im Lernheft Themen 3 und 8
0:50–1:30Java-Trainer: alle Aufgaben „Eingabe einlesen“ und „Fehler korrigieren“
1:30–1:45Pause, weg vom Bildschirm
1:45–2:30Kapitel 7: Stack, 8: Rekursion, 9: if und Schleifen lesen, im Lernheft Themen 1, 2 und 6
2:30–3:15Java-Trainer: Rekursion, dann „Übungsaufgabe“ und „Taschenrechner“
3:15–3:30Pause
3:30–4:30Kapitel 11 lesen, dann den Test vom 14.10.2024 in 45 Minuten auf Papier (Lernheft Thema 10) und selbst korrigieren
danachWas beim Test schiefging, nochmal im passenden Kapitel lesen. Abends nur die Checkliste.

1 · Wie ein Java-Programm aufgebaut ist

ca. 5 Minuten

Stell dir ein Java-Programm wie ein Haus vor. Die Klasse ist das Haus, die Methoden sind die Zimmer, und in den Zimmern stehen die Anweisungen, also die Befehle, die nacheinander ausgeführt werden.

public class Hallo {                        // die Klasse = das Haus
  public static void main(String[] args) {  // main = die Haustür, hier geht es los
    System.out.println("Hallo Welt");       // eine Anweisung, endet mit ;
  }
}
TeilWas es istWarum
public class Hallodie Klasse. Der Name muss genau wie die Datei heißen: Hallo.javaJava findet sonst dein Programm nicht
main(String[] args)die StartmethodeJava fängt immer bei main an, egal wo sie steht
{ }Blockklammern: was zusammengehörtJede { braucht ihre }
;Ende einer Anweisungwie der Punkt am Satzende
// TextKommentarfür Menschen, Java ignoriert ihn

Ausgeben: print und println

BefehlWas er machtWann du ihn nimmst
System.out.println("Hi");gibt aus und macht danach einen Zeilenumbruchnormale Ausgaben, jede in eine neue Zeile
System.out.print("Zahl: ");gibt aus ohne Zeilenumbruchbei Fragen, damit die Eingabe in derselben Zeile steht
"Alter: " + alter+ klebt Text und Werte zusammenwenn du Text und Variablen mischen willst

Variablen und Datentypen

Eine Variable ist eine beschriftete Schachtel. Der Datentyp sagt, was in die Schachtel passt. Du musst ihn einmal angeben (Deklaration), dann kannst du Werte hineinlegen (Zuweisung mit =).

TypWas rein passtBeispiel
intganze Zahlenint alter = 17;
doubleKommazahlen, im Code immer mit Punktdouble preis = 8.5;
chargenau ein Zeichen, in einfachen Hochkommaschar c = '+';
StringText, in doppelten AnführungszeichenString name = "Anna";
booleantrue oder falseboolean fertig = false;
Merke

Java fängt bei main an. Klassenname = Dateiname. 'A' ist ein char, "A" ist ein String. Groß- und Kleinschreibung zählt immer: String, nicht string.

2 · Eingabe: Wie kommt etwas von der Tastatur ins Programm?

ca. 15 Minuten · das wichtigste Kapitel (23 von 45 Punkten im Test)

Wenn du auf der Tastatur tippst, kommen bei Java erst mal nur einzelne Signale an, Taste für Taste, und am Ende ein Enter. Java hat drei Wege, daraus etwas Brauchbares zu machen. Im OneNote steht: „Man muss alle Varianten können.“ Also schauen wir uns alle drei an.

Was im Hintergrund passiert: der Puffer

Alles, was du tippst, landet zuerst in einem Wartebereich, dem Puffer. Tippst du 18 und Enter, liegt im Puffer:

18⏎ Enter

Die Lese-Befehle nehmen sich von vorne aus diesem Puffer, was sie brauchen. Der Knackpunkt: Nicht jeder Befehl nimmt das Enter mit. Das Enter ist im Puffer ein ganz normales Zeichen (ein Zeilenumbruch). Das musst du verstanden haben, dann verstehst du jede Scanner-Aufgabe.

Weg 1: System.in.read() – ein einziges Zeichen

int zeichen;
zeichen = System.in.read();          // liest GENAU EIN Zeichen
System.out.println(zeichen);         // gibt den ASCII-Wert aus, z. B. 65 bei A
System.out.println((char) zeichen);  // gibt das Zeichen aus: A
  • Was: nimmt genau ein Zeichen aus dem Puffer und liefert seinen ASCII-Wert als int (A = 65, a = 97).
  • Wann: wenn wirklich nur ein einzelnes Zeichen gebraucht wird. In der Praxis selten, aber es steht im Buch und im OneNote.
  • Warum (char)? Weil du sonst die Zahl siehst. (char) sagt Java: „Zeig mir das als Buchstaben.“ Das ist ein Typecast.
  • Braucht throws IOException und import java.io.*; (gleich erkläre ich warum).

Weg 2: BufferedReader – eine ganze Zeile, der klassische Weg

import java.io.*;                                         // (1)

public void myMainProgram() throws IOException {          // (2)
  BufferedReader eingabe = new BufferedReader(new InputStreamReader(System.in));  // (3)
  System.out.print("Wie alt bist Du? ");
  String alterStr = eingabe.readLine();                   // (4)
  int alter = Integer.parseInt(alterStr);                 // (5)
}

Laut Buch sind drei Bestandteile immer nötig. Gehen wir sie durch:

WasWarum
(1)import java.io.*;BufferedReader, InputStreamReader und IOException wohnen im Paket java.io (io = input/output). Ohne Import kennt Java sie nicht: „Symbol nicht gefunden“.
(2)throws IOExceptionBeim Lesen kann etwas schiefgehen. Java ist streng und will, dass du das ankündigst. Wichtig: auch an jede Methode, die diese Methode aufruft, also auch an den Konstruktor und an main.
(3)das Objekt erzeugenVon innen nach außen lesen: System.in ist die Tastatur. InputStreamReader macht aus den einzelnen Signalen einen Strom von Zeichen. BufferedReader puffert diese Zeichen und trennt sie am Enter in Zeilen.
(4)readLine()holt die ganze Zeile bis zum Enter, immer als String. Das Enter wird mitgenommen, aber nicht mit zurückgegeben.
(5)Integer.parseInt(...)Mit einem String kann man nicht rechnen. „18“ ist Text. parseInt macht daraus die Zahl 18. Für Kommazahlen: Double.parseDouble(...), immer mit Punkt.

In der Musterlösung zu Test-Aufgabe 6 steht dazu die Eselsbrücke aus dem Unterricht: „Eingeborene mit ihren Kanus am Amazonas“. Die einzelnen Tastendrücke fließen als Strom heran, werden gepuffert, und am Enter wird eine Zeile abgeholt.

Merke

BufferedReader = java.io.* + throws IOException + die lange Zeile. Er liefert immer einen String, Zahlen also immer mit Integer.parseInt oder Double.parseDouble umwandeln. Großer Vorteil: kein Enter-Problem, weil readLine das Enter immer mitnimmt.

Weg 3: Scanner – der neuere, bequeme Weg

import java.util.*;                       // Scanner wohnt in java.util

Scanner sc = new Scanner(System.in);      // einmal anlegen, dann immer wieder benutzen

Der Scanner kann direkt Zahlen lesen, das ist bequem. Er braucht kein throws IOException. Aber er hat vier verschiedene Lese-Methoden, und genau die musst du auseinanderhalten:

MethodeWas sie liestWas mit dem Enter passiertWann du sie nimmst
sc.nextLine()die ganze Zeile als String, auch mit Leerzeichenwird mitgenommenNamen mit Leerzeichen, ganze Sätze, oder Zahl als Text lesen und dann parsen
sc.next()ein Wort (Token) bis zum nächsten LeerzeichenLeerzeichen und Enter davor werden übersprungen, das Enter danach bleibt liegenVorname und Nachname einzeln, ein Rechenzeichen
sc.nextInt()eine ganze Zahlbleibt liegen!ganze Zahlen
sc.nextDouble()eine Kommazahl, im Format der Spracheinstellung des PCsbleibt liegen!Kommazahlen. Deutscher PC: mit Komma tippen, z. B. 12,5
sc.next().charAt(0)das erste Zeichen des nächsten Worts als charwie next()Rechenzeichen für switch: + - * /

Das berühmte Scanner-Problem, Schritt für Schritt

int alter = sc.nextInt();          // du tippst 17 und Enter
String ort = sc.nextLine();        // du willst den Wohnort tippen …
  1. Im Puffer liegt 17⏎
  2. nextInt() nimmt die 17. Übrig bleibt ⏎
  3. nextLine() liest „bis zum Enter“. Das Enter liegt ja schon ganz vorne. Also liest es sofort eine leere Zeile und gibt "" zurück. Du kommst gar nicht zum Tippen!
  4. Würdest du "" mit Double.parseDouble umwandeln, stürzt das Programm ab: NumberFormatException: empty String.

Die drei Abhilfen aus deinem OneNote:

AbhilfeSo geht's
Variante 1Nach jedem nextInt() oder nextDouble() ein sc.nextLine(); schreiben. Das räumt das Enter weg.
Variante 2Immer nur nextLine() benutzen und danach mit Integer.parseInt oder Double.parseDouble umwandeln.
Variante 3BufferedReader nehmen.

Wann stört das Enter nicht? Wenn als Nächstes next(), nextInt() oder nextDouble() kommt. Die überspringen Leerzeichen und Enter am Anfang einfach. Nur nextLine() fällt darauf rein. Genau das war Stelle B im Test: Nach nextInt kam nextDouble, also konnte man das sc.nextLine() weglassen. Bei Stelle D kam nach nextDouble ein nextLine, also musste es hin.

Merke

Frag dich bei jedem nextLine(): „Was kam direkt davor?“ War es nextInt(), nextDouble() oder next(), liegt noch ein Enter im Puffer, und du brauchst vorher ein sc.nextLine(); zum Wegräumen. nextDouble(): Komma (Spracheinstellung). Double.parseDouble: Punkt.

Welchen Weg nehme ich wann?

SituationNimm
Aufgabe sagt „mit BufferedReader“BufferedReader + parseInt/parseDouble
Ganzer Name mit LeerzeichennextLine() oder readLine()
Zahlen nacheinander, danach ein RechenzeichennextInt(), nextDouble(), next().charAt(0). Kein Enter-Problem.
Erst eine Zahl, dann Textnach der Zahl sc.nextLine(); einfügen
Freie Wahl, schnell und sicherScanner. Wie die Eingabe erfolgt, bleibt dir überlassen, man sollte aber schlau wählen (steht so im OneNote).

3 · Rechnen und Typecasting

ca. 6 Minuten

Java rechnet mit + - * / wie du. Mit einer großen Ausnahme: Wenn beide Zahlen int sind, ist auch das Ergebnis int. Der Rest nach dem Komma wird einfach abgeschnitten, nicht gerundet.

RechnungErgebnisWarum
18 / 44int / int → int. 4,5 wird zu 4 abgeschnitten.
18 % 42% heißt Modulo und gibt den Rest: 18 : 4 = 4 Rest 2
18 / 4.04.5Sobald eine Zahl double ist, wird double gerechnet
7 / 2 * 2.06.0Von links: 7/2 = 3 (int!), dann 3 * 2.0 = 6.0

Java gibt double-Werte immer mit Punkt und mindestens einer Nachkommastelle aus: 4.0, nicht 4. Darum stand im Test: „Double-Werte als Double ausgeben!“

Typecasting: einen Typ in einen anderen verwandeln

Im OneNote stehen drei Arten. Ich erkläre dir, wann du welche brauchst:

ArtSo sieht's ausWann
1. Implizit (automatisch)double d = 5; // 5.0Von klein nach groß (int → double). Es geht nichts verloren, also macht Java das von selbst.
2. Explizit mit Klammerint i = (int) 9.99; // 9Von groß nach klein (double → int). Es geht etwas verloren, darum musst du es mit (int) ausdrücklich sagen. Es wird abgeschnitten, nicht gerundet. Auch (char) 65 → A.
3. BibliotheksfunktionInteger.parseInt("18")
Double.parseDouble("2.5")
Wenn die Zahl als Text (String) vorliegt, z. B. von readLine oder nextLine. Laut OneNote der beste Weg.
Merke

Bei jeder Rechnung fragst du: „int oder double?“ Zwei ints → Ergebnis int, abgeschnitten. Kommt die Zahl als String → parse…. Ist es schon eine Zahl und nur der Typ soll wechseln → (Typ) davor.

4 · ++ und -- verstehen

ca. 4 Minuten

Das ist der Punkt, an dem fast alle stolpern, du warst also in guter Gesellschaft. Das Wichtigste zuerst:

Der Kern

a++ heißt nicht „a + 1“. Es heißt a = a + 1. Die Variable wird also wirklich verändert und gespeichert. Das gilt immer, egal ob die Plus vorne oder hinten stehen.

Vorne oder hinten entscheidet nur eins: Welche Zahl wird in dieser einen Zeile benutzt?

SchreibweiseMerksatza = 5 vorher: Zeile benutzta danach
a++Plus hinten = erst benutzen, dann erhöhen56
++aPlus vorne = erst erhöhen, dann benutzen66
a--erst benutzen, dann verringern54
--aerst verringern, dann benutzen44

So gehst du in der KA vor: Mach dir neben dem Code eine kleine Tabelle mit zwei Spalten: „Ausgabe“ und „Variable danach“. Geh Zeile für Zeile und schreib beides auf. Dann kann nichts schiefgehen. Steht a++; allein in einer Zeile, ist vorne oder hinten egal, da wird ja nichts ausgegeben.

Die Gemeinheit i = i++; Java rechnet erst die rechte Seite: i++ liefert den alten Wert 1 und setzt i auf 2. Dann kommt i = 1 und überschreibt die 2. Ergebnis: 1. Die Lektion aus dem OneNote: So etwas schreibt man nicht. Möglichst kleinzeilig.

5 · static und der OOP-Ansatz

ca. 6 Minuten

Ihr benutzt im Unterricht eine Vorlage, die erst mal komisch aussieht. Ich erkläre dir, warum es sie gibt, dann musst du sie nicht auswendig lernen, sondern kannst sie herleiten.

Was heißt static?

Im OneNote steht: static heißt „automatisch da, ohne dass wir das Programm selbst erzeugen müssen“ und „genau einmal da“. Darum ist main static: Java muss main ja aufrufen können, bevor irgendwas anderes existiert.

Das Problem: In einer static-Methode gibt es kein Objekt. Und this heißt „dieses Objekt“. Ohne Objekt kein this. Außerdem kann eine static-Methode direkt nur andere static-Methoden aufrufen.

Lösung A: alles static (klassisch)

public class Klassisch {
  public static void up() {           // UP muss auch static sein
    System.out.println("UP");
  }
  public static void main(String[] args) {
    up();                             // Aufruf OHNE this
  }
}

Lösung B: der OOP-Ansatz (eure Vorlage)

public class HalloWeltOOP {
  public HalloWeltOOP () {              // (2) der Konstruktor
    this.myMainProgram();               // (3) startet unser Hauptprogramm
  }
  public static void main(String[] args) {
    new HalloWeltOOP();                 // (1) erzeugt ein Objekt
  }
  void up() {                           // kein static nötig
    System.out.println("UP");
  }
  public void myMainProgram() {         // (4) hier schreibst du dein Programm
    System.out.println("Hallo Welt");
    this.up();                          // this geht jetzt
  }
}
  1. main ist static und startet. Sie macht nur eins: new HalloWeltOOP(). Das erzeugt ein Objekt der Klasse.
  2. Bei new läuft automatisch der Konstruktor. Ein Konstruktor heißt genau wie die Klasse und hat keinen Rückgabetyp, nicht mal void.
  3. Der Konstruktor ruft this.myMainProgram() auf. Ab jetzt sind wir „im Objekt“.
  4. Darum gehen in myMainProgram this.up() und UPs ohne static.
Merke und Fehler-Checkliste

static = automatisch da, genau einmal da. In static gibt es kein this. Fehler finden: (1) Steht this in static main? (2) Wird aus static main eine Methode ohne static aufgerufen? (3) Heißen Klasse, Konstruktor und new …() exakt gleich? (4) Ist der Methodenname beim Aufruf genau gleich geschrieben (myMainProgramm vs. myMainProgram)?

6 · Unterprogramme: Parameter und return

ca. 6 Minuten

Ein Unterprogramm (UP, Methode) ist wie ein Rezept mit Namen. Du schreibst es einmal und rufst es auf, so oft du willst. Im OneNote heißt das: Zerlegen, zerlegen, zerlegen.

double addieren(int p1, double p2) {   // Rückgabetyp, Name, Parameter
  return p1 + p2;                        // Ergebnis zurückgeben
}

erg = this.addieren(z1, z2);             // Aufruf: z1 kommt in p1, z2 in p2
TeilWas es bedeutet
doubleRückgabetyp: was kommt raus? void heißt: es kommt nichts raus, das UP tut nur etwas (z. B. ausgeben).
addierender Name, klein geschrieben, sagt was es tut
(int p1, double p2)Parameter: was muss rein? Beim Aufruf werden die Werte kopiert: z1 nach p1, z2 nach p2. Reihenfolge und Typen müssen passen.
return …;gibt das Ergebnis an den Aufrufer zurück und beendet das UP sofort

Warum double als Rückgabetyp? Weil int + double ein double ergibt. Würdest du int zurückgeben, müsstest du casten und würdest Nachkommastellen verlieren.

Merke

Braucht der Aufrufer ein Ergebnis → Rückgabetyp + return. Tut das UP nur etwas → void. Parameter = was rein muss, return = was raus kommt.

7 · Was beim Aufruf passiert: der Stack

ca. 5 Minuten

Wenn main ein Unterprogramm aufruft, springt der Computer dorthin. Aber woher weiß er nachher, wohin er zurück muss? Dafür gibt es zwei Helfer:

  • Befehlszeilenzähler (PC, Program Counter): zeigt immer auf die Zeile, die gerade dran ist.
  • Stack (Kellerspeicher, Stapelspeicher): ein Stapel, auf den bei jedem Aufruf die Rücksprungadresse gelegt wird.

Stell dir einen Tellerstapel vor. Du legst immer oben drauf und nimmst immer von oben weg. Der Teller, den du zuletzt hingelegt hast, kommt zuerst wieder runter: LIFO, Last In, First Out.

  1. main ruft in Zeile 11 up1() auf → PUSH: „main():11“ bleibt im Stack, up1 kommt oben drauf.
  2. up1 ruft in Zeile 03 up2() auf → PUSH: up2 kommt oben drauf. Jetzt liegen drei Einträge übereinander.
  3. up2 ist fertig (}) → POP: up2 kommt runter, zurück zu up1, Zeile 04.
  4. up1 ist fertig → POP, zurück zu main, Zeile 12.
Merke

Immer bei main anfangen. Aufruf = PUSH (die Aufrufzeile bleibt als Rücksprungadresse liegen). Ende des UPs = POP (weiter in der Zeile nach dem Aufruf). LIFO. Die Animation dazu ist im Lernheft, Aufgabe 1.1.

8 · Rekursion

ca. 12 Minuten · hier sind Struktogramm und PAP gefragt

Rekursion heißt: Eine Methode ruft sich selbst auf. Klingt verrückt, ist aber eine clevere Idee: Du löst ein großes Problem, indem du es auf ein etwas kleineres Problem derselben Art zurückführst. So lange, bis das Problem so klein ist, dass du die Antwort einfach weißt.

Beispiel aus dem Alltag: „Wie viele Leute stehen vor mir in der Schlange?“ Du fragst die Person vor dir. Die fragt die Person vor ihr, und so weiter. Die erste Person sagt: „Vor mir steht keiner, 0.“ Dann geht die Antwort zurück, und jeder zählt 1 dazu.

Das Rezept: zwei Fragen

  1. Was ist der einfachste Fall? Den schreibst du als Abbruchbedingung zuerst. Ohne ihn ruft sich die Methode endlos auf → StackOverflowError (der Stack läuft über).
  2. Wie führe ich den Fall n auf den Fall n−1 zurück? Das ist der rekursive Aufruf. Der Parameter muss dabei kleiner werden, sonst kommt man nie beim einfachsten Fall an.

vielfaches: x · n als Addition

double vielfaches(double x, int n) {
  if (n == 1) {                        // einfachster Fall: 1 mal x ist x
    return x;
  } else {
    return x + vielfaches(x, n - 1);   // x·n = x + x·(n−1)
  }
}

Aufruf vielfaches(2.5, 3), Schritt für Schritt:

Hinweg (alles kommt auf den Stack)Rückweg (LIFO, jetzt wird gerechnet)
vielfaches(2.5, 3) = 2.5 + vielfaches(2.5, 2)2.5 + 5.0 = 7.5
vielfaches(2.5, 2) = 2.5 + vielfaches(2.5, 1)2.5 + 2.5 = 5.0
vielfaches(2.5, 1) = 2.5 ← Abbruch2.5

Die vier Klassiker aus AB 18

MethodeEinfachster FallZurückführenWarum so?
vielfaches(x, n)n==1 → xx + vielfaches(x, n-1)Malnehmen ist wiederholtes Addieren
potenz(b, e)e==0 → 1b * potenz(b, e-1)Potenz ist wiederholtes Malnehmen; hoch 0 ist 1
fakultaet(n)n==1 → 1fakultaet(n-1) * n5! = 4! · 5
fibo(n)n<=2 → 1fibo(n-1) + fibo(n-2)jede Zahl ist die Summe der zwei davor; zwei Startwerte, darum n<=2

Potenz doppelt rekursiv

Euer Lehrer hat angekündigt: Potenz rekursiv, und zwar ohne *, weil das Malnehmen das rekursive vielfaches übernimmt. Überleg mal: basis * potenz(basis, e-1) heißt ja „basis so oft addieren, wie potenz(basis, e-1) groß ist“. Und genau das macht vielfaches:

int potenz(int x, int n) {
  if (n == 0) {
    return 1;
  } else {
    return (int) vielfaches((double) x, potenz(x, n - 1));
  }
}

Die Casts brauchst du, weil vielfaches ein double haben will und ein double zurückgibt, potenz aber mit int arbeitet. Die zweite Variante aus eurem Taschenrechner nimmt multiplikationRekursiv(int i1, int i2) (Abbruch bei i1 == 0 → 0). Da ist alles int, also keine Casts.

Struktogramm und PAP zeichnen

  • Für jede Methode ein eigenes Diagramm. Oben steht die Methodensignatur.
  • Struktogramm: Das if ist ein Rechteck mit zwei schrägen Linien (Dreieck). Oben die Bedingung, links „ja“, rechts „nein“. Was im if steht, kommt in die linke Spalte, was im else steht, in die rechte. Der rekursive Aufruf ist einfach eine Anweisung im Feld.
  • PAP: Oval für Start und Ende, Raute für die Verzweigung, Rechteck für eine Anweisung, Rechteck mit doppelten Seitenlinien für einen Unterprogramm-Aufruf (auch den rekursiven).
Merke

Erst Abbruch, dann zurückführen. Der Parameter muss kleiner werden. Hinweg: alles wandert auf den Stack. Rückweg: von oben nach unten ausrechnen. Beim Nachrechnen immer eine Tabelle von unten nach oben machen (wie bei makkaroni und brat).

9 · if, Schleifen und die Gemeinheiten

ca. 6 Minuten

if und else

if (tipp > zufall) {
  System.out.println("Die Zahl war zu groß!");
} else if (tipp < zufall) {
  System.out.println("Die Zahl war zu klein!");
} else {
  System.out.println("Richtig!");
}

Wichtig: Es gibt keine if-Schleife! if fragt einmal ab, das ist eine Verzweigung. Vergleichen mit ==, zuweisen mit =. Und: Ohne geschweifte Klammern gehört nur die nächste Zeile zum if, egal wie es eingerückt ist. Darum immer Klammern setzen. Für „und“ nimmst du &&, für „oder“ ||.

Welche Schleife wann?

SchleifeSo sieht sie ausWann
forfor (int i = 1; i <= 10; i++) { … }Du weißt, wie oft, z. B. 10-mal. Ablauf: Start einmal, dann Bedingung prüfen, Körper, Schritt, Bedingung prüfen …
whilewhile (bedingung) { … }Prüft zuerst. Kann auch 0-mal laufen.
do-whiledo { … } while (bedingung);Läuft mindestens einmal, prüft am Ende. Perfekt für Menüs (Taschenrechner) und Zahlenraten, denn man muss erst eingeben, bevor man prüfen kann.

Die Gemeinheiten aus deinem OneNote

Bei „Was gibt das aus?“-Aufgaben mit Schleifen hilft nur eins: eine Tabelle mit allen Variablen führen und Runde für Runde eintragen. Achte besonders auf int-Division (5/2 ist 2) und auf Variablen, die sich in der Schleife ändern und gleichzeitig in der Bedingung stehen.

10 · switch-case

ca. 5 Minuten · neu, kommt sicher dran

switch ist wie ein Weichensteller: Er schaut auf eine Variable und springt zum passenden Fall. Das ist übersichtlicher als eine lange if-else-Kette, wenn du eine Variable mit vielen festen Werten vergleichst, z. B. ein Rechenzeichen.

char c = eingabe.next().charAt(0);    // ein Zeichen einlesen

switch (c) {                           // nach welcher Variable wird entschieden?
  case '+':                            // wenn c gleich '+' ist …
    erg = this.addieren(z1, z2);
    System.out.println("Ergebnis ist: " + erg);
    break;                             // … und dann raus aus dem switch
  case '-':
    erg = this.subtrahieren(z1, z2);
    System.out.println("Ergebnis ist: " + erg);
    break;
  default:                             // alles andere
    System.out.println("Auswahl nicht unterstützt");
    break;
}
TeilWas und warum
switch (c)die Variable, nach der entschieden wird. Geht mit int, char und String, nicht mit double.
case '+':ein Fall. Bei char mit einfachen Hochkommas, bei int ohne: case 1:
break;beendet den switch. Ohne break läuft Java einfach in den nächsten Fall weiter und macht den auch noch.
default:wird genommen, wenn kein case passt. Wie das letzte else.

Warum next().charAt(0)? Der Scanner hat kein „nextChar“. Also liest du mit next() ein Wort und nimmst mit charAt(0) das erste Zeichen davon (Zählung beginnt bei 0).

Das Menü mit do-while (Taschenrechner): Die ganze Abfrage plus switch steht in do { … } while (c != '0');. Denk an case '0': break;, sonst meldet default bei der 0 einen Fehler. Und '0' mit Hochkommas, weil c ein char ist.

Merke

switch (Variable) · case Wert: · break; · default:. Ein Zeichen einlesen mit next().charAt(0). Nach jedem Fall ein break.

11 · So gehst du in der KA vor

ca. 4 Minuten

Zum Schluss mein Rat für die Arbeit selbst. Jede Aufgabenart hat ihr Vorgehen:

AufgabenartSo gehst du vor
„Korrigiere die Fehler“Von oben nach unten: Import richtig? throws IOException an allen nötigen Stellen? Namen von Klasse, Konstruktor, new und Methoden gleich? this in static? Typen passend (String nicht direkt in int, parse benutzen)? Jedes ; und jede Klammer da?
„Was gibt das aus?“Tabelle neben den Code: jede Variable eine Spalte, Zeile für Zeile eintragen. Bei jeder Rechnung fragen: int oder double? Doubles mit .0 hinschreiben.
„Erläutere genauer, auch im Hintergrund“Immer drei Dinge sagen: was der Befehl macht, was im Puffer bzw. im Speicher passiert, und was ohne ihn schiefgehen würde (mit Namen des Fehlers, z. B. NumberFormatException).
„Ergänze die Lücken“Erst den Typ der Variable anschauen (int → nextInt, double → nextDouble, String → nextLine), dann die Struktur (switch → case, break, default).
Programmieren am PCVorlage hinschreiben, Variablen überlegen, Eingabe, UPs mit return, Ausgabe. Nach jedem kleinen Schritt kompilieren. Bei Fehlern immer den ersten Fehler zuerst beheben, Folgefehler verschwinden oft von selbst.
Rekursion zeichnenPro Methode ein Diagramm, Signatur oben, if als Dreieck bzw. Raute, UP-Aufruf mit doppelten Seitenlinien.

Und zum Schluss: Du hast dich gut vorbereitet. Wenn du bei einer Aufgabe hängst, geh weiter und komm später zurück. Viel Erfolg am Dienstag!