Name eingeben: nach dem Namen. Gib dann Guten Tag Benutzer <Name> und am Ende Programmende Eingabe. aus. Benutze BufferedReader.Dienstag, 17.11.2026
Lernheft mit Lösungen
Dein Lehrer hat gesagt: Es kommen nur Aufgaben dran, die auch im OneNote sind. Darum stehen hier nur Aufgaben aus deinem OneNote, jeweils mit Quelle. Jede Aufgabe hat einen roten Lösungsknopf mit Erklärung, wie man auf die Lösung kommt. Alle Ausgaben und Programme sind mit Java 21 getestet.
| Wann | Was |
|---|---|
| Erst verstehen | Lies zuerst das Erklärheft „Java verstehen“ (auch als Datei java-erklaert.html im Ordner Java-KA-Lernen). Dort steht zu jedem Befehl, was er macht, wann und warum. Den genauen Zeitplan für heute (30 Min.) und morgen (4–5 Std.) findest du dort. |
| Dann üben | Nach jedem Kapitel die passenden Themen hier im Lernheft. Bei jeder Aufgabe erst selbst lösen, dann die rote Lösung aufklappen und den Lösungsweg lesen, auch wenn du richtig lagst. |
| Am PC | Im Java-Trainer (Ordner Java-KA-Lernen → java-trainer → start.bat) möglichst viele Aufgaben aus Thema 9. Übungsaufgabe und Taschenrechner auf jeden Fall. |
| Generalprobe | Den Test vom 14.10.2024 (Thema 10) in 45 Minuten auf Papier, danach selbst korrigieren. |
| Dienstag früh | Nur die Checkliste und die roten „Falle“-Kästen. |
Nur Aufgaben, die auch im OneNote zu finden sind. Möglichst viel am PC, eventuell Theorie. Keine Struktogramme oder PAPs, außer bei Rekursion. Noch keine Arrays. Java4U-Aufgaben 42 und 43 nicht.
Schreib auf Papier für jeden Schritt auf, was im Stack steht und was Kara tut (M = move, L = turnLeft, R = turnRight). (a) bis (e) sind wie im Arbeitsblatt schon vorgegeben. Dann klick dich zur Kontrolle durch.
main (Zeile 09). Die UPs oben laufen nur, wenn sie aufgerufen werden.} eines UPs: oberen Eintrag weg (POP), weiter in der Zeile nach dem Aufruf.Ergebnis: Kara macht M R L R M L. Höchstens 3 Einträge gleichzeitig.
main: M (Zeile 10) → up1: R (02) → up2: L (07) → zurück in up1: R (04) → zurück in main: M (12) → up2: L (07). Zusammen MRLRML.
Wie funktioniert das mit den Sprüngen und Rücksprüngen bei Unterprogrammen? Erkläre mit den Begriffen Befehlszeilenzähler, Stack und LIFO.
Der Befehlszeilenzähler (PC) arbeitet die Zeilennummern ab. Wird ein Unterprogramm aufgerufen, springt er in das UP. Damit das Programm danach an der richtigen Stelle weitermacht, wird die Rücksprungadresse (die Zeile des Aufrufs) im Stack gespeichert (PUSH). Ist das UP fertig, wird die Adresse wieder aus dem Stack geholt (POP) und dort weitergemacht. Weil UPs andere UPs aufrufen können, muss die zuletzt gespeicherte Adresse zuerst wieder raus: Last In, First Out (LIFO).
StackOverflowError.| Methode | Abbruch | Rekursiver Fall |
|---|---|---|
| vielfaches(x, n) = x·n | n==1 → x | x + vielfaches(x, n-1) |
| potenz(b, e) = be | e==0 → 1 | b * potenz(b, e-1) |
| fakultaet(n) = n! | n==1 → 1 | fakultaet(n-1) * n |
| fibo(n): 1 1 2 3 5 8 13 | n<=2 → 1 | fibo(n-1) + fibo(n-2) |
double vielfaches(double multiplikand, int multiplikator) {
if (multiplikator==1) {
return multiplikand;
} else {
return multiplikand+vielfaches(multiplikand,multiplikator-1);
}
}
int potenz(int basis,int exponent) {
if (exponent==0) {
return 1;
} else {
return basis*potenz(basis,exponent-1);
}
}
int fakultaet(int zahl) {
if (zahl==1) {
return 1;
} else {
return fakultaet(zahl-1)*zahl;
}
}
int fibo(int n) {
if (n>2) {
return fibo(n-1) + fibo (n-2);
} else { // Fall n<=2, also n=1 oder n=2
return 1;
}
}
// Potenz rekursiv mit Vielfachem rekursiv
int potenz(int x, int n) {
if (n==0) {
return 1;
} else {
return (int) vielfaches((double)x,potenz(x,n-1));
}
}
Bei der doppelt rekursiven Potenz ist potenz(x,n-1) der Multiplikator, also wie oft x addiert wird. Die Casts sind nötig: vielfaches will und liefert double, die Potenz ist int. Und: Abbruch bei n==0, nicht bei n==1 (OneNote: „Potenz mit hoch 0“).
Überleg vor jedem Klick: Was kommt als Nächstes auf den Stack, und wann wird zurückgerechnet?
Hinweg (alles kommt auf den Stack): potenz(2,3) → potenz(2,2) → potenz(2,1) → potenz(2,0).
Rückweg (LIFO): potenz(2,0) = 1 → potenz(2,1) = 2·1 = 2 → potenz(2,2) = 2·2 = 4 → potenz(2,3) = 2·4 = 8.
potenz(5, 3) = 5 · 5 · 5 · potenz(5, 0) = 5 · 5 · 5 · 1 = 125.
vielfaches(2.5, 4) = 2.5 + 2.5 + 2.5 + 2.5 = 10.0. Rückgabetyp double, darum mit .0.
fakultaet(5) = 1 · 2 · 3 · 4 · 5 = 120.
fibo(7): Folge 1, 1, 2, 3, 5, 8, 13.
potenz(5, 4) doppelt rekursiv: pot(5,0)=1 → vielfaches(5,1)=5 → vielfaches(5,5)=25 → vielfaches(5,25)=125 → vielfaches(5,125)=625, mit (int) → 625. Das ist der Aufruf aus dem OneNote-Programm.
int makkaroni(int nudel)
{ if (nudel==1)
{ return 1; }
else { if (nudel==2)
return 2;
else return 2*makkaroni(nudel-2)+makkaroni(nudel-1);
}
}
int brat(int kartoffel)
{ if (kartoffel==1)
{ return 1; }
else { if (kartoffel==2)
return 3;
else return 3*brat(kartoffel-2)+2*brat(kartoffel-1);
}
}
| n | makkaroni(n) | brat(n) |
|---|---|---|
| 1 | 1 | 1 |
| 2 | 2 | 3 |
| 3 | 2·1 + 2 = 4 | 3·1 + 2·3 = 9 |
| 4 | 2·2 + 4 = 8 | 3·3 + 2·9 = 27 |
| 5 | 2·4 + 8 = 16 | 3·9 + 2·27 = 81 |
Im OneNote steht dazu „Potenz über Makkaroni und Bratkartoffel“: makkaroni liefert die Zweierpotenzen, brat die Dreierpotenzen.
Für jede Methode ein eigenes Struktogramm. Oben die Methodensignatur. if-else ist das Dreieck mit „ja“ links und „nein“ rechts. Der rekursive Aufruf ist einfach eine Anweisung im Feld.
Oval = Start und Ende, Raute = Verzweigung, Rechteck = Anweisung, Rechteck mit doppelten Seitenlinien = Unterprogramm-Aufruf. Ein PAP pro Methode.
vielfaches als Struktogramm.vielfaches als PAP.vielfaches verwendet wird.Kopf = Signatur abschreiben. Die if-Bedingung ins Dreieck. Was im if steht, kommt in die ja-Spalte, was im else steht, in die nein-Spalte. Im PAP wird der rekursive Aufruf ein UP-Kasten.
flowchart TD
S([Start: vielfaches x, n]) --> B{n == 1 ?}
B -- ja --> R1[Rückgabe x]
B -- nein --> U[[h = vielfaches x, n-1]]
U --> R2[Rückgabe x + h]
R1 --> E([Ende])
R2 --> E
flowchart TD
S([Start: potenz basis, exponent]) --> B{exponent == 0 ?}
B -- ja --> R1[Rückgabe 1]
B -- nein --> U[[h = potenz basis, exponent-1]]
U --> R2[Rückgabe basis * h]
R1 --> E([Ende])
R2 --> E
Nur das Malnehmen ändert sich: Statt basis * h steht ein zweiter UP-Aufruf vielfaches(basis, h). Für vielfaches gibt es ein eigenes Struktogramm (Lösung 1).
flowchart TD
S([Start: potenz x, n]) --> B{n == 0 ?}
B -- ja --> R1[Rückgabe 1]
B -- nein --> U1[[h = potenz x, n-1]]
U1 --> U2[[e = vielfaches x, h]]
U2 --> R2[Rückgabe e als int]
R1 --> E([Ende])
R2 --> E
this.___ aufgerufen werden und brauchen vorne public static, weil wir keinen objektorientierten Ansatz haben.static heißt: automatisch da, ohne dass wir das Programm selbst erzeugen müssen, und genau einmal da. Gut für ein Hauptprogramm.this.___ geht nicht mehr.main macht new Klasse(), der Konstruktor ruft this.myMainProgram() auf. Damit braucht man this.___ und static an den UPs nicht mehr.// klassisch: alles static
public class Klassisch {
static void up() {
System.out.println("UP");
}
public static void main(String[] args) {
up();
}
}
// OOP-Ansatz (HalloWeltOOP)
public class HalloWeltOOP {
public HalloWeltOOP () {
this.myMainProgram();
}
public static void main(String[] args) {
new HalloWeltOOP();
}
void up() {
System.out.println("UP");
}
public void myMainProgram() {
System.out.println("Hallo Welt");
this.up();
}
}
Beide Programme sind unabhängig. Beide kompilieren nicht. Korrigiere die Fehler.
// a) Programm 1
public class GehtNicht1 {
public void up() {
System.out.println("UP");
}
public static void main(String[] args) {
System.out.println("HP Anfang");
this.up();
System.out.println("HP Ende");
}
}
// b) Programm 2
public class GehtNicht2 {
public GehtNicht2 () {
this.myMainProgramm();
}
public static void main(String[] args) {
new GehtNicht();
}
public static void up() {
System.out.println("UP");
}
public void myMainProgram() {
System.out.println("HP Anfang");
this.up();
System.out.println("HP Ende");
}
}
this in einer static-Methode?new …() exakt gleich?a) In static main gibt es kein this → up();. Und weil main static ist, muss auch up static sein → public static void up().
b) myMainProgramm hat ein m zu viel → this.myMainProgram();. Die Klasse heißt GehtNicht2 → new GehtNicht2();. Sauber nach OOP-Ansatz: bei up() das static weglassen.
Im Java-Trainer kannst du beide Programme am PC reparieren (Aufgaben „GehtNicht1“ und „GehtNicht2“).
| Code | Name | Bedeutung | bei x=5 liefert | x danach |
|---|---|---|---|---|
| x++ | Postinkrement | erst benutzen, dann +1 | 5 | 6 |
| ++x | Präinkrement | erst +1, dann benutzen | 6 | 6 |
| x-- | Postdekrement | erst benutzen, dann −1 | 5 | 4 |
| --x | Prädekrement | erst −1, dann benutzen | 4 | 4 |
a++ ist nicht „a + 1“. Es ist die Kurzform von a = a + 1. Die Variable wird also wirklich verändert und gespeichert, egal ob ++ vorne oder hinten steht. Vorne oder hinten entscheidet nur, welchen Wert der Ausdruck in dieser Zeile liefert. Entscheidend ist, ob der Operator vor oder nach dem Bezeichner steht: Entsprechend wird vor oder nach der Ausgabe erhöht oder verringert.
Darum bei jeder Zeile zwei Dinge mitschreiben: was kommt raus und welchen Wert hat die Variable danach.
int intZahl; intZahl = 5; intZahl++; System.out.println(intZahl); // a System.out.println(intZahl++); // b System.out.println(intZahl); // c System.out.println(++intZahl); // d System.out.println(intZahl); // e System.out.println(intZahl--); // f System.out.println(intZahl); // g System.out.println(--intZahl); // h System.out.println(intZahl); // i
| Zeile | Ausgabe | intZahl danach | warum |
|---|---|---|---|
| intZahl++; | – | 6 | steht allein, einfach +1 |
| a | 6 | 6 | nur ausgeben |
| b | 6 | 7 | Postinkrement: erst ausgeben, dann +1 |
| c | 7 | 7 | nur ausgeben |
| d | 8 | 8 | Präinkrement: erst +1, dann ausgeben |
| e | 8 | 8 | nur ausgeben |
| f | 8 | 7 | Postdekrement: erst ausgeben, dann −1 |
| g | 7 | 7 | nur ausgeben |
| h | 6 | 6 | Prädekrement: erst −1, dann ausgeben |
| i | 6 | 6 | nur ausgeben |
int intZahl=8;
intZahl--;
System.out.print("a: ");
System.out.println(intZahl);
System.out.print("b: ");
System.out.println(intZahl--);
System.out.print("c: ");
System.out.println(intZahl);
System.out.print("d: ");
System.out.println(--intZahl);
System.out.print("e: ");
System.out.println(intZahl);
System.out.print("f: ");
System.out.println(++intZahl);
System.out.print("g: ");
System.out.println(intZahl);
System.out.print("h: ");
System.out.println(intZahl++);
System.out.print("i: ");
System.out.println(intZahl);
| Zeile | Ausgabe | intZahl danach |
|---|---|---|
| intZahl--; | – | 7 |
| a: intZahl | 7 | 7 |
| b: intZahl-- | 7 | 6 |
| c: intZahl | 6 | 6 |
| d: --intZahl | 5 | 5 |
| e: intZahl | 5 | 5 |
| f: ++intZahl | 6 | 6 |
| g: intZahl | 6 | 6 |
| h: intZahl++ | 6 | 7 |
| i: intZahl | 7 | 7 |
public class Test12345 {
public static void main(String[] args) {
int i=1;
System.out.println(i=i++);
} // end of main
} // end of class Test12345
Java rechnet zuerst die rechte Seite i++: Die liefert den alten Wert 1 und setzt i auf 2. Dann kommt die Zuweisung i = 1 und schreibt die 2 wieder kaputt. Die Zuweisung liefert 1, also wird 1 ausgegeben.
Die Lektion aus dem OneNote: So etwas macht man nicht. Keine Hintereinanderausführung, möglichst kleinzeilig. Zerlegen, zerlegen, zerlegen.
double d = 5; → 5.0double d=20.5; int i=(int)d; → 20. Kommazahlen werden abgeschnitten und nicht gerundet. Einfach, funktioniert aber nicht immer.Integer.parseInt(str), Double.parseDouble(str), geht auch für andere Datentypen. Laut OneNote „natürlich Nummer 3“ am besten.int i=999;
double d=1.1;
i=(int)d; // double in int umwandeln (per einfachem typecasting)
// Kommazahlen werden abgeschnitten und nicht gerundet
d=(double)i; // int in double umwandeln (per einfachem typecasting)
int / int ergibt int, der Rest fällt weg. Sobald ein double beteiligt ist, wird double gerechnet. double-Werte immer als double hinschreiben: 4.0, nicht 4 („Double-Werte als Double ausgeben!“).
public class Rechnung {
public static void main(String[] args) {
int a = 18;
int b = 4;
double c = 18.0;
double d = 4.0;
System.out.print("a: ");
System.out.println(a / b);
System.out.print("b: ");
System.out.println(a % b);
System.out.print("c: ");
System.out.println(a / d);
System.out.print("d: ");
System.out.println(c / d);
System.out.print("e: ");
System.out.println(c / b);
}
}
| Ausgabe | warum | |
|---|---|---|
| a: 18 / 4 | 4 | int / int: 18 : 4 = 4 Rest 2, Rest fällt weg |
| b: 18 % 4 | 2 | Modulo = der Rest |
| c: 18 / 4.0 | 4.5 | d ist double → double-Division |
| d: 18.0 / 4.0 | 4.5 | beides double |
| e: 18.0 / 4 | 4.5 | c ist double, b wird automatisch zu 4.0 (implizit) |
Schreib jeweils eine Zeile Java:
str (von readLine) soll ein double d werden.alterStr soll ein int alter werden.d soll per einfachem Typecasting ein int i werden.int zeichen soll als Zeichen ausgegeben werden.double d = Double.parseDouble(str); int alter = Integer.parseInt(alterStr); int i = (int) d; System.out.println((char) zeichen);
Regel: Kommt die Zahl als String (von readLine oder nextLine), dann parse…. Ist es schon eine Zahl und soll nur der Typ wechseln, dann (Typ) davor, allgemein (Typ) Bezeichner.
Im OneNote stehen die Programme mit tools.showMessage aus JavaKara. Hier steht dafür System.out.println, die Ausgabe ist dieselbe.
if (bed1) anw1; anw2;
int i;
for (i = 20; i > 3; i = i / 2) {
System.out.println("IN der Schleife: i hat den Wert: "+i);
}
System.out.println("AUSSERHALB der Schleife: ------");
System.out.println("AUSSERHALB der Schleife: i hat den Wert: "+i);
Start mit 20 → 20 > 3 → Ausgabe 20. Durch 2 → 10 > 3 → Ausgabe 10. Durch 2 → 5 > 3 → Ausgabe 5. Durch 2 → 2, nicht 2.5! INT geteilt durch INT gibt INT, die 2.5 wird abgeschnitten. 2 ist nicht größer als 3 → raus aus der Schleife. Außerhalb: i hat den Wert: 2.
double i;
for (i=20;i>=2.5;i=(int)i/2) {
System.out.println(""+i);
}
System.out.println("----");
System.out.println(""+i);
Was ist hier alles gemein? Eine double-Variable, die i heißt. (int)i/2: Der Cast gilt nur für i, dann int / int = int, abgeschnitten. Und beim Speichern in i wird automatisch (implizit) wieder double daraus.
20.0 → (int)20.0/2 = 10 → 10.0 → 5 → 5.0 → (int)5.0/2 = 2 → 2.0. 2.0 ist nicht ≥ 2.5 → raus. Ausgabe: 20.0, 10.0, 5.0, ----, 2.0.
int i;
int j=3;
int k=100;
int l=4;
for (i=j;i<=k;i=i+l) {
System.out.println(""+i);
l=l*2;
k=k/3;
} // end of for
| i | j | k | l | Ausgabe |
|---|---|---|---|---|
| 3 | 3 | 100 | 4 | 3 |
| 3 | 3 | 33 | 8 | danach i = 3 + 8 |
| 11 | 3 | 33 | 8 | 11 |
| 11 | 3 | 11 | 16 | danach i = 11 + 16 |
| 27 | 3 | 11 | 16 | 27 <= 11? nein → Ende |
Der Trick: k und l ändern sich in der Schleife, und die Bedingung i<=k wird jedes Mal mit dem neuen k geprüft. k = 100/3 = 33 (int-Division).
zeichen=System.in.read(); liest genau ein Zeichen und liefert den ASCII-Wert. Zeichen ausgeben: (char)zeichen (Typecast).import java.io.*;, throws IOException im Methodenkopf, BufferedReader-Objekt erzeugen.import java.io.*; ... throws IOException ... BufferedReader input = new BufferedReader( new InputStreamReader(System.in)); String str = input.readLine(); int zahl = Integer.parseInt(str);
import java.util.*; ... Scanner sc = new Scanner(System.in); String zeile = sc.nextLine(); String wort = sc.next(); int i = sc.nextInt(); double d = sc.nextDouble(); char c = sc.next().charAt(0);
| Scanner | liest | das <Enter> |
|---|---|---|
| nextLine() | die ganze Zeile, kann auch leer sein | wird mitgelesen |
| next() | ein Token bis zum Leerzeichen (Delimiter) | wird übersprungen, kann keinen leeren String zurückgeben |
| nextInt() | eine Ganzzahl | bleibt im Puffer liegen |
| nextDouble() | Kommazahl nach Spracheinstellung des PCs | bleibt im Puffer liegen |
Nach nextInt() oder nextDouble() bleibt die Return-Taste im Puffer. Ein nextLine() danach liest sofort diese leere Restzeile → "" → Double.parseDouble("") stürzt ab.
Variante 1: nach jedem nextInt/nextDouble einfach sc.nextLine(); schreiben. Dann ist die Return-Taste erledigt. Variante 2: immer mit nextLine() arbeiten und danach umwandeln (Double.parseDouble, Integer.parseInt). Variante 3: mit BufferedReader arbeiten („oldschool, aber gut“).
BufferedReader input = new BufferedReader(new [1]([2])); · String str = input.[3](); · import [4];
InputStreamReader · System.in · readLine · java.io.*. Groß- und Kleinschreibung zählt. Von innen nach außen: Tastatur (System.in) → Zeichenstrom (InputStreamReader) → Puffer (BufferedReader) → Zeile holen (readLine).
import java.util.*;
public class einfacheEingabeScanner {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
System.out.println("Wie heißt Du? Bitte im Format Vornamen Nachnamen eingeben.");
String s;
s = sc.nextLine(); // <-- Pfeil
System.out.println("Hallo, " + s + "! Schön, Dich kennen zu lernen!");
System.out.println("\n\nUnd nocheinmal!");
System.out.println("Wie heißt Du? Bitte im Format Vornamen Nachnamen eingeben.");
s = sc.next(); // Kann keinen leeren String zurückgeben A
System.out.println("Schöner Vorname: " + s);
s = sc.next(); // Kann keinen leeren String zurückgeben
System.out.println("Schöner Nachname: " + s);
System.out.println("\n");
System.out.println("Wie alt bist Du?");
int alter;
alter = sc.nextInt();
System.out.println("Ah, Du bist " + alter + " Jahre alt!");
// sc.nextLine(); // Könnte man hier machen, muss man aber nicht! B
System.out.println("\n");
System.out.println("Wie viel Geld hast Du?");
double money;
money = sc.nextDouble(); // C
System.out.println("Du bist ja reich mit " + money + " Euro!");
sc.nextLine(); // Ohne das hier tritt ein Fehler auf D
System.out.println("\n");
System.out.println("Wie groß bist Du?");
double groesse;
String strGroesse;
strGroesse = sc.nextLine();
groesse = Double.parseDouble(strGroesse);
System.out.println("Du bist ja groß mit " + groesse + " cm!");
}
}
sc.next() an Stelle A gegenüber sc.nextLine() am Pfeil?Jeweils genauer erläutern und die Funktionsweise im Hintergrund erklären.
sc.next() nutzt Tokenization: Der eingegebene String wird in Token (Teile) zerlegt. Es wird jeweils ein String-Token erwartet, und das Token kann nicht leer sein. Trennzeichen (Delimiter) ist standardmäßig das Leerzeichen. So wird sichergestellt, dass auf jeden Fall ein Vorname und ein Nachname eingegeben werden, also zwei durch Leerzeichen getrennte Strings. nextLine() liest dagegen die ganze Zeile und kann auch leer sein.
sc.nextInt() darüber hat das Enter-Zeichen nicht mitgenommen. Würde direkt danach ein String mit nextLine abgefragt, bräuchte man die Zeile B. Da danach aber mit sc.nextDouble() ein double abgefragt wird, kann man sie weglassen: nextDouble überspringt das liegengebliebene Enter. Beispiel im Puffer: <enter> 15,8 <enter>, genommen wird die 15,8.
Der Scanner nimmt die Spracheinstellung des PCs. Ein double muss bei einem deutschen PC mit Komma eingegeben werden, z. B. 12,5. Mit Punkt kommt eine InputMismatchException.
Das double davor wurde mit sc.nextDouble() gelesen. Das lässt das Enter noch stehen. Das spätere sc.nextLine() würde ohne D direkt einen leeren String lesen. Der kann nicht mit Double.parseDouble geparst werden: Es kommt eine NumberFormatException (empty String). D räumt das Enter vorher weg.
Name eingeben, begrüßen, Alter als Integer eingeben, „Du bist mindestens … Tage alt“. Das Programm kompiliert nicht.
Wie heisst Du? Oberbappo Hallo, Oberbappo Wie alt bist Du? 18 Du bist mindestens 6570 Tage alt
import java.util;
public class BufferedOOP {
public BufferedOOP () {
this.myMainProgram();
}
public static void main(String[] args) {
new BufferedOOP();
}
public void myMainProgram() throws IOException {
String name;
String alterStr;
int alter;
int tage;
BufferedReader eingabe = new BufferedReader(Scanner(in));
System.out.println("Wie heisst Du?");
name=eingabe.read();
System.out.println("Hallo, "+name);
System.out.println("Wie alt bist Du?");
alterStr=eingabe.readLine();
alter=Double.parseInteger(alterStr);
tage=alter*365;
System.out.println("Du bist mindestens "+tage+" Tage alt");
}
}
import java.util; → import java.io.*;throws IOException auch an Konstruktor und main, weil sie myMainProgram aufrufen.new BufferedReader(Scanner(in)) → new BufferedReader(new InputStreamReader(System.in))eingabe.read() liest nur ein Zeichen als int → eingabe.readLine()Double.parseInteger gibt es nicht → Integer.parseInt(alterStr)Im Java-Trainer kannst du genau dieses Programm am PC reparieren (Aufgabe „BufferedOOP korrigieren“).
Erkläre die Skizze aus dem Unterricht in eigenen Worten: System.in → InputStreamReader → BufferedReader → readLine. Gib auch die komplette Programmzeile für einen BufferedReader in Java an.
BufferedReader eingabe = new BufferedReader(new InputStreamReader(System.in));String s = eingabe.readLine();
System ist die Ein- und Ausgabe. System.in ist dabei die Eingabe, hier über die Tastatur (es könnten auch Dateien oder das Internet sein). Wenn wir Tasten drücken, gibt es einzelne Signale. Diese möchten wir nicht einzeln auswerten, sondern am Stück, z. B. als String. Dazu brauchen wir einen InputStream (InputStreamReader). Dieser hat hintereinander alle Buchstaben bzw. Tastendrücke, aber auch das <enter>. Wir möchten nun am <enter> trennen, da dieses als Zeilenumbruch gilt. Dazu puffern wir die einzelnen Zeichenabschnitte in einem BufferedReader. Aus diesem können wir dann Zeile für Zeile als String mit readLine() auslesen.
c=eingabe.next().charAt(0); // c enthält genau ein Character-Zeichen
// switch kann auch mit Characterzeichen umgehen
switch (c) {
case '+':
System.out.println("+");
erg=this.addieren(z1,z2);
System.out.println("Ergebnis ist: "+erg);
break;
...
default:
System.out.println("Vollidiot! ;-) ");
break;
}
switch kann auch mit Characterzeichen umgehen.case '+':break;, sonst läuft Java in den nächsten Fall weiter.default: = alles andere.eingabe.next().charAt(0)Programm aus der „Übungsaufgabe“: z1 (int), z2 (double), Zeichen, 4 UPs, Auswahl mit switch. Es fehlen die Scanner-Eingaben für die Zahlen und Teile des switch.
Scanner eingabe=new Scanner(System.in);
System.out.print("Geben Sie die erste Zahl ein: ");
[1]
System.out.print("Geben Sie die zweite Zahl ein: ");
[2]
System.out.print("Welche Operation soll durchgeführt werden: ");
c=eingabe.next().charAt(0);
switch ([3]) {
[4] '+':
System.out.println("+");
erg=this.addieren(z1,z2);
System.out.println("Ergebnis ist: "+erg);
[5];
...
[6]:
System.out.println("Auswahl nicht unterstützt");
}
[1] z1=eingabe.nextInt(); weil z1 int ist. [2] z2=eingabe.nextDouble(); weil z2 double ist. [3] c, unterschieden wird nach dem Zeichen. [4] case [5] break, sonst würde nach dem Addieren auch subtrahiert. [6] default.
Kein Enter-Problem: nach nextInt und nextDouble kommt next(), und das überspringt das liegengebliebene Enter. Das ganze Programm kannst du im Java-Trainer ergänzen (Aufgabe „Uebung ergänzen“).
Auf dem Desktop: Ordner Java-KA-Lernen → java-trainer → Doppelklick auf start.bat. Dort gibt es genau diese Aufgaben mit Editor, Strukturfarben wie im JavaEditor, einer Konsole zum Eintippen und automatischen Tests. Hier im Lernheft stehen dieselben Aufgaben zum Lesen, mit Lösungsweg.
throws IOException.return, Auswahl mit switch, Wiederholung mit Schleife.Name eingeben: nach dem Namen. Gib dann Guten Tag Benutzer <Name> und am Ende Programmende Eingabe. aus. Benutze BufferedReader.So soll es aussehen (grün = Eingabe)
Name eingeben: Anna
Guten Tag Benutzer Anna
Programmende Eingabe.
Drei Bestandteile laut Buch: import java.io.*;, throws IOException und das Objekt BufferedReader input = new BufferedReader(new InputStreamReader(System.in));. Dann str = input.readLine();
throws IOException an jede Methode, die liest oder eine lesende Methode aufruft: myMainProgram, Konstruktor, main.print fragen (ohne Zeilenumbruch), mit readLine() die ganze Zeile als String holen.+ zusammenbauen.import java.io.*;
public class Eingabe {
public Eingabe() throws IOException {
this.myMainProgram();
}
public static void main(String[] args) throws IOException {
new Eingabe();
}
public void myMainProgram() throws IOException {
String str;
BufferedReader input = new BufferedReader(new InputStreamReader(System.in));
System.out.print("Name eingeben: ");
str = input.readLine();
System.out.print("Guten Tag Benutzer ");
System.out.println(str);
System.out.println("Programmende Eingabe.");
}
}
Im Java-Trainer automatisch geprüft
Name eingeben: , dann Guten Tag Benutzer <Name> und Programmende Eingabe.So soll es aussehen (grün = Eingabe)
Name eingeben: Anna Berg
Guten Tag Benutzer Anna Berg
Programmende Eingabe.
import java.util.*; und Scanner input = new Scanner(System.in);. Für den ganzen Namen (mit Leerzeichen) input.nextLine(), nicht next().
throws IOException.nextLine() liest die ganze Zeile bis Enter. next() würde bei „Anna Berg“ nur „Anna“ liefern, darum fällt der Test mit Leerzeichen sonst durch.import java.util.*;
public class EingabeNEU {
public EingabeNEU() {
this.myMainProgram();
}
public static void main(String[] args) {
new EingabeNEU();
}
public void myMainProgram() {
String str;
Scanner input = new Scanner(System.in);
System.out.print("Name eingeben: ");
str = input.nextLine();
System.out.print("Guten Tag Benutzer ");
System.out.println(str);
System.out.println("Programmende Eingabe.");
}
}
Im Java-Trainer automatisch geprüft
System.in.read() genau ein Zeichen. Gib ASCII-Wert: <Zahl> aus und danach das Zeichen selbst mit Typecast (char).So soll es aussehen (grün = Eingabe)
A
ASCII-Wert: 65
ASCII-Zeichen: A
int zeichen = System.in.read(); liefert den ASCII-Wert. Zeichen ausgeben: (char) zeichen. Braucht throws IOException.
read() liest genau ein Zeichen und liefert seinen ASCII-Wert als int.(char), allgemein (Typ) Bezeichner.import java.io.*;
public class EinfachsteEingabe {
public EinfachsteEingabe() throws IOException {
this.myMainProgram();
}
public static void main(String[] args) throws IOException {
new EinfachsteEingabe();
}
public void myMainProgram() throws IOException {
int zeichen;
zeichen = System.in.read();
System.out.print("ASCII-Wert: ");
System.out.println(zeichen);
System.out.print("ASCII-Zeichen: ");
System.out.println((char) zeichen);
}
}
Im Java-Trainer automatisch geprüft
Geben Sie die erste Zahl ein: …), wandle sie mit Integer.parseInt um und gib aus: Die Summe von 3 und 4 ist: 7So soll es aussehen (grün = Eingabe)
Geben Sie die erste Zahl ein: 3 Geben Sie die zweite Zahl ein: 4 Die Summe von 3 und 4 ist: 7 Programmende Summe.
str = input.readLine(); zahl1 = Integer.parseInt(str); zweimal, dann ergebnis = zahl1 + zahl2;
Integer.parseInt(str) in int umwandeln.+ verketten.import java.io.*;
public class Summe {
public Summe() throws IOException {
this.myMainProgram();
}
public static void main(String[] args) throws IOException {
new Summe();
}
public void myMainProgram() throws IOException {
String str;
int zahl1, zahl2, ergebnis;
BufferedReader input = new BufferedReader(new InputStreamReader(System.in));
System.out.print("Geben Sie die erste Zahl ein: ");
str = input.readLine();
zahl1 = Integer.parseInt(str);
System.out.print("Geben Sie die zweite Zahl ein: ");
str = input.readLine();
zahl2 = Integer.parseInt(str);
ergebnis = zahl1 + zahl2;
System.out.println("Die Summe von " + zahl1 + " und " + zahl2 + " ist: " + ergebnis);
System.out.println("Programmende Summe.");
}
}
Im Java-Trainer automatisch geprüft
Integer.parseInt(input.nextLine()), die zweite mit Variante 2: input.nextInt().So soll es aussehen (grün = Eingabe)
Geben Sie die erste Zahl ein: 3 Geben Sie die zweite Zahl ein: 4 Die Summe von 3 und 4 ist: 7
zahl1 = Integer.parseInt(input.nextLine()); und zahl2 = input.nextInt();
import java.util.*;
public class SummeScanner {
public SummeScanner() {
this.myMainProgram();
}
public static void main(String[] args) {
new SummeScanner();
}
public void myMainProgram() {
int zahl1, zahl2, ergebnis;
Scanner input = new Scanner(System.in);
System.out.print("Geben Sie die erste Zahl ein: ");
zahl1 = Integer.parseInt(input.nextLine());
System.out.print("Geben Sie die zweite Zahl ein: ");
zahl2 = input.nextInt();
ergebnis = zahl1 + zahl2;
System.out.println("Die Summe von " + zahl1 + " und " + zahl2 + " ist: " + ergebnis);
System.out.println("Programmende Summe.");
}
}
Im Java-Trainer automatisch geprüft
nextLine() lesen, Hallo, <Name>!next(): Schöner Vorname: …, Schöner Nachname: …nextInt(): Ah, Du bist 17 Jahre alt!nextDouble() (deutscher PC: mit Komma, z. B. 12,5): Du bist ja reich mit 12.5 Euro!nextLine() + Double.parseDouble (mit Punkt): Du bist ja groß mit 180.5 cm!So soll es aussehen (grün = Eingabe)
Wie heißt Du? Anna Berg Hallo, Anna Berg! Und nocheinmal! Anna Berg Schöner Vorname: Anna Schöner Nachname: Berg Wie alt bist Du? 17 Ah, Du bist 17 Jahre alt! Wie viel Geld hast Du? 12,5 Du bist ja reich mit 12.5 Euro! Wie groß bist Du? 180.5 Du bist ja groß mit 180.5 cm!
Nach nextDouble() kommt ein nextLine() für die Größe. Dazwischen muss ein sc.nextLine(); stehen, sonst liest es die leere Restzeile und parseDouble("") stürzt ab (NumberFormatException: empty String). Nach nextInt() braucht man es nicht, weil nextDouble() das Enter überspringt.
nextLine() für den ganzen Namen mit Leerzeichen.next() liest ein Token bis zum Leerzeichen und überspringt führende Leerzeichen und Enter, darum geht danach direkt nextInt().nextInt() und nextDouble() lassen das Enter liegen.nextLine() für die Größe: sc.nextLine(); zum Wegräumen. Das ist Stelle D aus dem Test.nextDouble() will auf deutschem PC ein Komma (Spracheinstellung), Double.parseDouble immer einen Punkt.import java.util.*;
public class OOPEinfacheEingabeScanner {
public OOPEinfacheEingabeScanner() {
this.myMainProgram();
}
public static void main(String[] args) {
new OOPEinfacheEingabeScanner();
}
public void myMainProgram() {
Scanner sc = new Scanner(System.in);
String s;
System.out.println("Wie heißt Du? Bitte im Format Vornamen Nachnamen eingeben.");
s = sc.nextLine();
System.out.println("Hallo, " + s + "! Schön, Dich kennen zu lernen!");
System.out.println("Und nocheinmal!");
s = sc.next();
System.out.println("Schöner Vorname: " + s);
s = sc.next();
System.out.println("Schöner Nachname: " + s);
System.out.println("Wie alt bist Du?");
int alter;
alter = sc.nextInt();
System.out.println("Ah, Du bist " + alter + " Jahre alt!");
System.out.println("Wie viel Geld hast Du?");
double money;
money = sc.nextDouble();
System.out.println("Du bist ja reich mit " + money + " Euro!");
sc.nextLine(); // Ohne das hier tritt ein Fehler auf
System.out.println("Wie groß bist Du?");
double groesse;
String strGroesse;
strGroesse = sc.nextLine();
groesse = Double.parseDouble(strGroesse);
System.out.println("Du bist ja groß mit " + groesse + " cm!");
}
}
Im Java-Trainer automatisch geprüft
Double.parseDouble um. Gib sie aus. Wandle sie dann mit einfachem Typecasting in ein int um und gib das auch aus.So soll es aussehen (grün = Eingabe)
Kommazahl: 2.75
Als double: 2.75
Als int: 2
double d = Double.parseDouble(str); und int i = (int) d;
Double.parseDouble macht ein double daraus (geht auch für andere Datentypen).(int) d schneidet die Nachkommastellen ab, es wird nicht gerundet: 9.99 → 9.import java.io.*;
public class EingabeDouble {
public EingabeDouble() throws IOException {
this.myMainProgram();
}
public static void main(String[] args) throws IOException {
new EingabeDouble();
}
public void myMainProgram() throws IOException {
BufferedReader input = new BufferedReader(new InputStreamReader(System.in));
String str;
double d;
int i;
System.out.print("Kommazahl: ");
str = input.readLine();
d = Double.parseDouble(str);
System.out.println("Als double: " + d);
i = (int) d; // Kommazahlen werden abgeschnitten und nicht gerundet
System.out.println("Als int: " + i);
}
}
Im Java-Trainer automatisch geprüft
HP Anfang, UP, HP Ende ausgegeben wird.Beispiel
HP Anfang UP HP Ende
In einer static-Methode gibt es kein this. Und aus static main kann man nur static-Methoden direkt aufrufen.
this.up(); → up(); (kein this in static).public void up() → public static void up(), weil main static ist.Merke: Im klassischen Ansatz müssen alle UPs static sein.
public class GehtNicht1 {
public static void up() {
System.out.println("UP");
}
public static void main(String[] args) {
System.out.println("HP Anfang");
up();
System.out.println("HP Ende");
}
}
Im Java-Trainer automatisch geprüft
HP Anfang, UP, HP Ende ausgegeben wird.Beispiel
HP Anfang UP HP Ende
Startcode (so im Test bzw. OneNote)
public class GehtNicht2 {
public GehtNicht2 () {
this.myMainProgramm();
}
public static void main(String[] args) {
new GehtNicht();
}
public static void up() {
System.out.println("UP");
}
public void myMainProgram() {
System.out.println("HP Anfang");
this.up();
System.out.println("HP Ende");
}
}
Vergleiche Buchstabe für Buchstabe: Wie heißt die Methode, wie wird sie aufgerufen? Wie heißt die Klasse, was steht hinter new?
this.myMainProgramm() → this.myMainProgram() (ein m zu viel).new GehtNicht() → new GehtNicht2().up() kein static, dann passt auch this.up().public class GehtNicht2 {
public GehtNicht2 () {
this.myMainProgram();
}
public static void main(String[] args) {
new GehtNicht2();
}
public void up() {
System.out.println("UP");
}
public void myMainProgram() {
System.out.println("HP Anfang");
this.up();
System.out.println("HP Ende");
}
}
Im Java-Trainer automatisch geprüft
So soll es aussehen (grün = Eingabe)
Wie heisst Du? Oberbappo Hallo, Oberbappo Wie alt bist Du? 18 Du bist mindestens 6570 Tage alt
Startcode (so im Test bzw. OneNote)
import java.util;
public class BufferedOOP {
public BufferedOOP () {
this.myMainProgram();
}
public static void main(String[] args) {
new BufferedOOP();
}
public void myMainProgram() throws IOException {
String name;
String alterStr;
int alter;
int tage;
BufferedReader eingabe = new BufferedReader(Scanner(in));
System.out.println("Wie heisst Du?");
name=eingabe.read();
System.out.println("Hallo, "+name);
System.out.println("Wie alt bist Du?");
alterStr=eingabe.readLine();
alter=Double.parseInteger(alterStr);
tage=alter*365;
System.out.println("Du bist mindestens "+tage+" Tage alt");
}
}
Es sind 6 Stellen: Import, throws an Konstruktor und main, Scanner im BufferedReader, read statt readLine, falsche Umwandlungsmethode.
import java.util; → import java.io.*;throws IOException auch an Konstruktor und main, weil sie myMainProgram aufrufen.new BufferedReader(Scanner(in)) → new BufferedReader(new InputStreamReader(System.in))eingabe.read() liefert ein int-Zeichen → eingabe.readLine()Double.parseInteger gibt es nicht → Integer.parseInt(alterStr)Vorgehen: immer den ersten Compilerfehler beheben und neu kompilieren.
import java.io.*;
public class BufferedOOP {
public BufferedOOP () throws IOException {
this.myMainProgram();
}
public static void main(String[] args) throws IOException {
new BufferedOOP();
}
public void myMainProgram() throws IOException {
String name;
String alterStr;
int alter;
int tage;
BufferedReader eingabe = new BufferedReader(new InputStreamReader(System.in));
System.out.println("Wie heisst Du?");
name=eingabe.readLine();
System.out.println("Hallo, "+name);
System.out.println("Wie alt bist Du?");
alterStr=eingabe.readLine();
alter=Integer.parseInt(alterStr);
tage=alter*365;
System.out.println("Du bist mindestens "+tage+" Tage alt");
}
}
Im Java-Trainer automatisch geprüft
switch, die case-Zeilen, die breaks und das default. Ergänze alles. Reihenfolge der Eingabe: z1, z2, dann das Rechenzeichen.So soll es aussehen (grün = Eingabe)
Geben Sie die erste Zahl ein: 3 Geben Sie die zweite Zahl ein: 2 Welche Operation soll durchgeführt werden: * * Ergebnis ist: 6.0
Startcode (so im Test bzw. OneNote)
import java.util.*;
public class Uebung {
public Uebung () {
this.myMainProgram();
}
public static void main(String[] args) {
new Uebung();
}
double addieren(int p1, double p2) {
return p1+p2;
}
double subtrahieren(int p1, double p2) {
return p1-p2;
}
double multiplizieren(int p1, double p2) {
return p1*p2;
}
double dividieren(int p1, double p2) {
return p1/p2;
}
public void myMainProgram() {
int z1;
double z2;
char c;
double erg;
Scanner eingabe=new Scanner(System.in);
System.out.print("Geben Sie die erste Zahl ein: ");
// hier fehlt etwas
System.out.print("Geben Sie die zweite Zahl ein: ");
// hier fehlt etwas
System.out.print("Welche Operation soll durchgeführt werden: ");
c=eingabe.next().charAt(0); // c enthält genau ein Character-Zeichen
// switch kann auch mit Characterzeichen umgehen
switch ( ) {
System.out.println("+");
erg=this.addieren(z1,z2);
System.out.println("Ergebnis ist: "+erg);
System.out.println("-");
erg=this.subtrahieren(z1,z2);
System.out.println("Ergebnis ist: "+erg);
System.out.println("*");
erg=this.multiplizieren(z1,z2);
System.out.println("Ergebnis ist: "+erg);
System.out.println("/");
erg=this.dividieren(z1,z2);
System.out.println("Ergebnis ist: "+erg);
System.out.println("Auswahl nicht unterstützt");
}
}
}
z1=eingabe.nextInt(); · z2=eingabe.nextDouble(); · switch (c) { · case '+': … break; · default:
nextInt(), z2 ist double → nextDouble().switch (c).case '+':break;, sonst läuft Java in den nächsten Fall weiter (bei + käme dann auch − usw.).default: für alle anderen Zeichen.import java.util.*;
public class Uebung {
public Uebung () {
this.myMainProgram();
}
public static void main(String[] args) {
new Uebung();
}
double addieren(int p1, double p2) {
return p1+p2;
}
double subtrahieren(int p1, double p2) {
return p1-p2;
}
double multiplizieren(int p1, double p2) {
return p1*p2;
}
double dividieren(int p1, double p2) {
return p1/p2;
}
public void myMainProgram() {
int z1;
double z2;
char c;
double erg;
Scanner eingabe=new Scanner(System.in);
System.out.print("Geben Sie die erste Zahl ein: ");
z1=eingabe.nextInt();
System.out.print("Geben Sie die zweite Zahl ein: ");
z2=eingabe.nextDouble();
System.out.print("Welche Operation soll durchgeführt werden: ");
c=eingabe.next().charAt(0); // c enthält genau ein Character-Zeichen
// switch kann auch mit Characterzeichen umgehen
switch (c) {
case '+':
System.out.println("+");
erg=this.addieren(z1,z2);
System.out.println("Ergebnis ist: "+erg);
break;
case '-':
System.out.println("-");
erg=this.subtrahieren(z1,z2);
System.out.println("Ergebnis ist: "+erg);
break;
case '*':
System.out.println("*");
erg=this.multiplizieren(z1,z2);
System.out.println("Ergebnis ist: "+erg);
break;
case '/':
System.out.println("/");
erg=this.dividieren(z1,z2);
System.out.println("Ergebnis ist: "+erg);
break;
default:
System.out.println("Auswahl nicht unterstützt");
break;
}
}
}
Im Java-Trainer automatisch geprüft
HalloWeltOOP komplett selbst, ohne Vorlage: Konstruktor ruft this.myMainProgram() auf, main erzeugt mit new das Objekt, ein UP up() (ohne static) gibt UP aus, myMainProgram() gibt Hallo Welt aus und ruft this.up() auf.Beispiel
Hallo Welt UP
Konstruktor = Name der Klasse, kein Rückgabetyp. main bleibt public static void main(String[] args) und macht nur new HalloWeltOOP();.
static heißt: automatisch da, genau einmal da. Darum ist main static.new ein Objekt, dabei läuft der Konstruktor.this.myMainProgram() auf. Ab hier sind wir im Objekt, also gehen this. und UPs ohne static.public class HalloWeltOOP {
public HalloWeltOOP () {
this.myMainProgram();
}
public static void main(String[] args) {
new HalloWeltOOP();
}
void up() {
System.out.println("UP");
}
public void myMainProgram() {
System.out.println("Hallo Welt");
this.up();
}
}
Im Java-Trainer automatisch geprüft
class Test eine Methode public static int vielfaches(int x, int n) (rekursiv). main gibt mit einer for-Schleife vielfaches(7, i) für i = 1 bis 10 aus, jede Zahl in einer eigenen Zeile.Beispiel
7 14 21 … 70
Weil main static ist und kein Objekt erzeugt wird, muss vielfaches auch public static sein. Aufruf ohne this.
if (n==1) return x; else return x + vielfaches(x, n-1);for (int i=1; i<=10; i++) { System.out.println(vielfaches(7, i)); }public class Test {
public static int vielfaches(int x, int n) {
if (n == 1) {
return x;
} else {
return x + vielfaches(x, n - 1);
}
}
public static void main(String[] args) {
for (int i = 1; i <= 10; i++) {
System.out.println(vielfaches(7, i));
}
}
}
Im Java-Trainer automatisch geprüft
double vielfaches(double x, int n), das x · n rekursiv berechnet, ohne *: x + x + … (n-mal).Beispiel
vielfaches(2.5, 4) → 10.0
if (n == 1) { return x; } else { return x + vielfaches(x, n - 1); }
import java.util.*;
public class Vielfaches {
public Vielfaches() {
this.myMainProgram();
}
public static void main(String[] args) {
new Vielfaches();
}
double vielfaches(double x, int n) {
if (n == 1) {
return x;
} else {
return x + this.vielfaches(x, n - 1);
}
}
public void myMainProgram() {
System.out.println(this.vielfaches(2.5, 4));
}
}
Im Java-Trainer automatisch geprüft
int potenz(int basis, int exponent), die die n-te Potenz rekursiv berechnet. Hoch 0 ist 1.Beispiel
potenz(5, 3) → 125 potenz(2, 0) → 1
if (exponent == 0) { return 1; } else { return basis * potenz(basis, exponent - 1); }
exponent == 1. Dann geht potenz(2, 0) in eine endlose Rekursion.import java.util.*;
public class Potenz {
public Potenz() {
this.myMainProgram();
}
public static void main(String[] args) {
new Potenz();
}
int potenz(int basis, int exponent) {
if (exponent == 0) {
return 1;
} else {
return basis * this.potenz(basis, exponent - 1);
}
}
public void myMainProgram() {
System.out.println(this.potenz(5, 3));
}
}
Im Java-Trainer automatisch geprüft
int fakultaet(int zahl), die die Fakultät einer natürlichen Zahl rekursiv berechnet.Beispiel
fakultaet(5) → 120
if (zahl == 1) { return 1; } else { return fakultaet(zahl - 1) * zahl; }
import java.util.*;
public class Fakultaet {
public Fakultaet() {
this.myMainProgram();
}
public static void main(String[] args) {
new Fakultaet();
}
int fakultaet(int zahl) {
if (zahl == 1) {
return 1;
} else {
return this.fakultaet(zahl - 1) * zahl;
}
}
public void myMainProgram() {
System.out.println(this.fakultaet(5));
}
}
Im Java-Trainer automatisch geprüft
int fibo(int n), die die n-te Fibonacci-Zahl berechnet (1, 1, 2, 3, 5, 8, 13 …). Das Hauptprogramm fragt mit Scanner, welche Fibo-Zahl man will, und gibt Die gesuchte Zahl lautet: … aus.So soll es aussehen (grün = Eingabe)
Welche Fibo Zahl willst Du? 7
Die gesuchte Zahl lautet: 13
if (n > 2) { return fibo(n-1) + fibo(n-2); } else { return 1; }
import java.util.*;
public class FibonacciRekursiv {
public FibonacciRekursiv() {
this.myMainProgram();
}
public static void main(String[] args) {
new FibonacciRekursiv();
}
int fibo(int n) {
if (n > 2) {
return this.fibo(n - 1) + this.fibo(n - 2);
} else { // Fall n<=2, also n=1 oder n=2
return 1;
}
}
public void myMainProgram() {
Scanner sc = new Scanner(System.in);
int f;
int eingabe;
System.out.print("Welche Fibo Zahl willst Du? ");
eingabe = sc.nextInt();
f = this.fibo(eingabe);
System.out.println("Die gesuchte Zahl lautet: " + f);
}
}
Im Java-Trainer automatisch geprüft
makkaroni(5), was ist brat(5)? Schreib dann beide Methoden ab und lass das Hauptprogramm beide Werte ausgeben, um dein Ergebnis zu prüfen.int makkaroni(int nudel) {
if (nudel==1) { return 1; }
else { if (nudel==2) return 2;
else return 2*makkaroni(nudel-2)+makkaroni(nudel-1);
}
}
int brat(int kartoffel) {
if (kartoffel==1) { return 1; }
else { if (kartoffel==2) return 3;
else return 3*brat(kartoffel-2)+2*brat(kartoffel-1);
}
}Beispiel
makkaroni(5) = ? brat(5) = ?
Von unten nach oben rechnen: m(1)=1, m(2)=2, m(3)=2·m(1)+m(2)=4 … Genauso bei brat.
makkaroni: m(1)=1, m(2)=2, m(3)=2·1+2=4, m(4)=2·2+4=8, m(5)=2·4+8=16. Das sind Zweierpotenzen.
brat: b(1)=1, b(2)=3, b(3)=3·1+2·3=9, b(4)=3·3+2·9=27, b(5)=3·9+2·27=81. Das sind Dreierpotenzen. (Im OneNote: „Potenz über Makkaroni und Bratkartoffel“.)
import java.util.*;
public class MakkaroniBrat {
public MakkaroniBrat() {
this.myMainProgram();
}
public static void main(String[] args) {
new MakkaroniBrat();
}
int makkaroni(int nudel) {
if (nudel == 1) {
return 1;
} else {
if (nudel == 2) {
return 2;
} else {
return 2 * this.makkaroni(nudel - 2) + this.makkaroni(nudel - 1);
}
}
}
int brat(int kartoffel) {
if (kartoffel == 1) {
return 1;
} else {
if (kartoffel == 2) {
return 3;
} else {
return 3 * this.brat(kartoffel - 2) + 2 * this.brat(kartoffel - 1);
}
}
}
public void myMainProgram() {
System.out.println("makkaroni(5) = " + this.makkaroni(5));
System.out.println("brat(5) = " + this.brat(5));
}
}
Im Java-Trainer automatisch geprüft
int potenz(int x, int n) rekursiv, aber ohne *: Das Malnehmen übernimmt double vielfaches(double x, int n) (auch rekursiv). Das Hauptprogramm gibt potenz(5, 4) aus.Beispiel
625
return (int) vielfaches((double) x, potenz(x, n - 1));
vielfaches(x, potenz(x, n-1)).import java.util.*;
public class PotenzRekursivMitVielfachemRekursiv {
public PotenzRekursivMitVielfachemRekursiv() {
this.myMainProgram();
}
public static void main(String[] args) {
new PotenzRekursivMitVielfachemRekursiv();
}
double vielfaches(double x, int n) {
if (n == 1) {
return x;
} else {
return x + this.vielfaches(x, n - 1);
}
}
int potenz(int x, int n) {
if (n == 0) {
return 1;
} else {
return (int) this.vielfaches((double) x, this.potenz(x, n - 1));
}
}
public void myMainProgram() {
int i;
i = this.potenz(5, 4);
System.out.println(i);
}
}
Im Java-Trainer automatisch geprüft
int multiplikationRekursiv(int i1, int i2) rechnet i1 · i2 rekursiv (Abbruch bei i1 == 0). int potenz(int basis, int exponent) benutzt sie statt *.Beispiel
multiplikationRekursiv(4, 3) → 12 potenz(2, 5) → 32
if (i1 == 0) return 0; else return i2 + multiplikationRekursiv(i1 - 1, i2); und in potenz: return multiplikationRekursiv(basis, potenz(basis, exponent - 1));
import java.util.*;
public class MultiplikationRekursiv {
public MultiplikationRekursiv() {
this.myMainProgram();
}
public static void main(String[] args) {
new MultiplikationRekursiv();
}
int multiplikationRekursiv(int i1, int i2) {
if (i1 == 0) {
return 0;
} else {
return i2 + this.multiplikationRekursiv(i1 - 1, i2);
}
}
int potenz(int basis, int exponent) {
if (exponent == 0) {
return 1;
} else {
return this.multiplikationRekursiv(basis, this.potenz(basis, exponent - 1));
}
}
public void myMainProgram() {
System.out.println(this.potenz(2, 5));
}
}
Im Java-Trainer automatisch geprüft
So soll es aussehen (grün = Eingabe)
Geben Sie die erste Zahl ein: 7 Geben Sie die zweite Zahl ein: 2 Welche Operation soll durchgeführt werden: / Ergebnis ist: 3.5
Die UPs heißen addieren, subtrahieren, multiplizieren, dividieren und bekommen (int p1, double p2), Rückgabe double. Zeichen: eingabe.next().charAt(0).
nextInt(), nextDouble(), next().charAt(0). Kein Enter-Problem, weil next() das Enter überspringt.import java.util.*;
public class Uebungsaufgabe {
public Uebungsaufgabe() {
this.myMainProgram();
}
public static void main(String[] args) {
new Uebungsaufgabe();
}
double addieren(int p1, double p2) {
return p1 + p2;
}
double subtrahieren(int p1, double p2) {
return p1 - p2;
}
double multiplizieren(int p1, double p2) {
return p1 * p2;
}
double dividieren(int p1, double p2) {
return p1 / p2;
}
public void myMainProgram() {
int z1;
double z2;
char c;
double erg;
Scanner eingabe = new Scanner(System.in);
System.out.print("Geben Sie die erste Zahl ein: ");
z1 = eingabe.nextInt();
System.out.print("Geben Sie die zweite Zahl ein: ");
z2 = eingabe.nextDouble();
System.out.print("Welche Operation soll durchgeführt werden: ");
c = eingabe.next().charAt(0);
switch (c) {
case '+':
erg = this.addieren(z1, z2);
System.out.println("Ergebnis ist: " + erg);
break;
case '-':
erg = this.subtrahieren(z1, z2);
System.out.println("Ergebnis ist: " + erg);
break;
case '*':
erg = this.multiplizieren(z1, z2);
System.out.println("Ergebnis ist: " + erg);
break;
case '/':
erg = this.dividieren(z1, z2);
System.out.println("Ergebnis ist: " + erg);
break;
default:
System.out.println("Vollidiot! ;-) ");
break;
}
}
}
Im Java-Trainer automatisch geprüft
holeInt für z1, holeDouble für z2, mit den 4 UPs rechnen, Das Ergebnis ist: …holeInt, Potenz doppelt rekursiv über multiplikationRekursivSo soll es aussehen (grün = Eingabe)
Was wünschen Sie? + 1. Summand 3 2. Summand 2 Das Ergebnis ist: 5.0 Was wünschen Sie? ^ Basis 2 Exponent 5 Das Ergebnis ist: 32 Was wünschen Sie? 0 Auf Wiedersehen!
Gerüst: do { str = sc.next(); c = str.charAt(0); switch (c) { … case '0': break; default: … } } while (c != '0');. holeInt: Text ausgeben, mit Scanner int lesen, zurückgeben.
int holeInt(String s), double holeDouble(String s), die 4 Rechen-UPs, multiplikationRekursiv, potenz.case '0': break; nicht vergessen, sonst meldet default bei 0 einen Fehler.c != '0' mit Hochkommas, c ist ein char.import java.util.*;
public class Taschenrechner {
public Taschenrechner() {
this.myMainProgram();
}
public static void main(String[] args) {
new Taschenrechner();
}
Scanner sc = new Scanner(System.in);
int holeInt(String s) {
System.out.println(s);
return sc.nextInt();
}
double holeDouble(String s) {
System.out.println(s);
return sc.nextDouble();
}
double addieren(int p1, double p2) {
return p1 + p2;
}
double subtrahieren(int p1, double p2) {
return p1 - p2;
}
double multiplizieren(int p1, double p2) {
return p1 * p2;
}
double dividieren(int p1, double p2) {
return p1 / p2;
}
int multiplikationRekursiv(int i1, int i2) {
if (i1 == 0) {
return 0;
} else {
return i2 + this.multiplikationRekursiv(i1 - 1, i2);
}
}
int potenz(int basis, int exponent) {
if (exponent == 0) {
return 1;
} else {
return this.multiplikationRekursiv(basis, this.potenz(basis, exponent - 1));
}
}
public void myMainProgram() {
String str;
char c;
int z1;
double z2;
do {
System.out.println("Taschenrechner: + - * / ^ 0 Ende");
System.out.println("Was wünschen Sie?");
str = sc.next();
c = str.charAt(0);
switch (c) {
case '+':
z1 = this.holeInt("1. Summand");
z2 = this.holeDouble("2. Summand");
System.out.println("Das Ergebnis ist: " + this.addieren(z1, z2));
break;
case '-':
z1 = this.holeInt("Minuend");
z2 = this.holeDouble("Subtrahend");
System.out.println("Das Ergebnis ist: " + this.subtrahieren(z1, z2));
break;
case '*':
z1 = this.holeInt("Multiplikand");
z2 = this.holeDouble("Multiplikator");
System.out.println("Das Ergebnis ist: " + this.multiplizieren(z1, z2));
break;
case '/':
z1 = this.holeInt("Dividend");
z2 = this.holeDouble("Divisor");
System.out.println("Das Ergebnis ist: " + this.dividieren(z1, z2));
break;
case '^':
int b = this.holeInt("Basis");
int e = this.holeInt("Exponent");
System.out.println("Das Ergebnis ist: " + this.potenz(b, e));
break;
case '0':
break;
default:
System.out.println("Sie haben eine fehlerhafte Eingabe gemacht");
break;
}
} while (c != '0');
System.out.println("Auf Wiedersehen! Es war mir eine Ehre!");
}
}
Im Java-Trainer automatisch geprüft
Die Zahl war zu groß! oder Die Zahl war zu klein!So soll es aussehen (grün = Eingabe)
Dein Tipp: 50 Die Zahl war zu groß! Dein Tipp: 25 Richtig! Du hast 2 Versuche gebraucht.
Zufall: int zufall = (int) (Math.random() * 100) + 1;. Schleife: do { … } while (tipp != zufall);
versuche++, mit if / else if vergleichen.import java.util.*;
public class Zahlenraten {
public Zahlenraten() {
this.myMainProgram();
}
public static void main(String[] args) {
new Zahlenraten();
}
public void myMainProgram() {
Scanner sc = new Scanner(System.in);
int zufall = (int) (Math.random() * 100) + 1;
int tipp;
int versuche = 0;
do {
System.out.print("Dein Tipp: ");
tipp = sc.nextInt();
versuche++;
if (tipp > zufall) {
System.out.println("Die Zahl war zu groß!");
} else if (tipp < zufall) {
System.out.println("Die Zahl war zu klein!");
}
} while (tipp != zufall);
System.out.println("Richtig! Du hast " + versuche + " Versuche gebraucht.");
}
}
Im Java-Trainer automatisch geprüft
Alle 6 Aufgaben des Tests sind hier im Lernheft, jeweils mit Musterlösung. Schreib sie am Montagabend in dieser Reihenfolge auf Papier, mit Timer, ohne die Lösungen anzusehen. Danach korrigieren.
| Aufgabe | Punkte | Thema | hier im Heft |
|---|---|---|---|
| 1 | 5 | GehtNicht1 und GehtNicht2 korrigieren | Aufgabe 3.2 |
| 2 | 8 | BufferedOOP korrigieren | Aufgabe 7.3 |
| 3 | 7 | Was geben die Programme aus? (a) Inkrement, (b) Rechnung | Aufgabe 4.2 und 5.1 |
| 4 | 10 | Scanner-Programm erklären, Stellen A bis D | Aufgabe 7.2 |
| 5 | 10 | Uebung ergänzen (Scanner + switch) | Aufgabe 8.1 |
| 6 | 5 | BufferedReader-Skizze erklären + Programmzeile | Aufgabe 7.4 |
| Summe | 45 | mal 2 = 90er-Schlüssel | |
Im OneNote steht auch „Alte Klassenarbeit zum Üben“ (Oktober 2020, ohne Arrays). Die Aufgabenblätter sind als Dateien eingebettet und im PDF-Export nicht lesbar. Öffne sie direkt in OneNote unter Software → Java4U → „Alte Klassenarbeit zum Üben“, zusammen mit dem Lösungsvorschlag.