Bis jetzt haben wir die grundlegenden Datentypen kennen gelernt und mit ihnen gerechnet. Als nächstes führen wir Fallunterscheidungen ein, denn oft müssen je nach Bedarf einmal die einen, ein anderes Mal andere Anweisungen durchgeführt werden.
In Java kann man mehrere Anweisungen die zusammen gehören in einem Block zusammenfassen. Ein Block verhält sich dann wie eine einzelne Anweisung, die mehrere Schritte macht.
{
Anweisung;
Anweisung;
}
In Java ist die "if-Anweisung" ein grundlegendes Konstrukt der Programmierung, das verwendet wird, um Entscheidungen in einem Programm zu treffen. Mit der if-Anweisung kann ein Programm einen bestimmten Codeblock ausführen, wenn eine Bedingung erfüllt ist, andernfalls wird ein anderer Codeblock übersprungen. Die Syntax der if-Anweisung in Java ist wie folgt:
if (Bedingung) {
// Codeblock, der ausgeführt wird, wenn die Bedingung wahr (true) ist
} else {
// Codeblock, der ausgeführt wird, wenn die Bedingung falsch (false) ist
}
Die "Bedingung" ist ein Ausdruck, der einen booleschen Wert (true oder false) zurückgibt. Wenn die Bedingung wahr ist (true), wird der Codeblock innerhalb der geschweiften Klammern nach dem "if" ausgeführt. Wenn die Bedingung falsch ist (false), wird der Codeblock innerhalb der geschweiften Klammern nach dem "else" (optional) ausgeführt.
Hier ist ein einfaches Beispiel für die Verwendung der if-Anweisung in Java:
int alter = 25;
if (alter >= 18) {
System.out.println("Sie sind volljährig.");
} else {
System.out.println("Sie sind minderjährig.");
}
}
In Java können Sie eine if-Anweisung mit mehreren Möglichkeiten erstellen, indem Sie die if-else if-else Struktur verwenden. Dies ermöglicht es Ihnen, mehrere Bedingungen in einer Sequenz zu überprüfen und verschiedene Aktionen basierend auf dem Ergebnis der Bedingungen auszuführen. Die allgemeine Syntax sieht folgendermaßen aus:
Dafür können wir natürlich mehrere if-Abfragen machen:
if (Bedingung1) {
// Codeblock, der ausgeführt wird, wenn Bedingung1 wahr (true) ist
} else if (Bedingung2) {
// Codeblock, der ausgeführt wird, wenn Bedingung1 falsch (false) und Bedingung2 wahr (true) ist
} else if (Bedingung3) {
// Codeblock, der ausgeführt wird, wenn Bedingung1 und Bedingung2 falsch (false) und Bedingung3 wahr (true) ist
} else {
// Codeblock, der ausgeführt wird, wenn keine der vorherigen Bedingungen wahr (true) ist
}
Java überprüft die Bedingungen in der Reihenfolge, wie sie in der if-else if-else Struktur aufgeführt sind. Wenn die erste Bedingung wahr (true) ist, wird der zugehörige Codeblock ausgeführt, und der Rest der Struktur wird übersprungen. Wenn die erste Bedingung falsch (false) ist, wird die nächste Bedingung in der Struktur überprüft, und so weiter, bis eine wahre Bedingung gefunden wird oder der "else"-Block erreicht wird. Hier ist ein Beispiel für eine if-Anweisung mit mehreren Möglichkeiten:
int zahl = 5;
if (zahl > 0) {
System.out.println("Die Zahl ist positiv.");
} else if (zahl < 0) {
System.out.println("Die Zahl ist negativ.");
} else {
System.out.println("Die Zahl ist null.");
}
In Java gibt es die "switch-Anweisung", die verwendet wird, um eine Vielzahl von Bedingungen basierend auf einem einzelnen Ausdruck zu überprüfen. Die switch-Anweisung bietet eine alternative Möglichkeit, mehrere Bedingungen in einem Programm zu überprüfen, anstelle der if-else if-else Struktur. Die switch-Anweisung ist besonders nützlich, wenn Sie eine bestimmte Variable auf verschiedene Werte überprüfen möchten.
Die allgemeine Syntax der switch-Anweisung in Java sieht folgendermaßen aus:
switch (Ausdruck) {
case Wert1:
// Codeblock, der ausgeführt wird, wenn der Ausdruck den Wert1 entspricht
break;
case Wert2:
// Codeblock, der ausgeführt wird, wenn der Ausdruck den Wert2 entspricht
break;
// Weitere case-Anweisungen können hinzugefügt werden
default:
// Codeblock, der ausgeführt wird, wenn der Ausdruck keinen der zuvor angegebenen Werte entspricht
}
Der "Ausdruck" ist eine Variable oder ein Ausdruck, der ausgewertet wird, um einen Wert zu erhalten. Die switch-Anweisung überprüft den Wert des Ausdrucks und führt den entsprechenden Codeblock aus, der mit dem entsprechenden Wert übereinstimmt. Wenn kein passender Wert gefunden wird, wird der Codeblock im "default"-Zweig ausgeführt. Beachten Sie, dass nach jedem Codeblock innerhalb der switch-Anweisung das Schlüsselwort "break" verwendet wird, um die switch-Anweisung zu beenden. Dadurch wird verhindert, dass die Ausführung in den nächsten Codeblock überspringt. Wenn "break" nicht verwendet wird, wird die Ausführung bis zum nächsten "break" oder bis zum Ende der switch-Anweisung fortgesetzt.
Hier ist ein Beispiel für die Verwendung der switch-Anweisung in Java:
int tag = 4;
String wochentag;
switch (tag) {
case 1:
wochentag = "Montag";
break;
case 2:
wochentag = "Dienstag";
break;
case 3:
wochentag = "Mittwoch";
break;
case 4:
wochentag = "Donnerstag";
break;
case 5:
wochentag = "Freitag";
break;
case 6:
wochentag = "Samstag";
break;
case 7:
wochentag = "Sonntag";
break;
default:
wochentag = "Ungültiger Tag";
}
System.out.println("Der " + tag + ". Tag der Woche ist " + wochentag);
In diesem Beispiel wird der Wert der Variable "tag" auf 4 gesetzt. Die switch-Anweisung überprüft den Wert von "tag" und weist den entsprechenden Wochentag an die Variable "wochentag" zu. In diesem Fall wird der Ausdruck "tag" mit dem Wert 4 übereinstimmen, und daher wird die Ausgabe "Der 4. Tag der Woche ist Donnerstag" erzeugt.
In Java gibt es verschiedene Arten von Schleifen, die verwendet werden, um bestimmte Anweisungen oder Codeblöcke mehrmals auszuführen, solange eine bestimmte Bedingung erfüllt ist. Schleifen ermöglichen es, Aufgaben zu automatisieren und repetitive Aufgaben effizient zu erledigen.
Die gängigsten Arten von Schleifen in Java sind die "for-Schleife", die "while-Schleife" und die "do-while-Schleife". Jede Schleifenart hat ihre eigenen Verwendungszwecke und Syntaktik:
for-Schleife: Die for-Schleife wird verwendet, wenn die Anzahl der Schleifendurchläufe im Voraus bekannt ist. Die Syntax der for-Schleife ist wie folgt:
for (Anfangswert; Bedingung; Schritt) {
// Codeblock, der wiederholt ausgeführt wird, solange die Bedingung wahr (true) ist
}
for (int i = 1; i <= 5; i++) {
System.out.println("Schleifendurchlauf #" + i);
}
Die while-Schleife wird verwendet, wenn die Anzahl der Schleifendurchläufe im Voraus nicht bekannt ist, sondern von einer Bedingung abhängt. Die Syntax der while-Schleife ist wie folgt:
while (Bedingung) {
// Codeblock, der wiederholt ausgeführt wird, solange die Bedingung wahr (true) ist
}
Beispiel:
int i = 1;
while (i <= 5) {
System.out.println("Schleifendurchlauf #" + i);
i++;
}
do-while-Schleife: Die do-while-Schleife ist ähnlich wie die while-Schleife, mit dem Unterschied, dass der Codeblock zuerst einmal ausgeführt wird und dann die Bedingung überprüft wird. Dadurch wird sichergestellt, dass der Codeblock mindestens einmal ausgeführt wird, selbst wenn die Bedingung von Anfang an falsch ist. Die Syntax der do-while-Schleife ist wie folgt:
do {
// Codeblock, der wiederholt ausgeführt wird, solange die Bedingung wahr (true) ist
} while (Bedingung);
int i = 1;
do {
System.out.println("Schleifendurchlauf #" + i);
i++;
} while (i <= 5);
Alle drei Arten von Schleifen haben ihre eigenen Verwendungszwecke, und die Auswahl der richtigen Schleifenart hängt von den spezifischen Anforderungen Ihres Programms ab. Sie können Schleifen verwenden, um Codeblöcke zu wiederholen, Daten zu durchlaufen oder andere wiederkehrende Aufgaben zu erledigen.
In Java können Sie verschachtelte Schleifen erstellen, indem Sie eine Schleife innerhalb einer anderen Schleife platzieren. Das ermöglicht es Ihnen, mehrere Schleifendurchläufe in einer komplexen Struktur auszuführen, um verschiedene Aufgaben zu erledigen. Verschachtelte Schleifen sind besonders nützlich, wenn Sie mit mehrdimensionalen Arrays arbeiten oder Muster und Matrizen erzeugen möchten.
Die Syntax für verschachtelte Schleifen sieht folgendermaßen aus:
for (initialisierung1; bedingung1; inkrement1) {
// Codeblock 1
for (initialisierung2; bedingung2; inkrement2) {
// Codeblock 2
}
}
//Hier ist ein Beispiel für eine verschachtelte for-Schleife:
for (int i = 1; i <= 5; i++) {
for (int j = 1; j <= 5; j++) {
System.out.print(i +""+ j +" ");
}
System.out.println();
}
In diesem Beispiel wird eine verschachtelte for-Schleife verwendet, um eine Matrix auszugeben. Sowohl die äußere als auch die innere Schleife werden fünfmal (i von 1 bis 5) durchlaufen.
Spalte
11 12 13 14 15 Zeile
21 22 23 24 25
31 32 33 34 35
41 42 43 44 45
51 52 53 54 55
Sie können auch verschachtelte while-Schleifen oder do-while-Schleifen verwenden, indem Sie die entsprechende Syntax ändern. Das Prinzip der Verschachtelung bleibt jedoch das gleiche, unabhängig von der Schleifenart. Es ist wichtig, vorsichtig mit verschachtelten Schleifen umzugehen, da sie leicht zu einer komplexen und schwer zu verstehenden Codebasis führen können. Stellen Sie sicher, dass Ihre verschachtelten Schleifen ordnungsgemäß funktionieren und die erwarteten Ergebnisse liefern, und verwenden Sie sie nur, wenn sie wirklich notwendig sind.
1)Schreibe ein Java-Programm, das den Benutzer nach seinem Alter fragt. Überprüfe dann mit Hilfe einer if-Anweisung, ob die Person alt genug ist, um einen Führerschein zu erhalten.
public class Fuehrerschein {
import java.util.Scanner;
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
System.out.println("Geben Sie Ihr Alter ein:");
int alter = scanner.nextInt();
/* TODO: Überprüfung des Alters mit if-Anweisung*/
System.out.println("Sie sind alt genug, um einen Führerschein zu erhalten.");
System.out.println("Sie sind noch nicht alt genug, um einen Führerschein zu erhalten.");
}
}
}
2)Schreibe ein Java-Programm, das das Bankkonto eines Benutzers überprüft. Der Benutzer wird nach seinem Kontostand gefragt. Wenn der Kontostand größer oder gleich 1000 ist, soll das Programm "Sie haben genug Geld auf Ihrem Konto" ausgeben. Andernfalls, wenn der Kontostand größer oder gleich 500 ist, aber weniger als 1000, soll das Programm "Ihr Kontostand ist ausreichend, aber Sie könnten mehr sparen" ausgeben. Wenn der Kontostand kleiner als 500 ist, soll das Programm "Sie müssen dringend mehr Geld sparen" ausgeben.
import java.util.Scanner;
public class BankkontoPruefung {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
System.out.print("Geben Sie Ihren Kontostand ein: ");
double kontostand = scanner.nextDouble();
// Überprüfung des Kontostands und entsprechende Meldungen ausgeben
System.out.println("Sie haben genug Geld auf Ihrem Konto.");
System.out.println("Ihr Kontostand ist ausreichend, aber Sie könnten mehr sparen.");
System.out.println("Sie müssen dringend mehr Geld sparen.");
}
}
3)Schreibe ein Java-Programm, das den Benutzer nach einer Schulnote (zwischen 1 und 6) fragt und dann die entsprechende Notenbezeichnung ausgibt. Verwende dafür eine Switch-Case-Anweisung. Das Programm soll folgende Schritte ausführen: Fordere den Benutzer auf, eine Note zwischen 1 und 6 einzugeben. Lese die eingegebene Note ein. Verwende eine Switch-Case-Anweisung, um die eingegebene Note in die entsprechende Notenbezeichnung umzuwandeln: 1: entspricht "Sehr gut" 2: entspricht "Gut" 3: entspricht "Befriedigend" 4: entspricht "Ausreichend" 5: entspricht "Mangelhaft" 6: entspricht "Ungenügend" Gib die entsprechende Notenbezeichnung aus. Falls der Benutzer eine Zahl außerhalb des Bereichs von 1 bis 6 eingibt, gib eine Fehlermeldung aus.
import java.util.Scanner;
public class SchulnotenBerechnung {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
System.out.println("Bitte geben Sie die Note als Zahl ein (1-6): ");
int note = scanner.nextInt();
//TODO
//switch (note)
}
}
}
4) Erstellen Sie ein Java-Programm, das die Zahlen von 1 bis 50 ausgibt. Für jede Zahl soll überprüft werden, ob sie sowohl durch 3 als auch durch 5 ohne Rest teilbar ist. Falls eine Zahl diese Bedingung erfüllt, geben Sie aus: "Die Zahl X ist durch 3 und 5 teilbar." Andernfalls geben Sie aus: "Die Zahl X ist nicht durch 3 und 5 teilbar." Ersetzen Sie dabei "X" durch die jeweilige Zahl. Verwenden Sie dafür eine for-Schleife zum Zählen von 1 bis 50 und eine while-Schleife zum Zählen von 50 bis 1.
public class Teilbarkeitspruefung {
public static void main(String[] args) {
for (.......) {
//TODO
}
while (.......) {
//TODO
}
}
}
5)Schreiben Sie ein Programm, das „Sterndreiecke“ folgender Art ausgibt.
a) b)
* ******
** *****
*** ****
**** ***
***** **
****** *
c) d)
* ******
** *****
*** ****
**** ***
***** **
****** *