structix/JavaTutorial
1
0
Fork 0
Code Issues 1 Pull Requests Projects Releases Wiki Activity

Update PrimitiveDatentypen and BedingungenSchleifen

Browse Source
This commit is contained in:
structix
2022-01-25 18:17:37 +01:00
parent 83a23a0645
commit c7f1574eb8
3 changed files with 191 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

156
BedingungenSchleifen.java
View File

@@ -46,5 +46,161 @@ public class BedingungenSchleifen {
// -------------------------------------------------- // --------------------------------------------------
// Bedingungen: // Bedingungen:
// Mit if-Anweisungen kann man basierend auf Bedingungen Code ausführen.
int zehn = 10;
// Folgend zwei Beispiele einer einfachen if-Anweisung:
if (zehn == 10) {
System.out.println("Dieser Code wird ausgeführt.");
}
// Da die Bedingung nicht erfüllt ist, wird der Code in den geschweiften Klammern nicht ausgeführt.
if (zehn != 10) {
System.out.println("Dieser Code wird nicht ausgeführt.");
}
// Oft soll bei wahr/falsch der Bedingung jeweils Code ausgeführt werden. Damit man nicht zwei einzelne if-Anweisungen
// schreiben muss, gibt es das if-else-Konstrukt:
if (zehn == 10) {
System.out.println("Variable hat den Wert 10.");
} else {
System.out.println("Variable hat nicht den Wert 10.");
}
// Sollen jetzt mehrere Abfragen ineinander geschachtelt werden, gibt es den else-if-Befehl, um tiefere Schachtelung zu vermeiden.
// Bsp. was mit tieferer Schachtelung gemeint ist: Bei den Werten 10, 11, 12 (und der Rest) sollen unterschiedliche
// Ausgaben auf dem Bildschirm erscheinen.
// Methode mit Schachtelung:
if (zehn == 10) {
System.out.println("Die Bedingung ist wahr. Der Wert ist 10.");
} else {
// Erste Schachtelung
if (zehn == 11) {
System.out.println("Fast wahr. Eins daneben. Der Wert ist 11.");
} else {
// Zweite Schachtelung
if (zehn == 12) {
System.out.println("Second first try. Der Wert ist 12.");
} else {
// Allgemeiner Fall
System.out.println("Der Wert ist irgendwas anderes... Wert: " + zehn);
}
}
}
// Methode mit else-if Konstrukt:
if (zehn == 10) {
System.out.println("Die Bedingung ist wahr. Der Wert ist 10.");
} else if (zehn == 11) {
System.out.println("Fast wahr. Eins daneben. Der Wert ist 11.");
} else if (zehn == 12) {
System.out.println("Second first try. Der Wert ist 12.");
} else {
// Allgemeiner Fall
System.out.println("Der Wert ist irgendwas anderes... Wert: " + zehn);
}
// Sollen in einem Programm nur Fälle unterschieden werden, wie im letzten Beispiel, dann kann auch ein
// switch-case-Konstrukt verwendet werden. Switch kann nur Vergleiche (bspw. a == 2) prüfen und keine Bedingungen,
// also bspw. a > 5.
// Die Switch Anweisung hat sich über die Java Versionen stark verändert. In anderen Programmiersprachen lassen
// sich nur Integer miteinander vergleichen. Ab Java 8 wurden hingegen auch Strings und Enums (mehr dazu später)
// hinzugefügt. In neueren Versionen wurde der Switch weiter angepasst. Dazu gibt es in diesem Kapitel noch einen
// kleinen Exkurs, welcher aber für den Anfang nicht relevant sein dürfte.
// Klassischer Switch:
// Einem switch wird eine Variable übergeben, welche dann auf Fälle (case) geprüft werden.
// Mit der Anweisung break; wird der Switch verlassen. Dies ist wichtig, da ab einem case-label ausgeführt wird.
// Das bedeutet: ist ein Fall eingetroffen, wird ab dort alles ausgeführt. Dieses Verfahren erscheint wahrscheinlich
// erstmal sinnlos, hat jedoch seinen Sinn, falls mehrere cases den gleichen Code ausführen sollen.
// Beispiel von vorher:
switch (zehn) {
case 10:
System.out.println("Die Bedingung ist wahr. Der Wert ist 10.");
break;
case 11:
System.out.println("Fast wahr. Eins daneben. Der Wert ist 11.");
break;
case 12:
System.out.println("Second first try. Der Wert ist 12.");
break;
default: // Allgemeiner Fall heißt default-case
System.out.println("Der Wert ist irgendwas anderes... Wert: " + zehn);
break; // Ist nicht nötig
}
// Möchte man z.B. die gleiche Ausgabe für die Werte 9, 10 und 11, dann wird das break; weggelassen und der Code
// ab dem entsprechenden case ausgeführt. Bsp.:
switch (zehn) {
case 9:
case 10:
case 11:
System.out.println("Wir sind im Fall 9-11");
break;
case 12:
System.out.println("Hier sind wir im Fall 12");
break;
default:
System.out.println("Default case.");
}
// Probier einfach mal aus, was passieren würde, wenn die break; Befehle weg sind.
// Seit Java 8 geht das auch mit Strings, also hier ein kleines Beispiel:
String wochentag = "di";
switch (wochentag) {
case "mo":
case "di":
case "mi":
case "do":
case "fr":
System.out.println("Ganz normaler Wochentag");
break;
case "sa":
case "so":
System.out.println("Wochenende");
break;
default:
System.out.println("Komischer Wochentag...");
}
// Das waren die wichtigen Dinge. Nun folgen nur noch ein paar interessante Dinge, die wahrscheinlich erst später
// relevant werden könnten.
// ----------------------------------------------------------------------
// Switch Exkurs:
// In Java 12 wurde der Switch Block erneut überarbeitet und kann nun einen Wert zurückgeben.
// Zudem können nun mehrere Labels in einem case vorkommen. Der Rückgabewert kann entweder mittels yield oder
// Pfeil -> angegeben werden (in Java 13 wurde break als Rückgabe mit dem Wort yield ersetzt).
// Das Beispiel von vorher mit Rückgabe, ob der eingegebene String ein Wochenendtag ist oder nicht.
// Funktioniert nur mit min. Java 12
boolean isWeekend = switch (wochentag) {
case "mo", "di", "mi", "do", "fr":
yield false;
case "sa", "so":
yield true;
default:
yield false;
};
System.out.println("Wochentag: " + wochentag + " ist am Wochenende: " + isWeekend);
// Oder mit Pfeil (yield und Pfeil dürfen nicht gemischt verwendet werden)
boolean isSecondWeekend = switch (wochentag) {
case "mo", "di", "mi", "do", "fr" -> false;
case "sa", "so" -> true;
default -> false;
};
System.out.println("Wochentag: " + wochentag + " ist am Wochenende: " + isSecondWeekend);
// In Java 17 wurde Pattern Matching in switches hinzugefügt. Dies ist allerdings nur ein Preview Feature,
// bedeutet man muss es explizit aktivieren und es wird eventuell in späteren Version nicht oder nicht in dieser
// Form übernommen.
} }
} }

34
PrimitiveDatentypen.java
View File

@@ -126,6 +126,40 @@ public class PrimitiveDatentypen {
String zusammengesetzt = str1 + " " + str2; String zusammengesetzt = str1 + " " + str2;
System.out.println(zusammengesetzt); System.out.println(zusammengesetzt);
// ------------------------------------------------------------
// Logik mit Booleans.
// Wird vor allem im nächsten Thema, wenn es um Bedingungen und Schleifen geht relevant.
// Alle Bedingungen in Java müssen auf einen Wahrheitswert ausgewertet werden können.
// Das heißt, man muss immer eine Bedingung finden, die mit Ja/Nein beantwortbar ist.
// Bspw.: 5 < 10 ist wahr, 5 > 10 ist falsch usw.
// Für Vergleiche gibt es folgende Zeichen:
// == Auf Gleichheit prüfen (ein einzelnes "=" ist in Java eine Zuweisung)
// != Ungleich
// > Echt größer
// >= Größer gleich
// < Echt kleiner
// <= Kleiner gleich
// Beispiele:
boolean gleichheit = 4 == 4; // Hier sieht man den Unterschied zwischen Vergleich und Zuweisung nochmal
System.out.println("Gleichheit: " + gleichheit);
boolean groesser = 4 > 5;
System.out.println("Ist 4 > 5? " + groesser);
// Booleans können mit einem ! negiert werden:
boolean nichtGroesser = !groesser;
System.out.println("Das Gegenteil von 4 > 5: " + nichtGroesser);
// Strings können in Java nicht mit == verglichen werden,
// da hiermit nur die Speicheradressen verglichen werden. Das sagt jedoch nichts über den Inhalt, dessen Gleichheit
// uns normalerweise interessiert, aus.
// Deshalb gibt es bei Strings den Operator .equals().
// Bsp.:
boolean stringGleichheit = str1.equals(str2);
System.out.println("Sind die Strings 1 und 2 gleich? " + stringGleichheit);
} }

1
README.md
View File

@@ -6,6 +6,7 @@
* Methoden * Methoden
* Arrays * Arrays
* Objekte * Objekte
* Datenstrukturen (Enums, Dynamische Arrays, Maps)
* Vererbung * Vererbung
* Polymorphismus * Polymorphismus
* Interfaces * Interfaces