From c7f1574eb85661bd17cb4259e9d45842133c0c22 Mon Sep 17 00:00:00 2001 From: structix Date: Tue, 25 Jan 2022 18:17:37 +0100 Subject: [PATCH] Update PrimitiveDatentypen and BedingungenSchleifen --- BedingungenSchleifen.java | 156 ++++++++++++++++++++++++++++++++++++++ PrimitiveDatentypen.java | 34 +++++++++ README.md | 1 + 3 files changed, 191 insertions(+) diff --git a/BedingungenSchleifen.java b/BedingungenSchleifen.java index 858163a..9fe5da8 100644 --- a/BedingungenSchleifen.java +++ b/BedingungenSchleifen.java @@ -46,5 +46,161 @@ public class BedingungenSchleifen { // -------------------------------------------------- // 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. } } diff --git a/PrimitiveDatentypen.java b/PrimitiveDatentypen.java index 0c0713f..6d52900 100644 --- a/PrimitiveDatentypen.java +++ b/PrimitiveDatentypen.java @@ -126,6 +126,40 @@ public class PrimitiveDatentypen { String zusammengesetzt = str1 + " " + str2; 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); } diff --git a/README.md b/README.md index 70448a3..80b2cbf 100644 --- a/README.md +++ b/README.md @@ -6,6 +6,7 @@ * Methoden * Arrays * Objekte +* Datenstrukturen (Enums, Dynamische Arrays, Maps) * Vererbung * Polymorphismus * Interfaces