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
| Minuten | Was |
|---|---|
| 0–5 | Kapitel 1: Aufbau eines Programms lesen |
| 5–20 | Kapitel 2: Eingabe lesen. Das wichtigste Kapitel, lies es langsam. |
| 20–30 | Kapitel 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
| Zeit | Was |
|---|---|
| 0:00–0:20 | Kapitel 2 bis 4 kurz wiederholen (nur die „Merke“-Kästen), dann im Lernheft Themen 4, 5 und 7 rechnen |
| 0:20–0:50 | Kapitel 5: static, 6: Methoden, 10: switch lesen, im Lernheft Themen 3 und 8 |
| 0:50–1:30 | Java-Trainer: alle Aufgaben „Eingabe einlesen“ und „Fehler korrigieren“ |
| 1:30–1:45 | Pause, weg vom Bildschirm |
| 1:45–2:30 | Kapitel 7: Stack, 8: Rekursion, 9: if und Schleifen lesen, im Lernheft Themen 1, 2 und 6 |
| 2:30–3:15 | Java-Trainer: Rekursion, dann „Übungsaufgabe“ und „Taschenrechner“ |
| 3:15–3:30 | Pause |
| 3:30–4:30 | Kapitel 11 lesen, dann den Test vom 14.10.2024 in 45 Minuten auf Papier (Lernheft Thema 10) und selbst korrigieren |
| danach | Was beim Test schiefging, nochmal im passenden Kapitel lesen. Abends nur die Checkliste. |
1 · Wie ein Java-Programm aufgebaut ist
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 ;
}
}
| Teil | Was es ist | Warum |
|---|---|---|
| public class Hallo | die Klasse. Der Name muss genau wie die Datei heißen: Hallo.java | Java findet sonst dein Programm nicht |
| main(String[] args) | die Startmethode | Java fängt immer bei main an, egal wo sie steht |
| { } | Blockklammern: was zusammengehört | Jede { braucht ihre } |
| ; | Ende einer Anweisung | wie der Punkt am Satzende |
| // Text | Kommentar | für Menschen, Java ignoriert ihn |
Ausgeben: print und println
| Befehl | Was er macht | Wann du ihn nimmst |
|---|---|---|
| System.out.println("Hi"); | gibt aus und macht danach einen Zeilenumbruch | normale Ausgaben, jede in eine neue Zeile |
| System.out.print("Zahl: "); | gibt aus ohne Zeilenumbruch | bei Fragen, damit die Eingabe in derselben Zeile steht |
| "Alter: " + alter | + klebt Text und Werte zusammen | wenn 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 =).
| Typ | Was rein passt | Beispiel |
|---|---|---|
| int | ganze Zahlen | int alter = 17; |
| double | Kommazahlen, im Code immer mit Punkt | double preis = 8.5; |
| char | genau ein Zeichen, in einfachen Hochkommas | char c = '+'; |
| String | Text, in doppelten Anführungszeichen | String name = "Anna"; |
| boolean | true oder false | boolean fertig = false; |
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?
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:
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 IOExceptionundimport 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:
| Was | Warum | |
|---|---|---|
| (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 IOException | Beim 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 erzeugen | Von 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.
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:
| Methode | Was sie liest | Was mit dem Enter passiert | Wann du sie nimmst |
|---|---|---|---|
| sc.nextLine() | die ganze Zeile als String, auch mit Leerzeichen | wird mitgenommen | Namen mit Leerzeichen, ganze Sätze, oder Zahl als Text lesen und dann parsen |
| sc.next() | ein Wort (Token) bis zum nächsten Leerzeichen | Leerzeichen und Enter davor werden übersprungen, das Enter danach bleibt liegen | Vorname und Nachname einzeln, ein Rechenzeichen |
| sc.nextInt() | eine ganze Zahl | bleibt liegen! | ganze Zahlen |
| sc.nextDouble() | eine Kommazahl, im Format der Spracheinstellung des PCs | bleibt liegen! | Kommazahlen. Deutscher PC: mit Komma tippen, z. B. 12,5 |
| sc.next().charAt(0) | das erste Zeichen des nächsten Worts als char | wie 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 …
- Im Puffer liegt 17⏎
nextInt()nimmt die 17. Übrig bleibt ⏎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!- Würdest du
""mitDouble.parseDoubleumwandeln, stürzt das Programm ab:NumberFormatException: empty String.
Die drei Abhilfen aus deinem OneNote:
| Abhilfe | So geht's |
|---|---|
| Variante 1 | Nach jedem nextInt() oder nextDouble() ein sc.nextLine(); schreiben. Das räumt das Enter weg. |
| Variante 2 | Immer nur nextLine() benutzen und danach mit Integer.parseInt oder Double.parseDouble umwandeln. |
| Variante 3 | BufferedReader 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.
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?
| Situation | Nimm |
|---|---|
| Aufgabe sagt „mit BufferedReader“ | BufferedReader + parseInt/parseDouble |
| Ganzer Name mit Leerzeichen | nextLine() oder readLine() |
| Zahlen nacheinander, danach ein Rechenzeichen | nextInt(), nextDouble(), next().charAt(0). Kein Enter-Problem. |
| Erst eine Zahl, dann Text | nach der Zahl sc.nextLine(); einfügen |
| Freie Wahl, schnell und sicher | Scanner. Wie die Eingabe erfolgt, bleibt dir überlassen, man sollte aber schlau wählen (steht so im OneNote). |
3 · Rechnen und Typecasting
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.
| Rechnung | Ergebnis | Warum |
|---|---|---|
| 18 / 4 | 4 | int / int → int. 4,5 wird zu 4 abgeschnitten. |
| 18 % 4 | 2 | % heißt Modulo und gibt den Rest: 18 : 4 = 4 Rest 2 |
| 18 / 4.0 | 4.5 | Sobald eine Zahl double ist, wird double gerechnet |
| 7 / 2 * 2.0 | 6.0 | Von 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:
| Art | So sieht's aus | Wann |
|---|---|---|
| 1. Implizit (automatisch) | double d = 5; // 5.0 | Von klein nach groß (int → double). Es geht nichts verloren, also macht Java das von selbst. |
| 2. Explizit mit Klammer | int i = (int) 9.99; // 9 | Von 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. Bibliotheksfunktion | Integer.parseInt("18") Double.parseDouble("2.5") | Wenn die Zahl als Text (String) vorliegt, z. B. von readLine oder nextLine. Laut OneNote der beste Weg. |
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
Das ist der Punkt, an dem fast alle stolpern, du warst also in guter Gesellschaft. Das Wichtigste zuerst:
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?
| Schreibweise | Merksatz | a = 5 vorher: Zeile benutzt | a danach |
|---|---|---|---|
| a++ | Plus hinten = erst benutzen, dann erhöhen | 5 | 6 |
| ++a | Plus vorne = erst erhöhen, dann benutzen | 6 | 6 |
| a-- | erst benutzen, dann verringern | 5 | 4 |
| --a | erst verringern, dann benutzen | 4 | 4 |
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
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
}
}
mainist static und startet. Sie macht nur eins:new HalloWeltOOP(). Das erzeugt ein Objekt der Klasse.- Bei
newläuft automatisch der Konstruktor. Ein Konstruktor heißt genau wie die Klasse und hat keinen Rückgabetyp, nicht mal void. - Der Konstruktor ruft
this.myMainProgram()auf. Ab jetzt sind wir „im Objekt“. - Darum gehen in myMainProgram
this.up()und UPs ohne static.
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
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
| Teil | Was es bedeutet |
|---|---|
| double | Rückgabetyp: was kommt raus? void heißt: es kommt nichts raus, das UP tut nur etwas (z. B. ausgeben). |
| addieren | der 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.
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
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.
- main ruft in Zeile 11
up1()auf → PUSH: „main():11“ bleibt im Stack, up1 kommt oben drauf. - up1 ruft in Zeile 03
up2()auf → PUSH: up2 kommt oben drauf. Jetzt liegen drei Einträge übereinander. - up2 ist fertig (
}) → POP: up2 kommt runter, zurück zu up1, Zeile 04. - up1 ist fertig → POP, zurück zu main, Zeile 12.
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
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
- 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). - 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 ← Abbruch | 2.5 |
Die vier Klassiker aus AB 18
| Methode | Einfachster Fall | Zurückführen | Warum so? |
|---|---|---|---|
| vielfaches(x, n) | n==1 → x | x + vielfaches(x, n-1) | Malnehmen ist wiederholtes Addieren |
| potenz(b, e) | e==0 → 1 | b * potenz(b, e-1) | Potenz ist wiederholtes Malnehmen; hoch 0 ist 1 |
| fakultaet(n) | n==1 → 1 | fakultaet(n-1) * n | 5! = 4! · 5 |
| fibo(n) | n<=2 → 1 | fibo(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).
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
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?
| Schleife | So sieht sie aus | Wann |
|---|---|---|
| for | for (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 … |
| while | while (bedingung) { … } | Prüft zuerst. Kann auch 0-mal laufen. |
| do-while | do { … } 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
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;
}
| Teil | Was 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.
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
Zum Schluss mein Rat für die Arbeit selbst. Jede Aufgabenart hat ihr Vorgehen:
| Aufgabenart | So 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 PC | Vorlage 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 zeichnen | Pro 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!