public class PrimitiveDatentypen { // Das ist ein einzeiliger Kommentar /* Das ist ein mehrzeiliger Kommentar */ // Der Einstiegspunkt eines Programms heißt (in Java) main. // Das Konstrukt ist eine Methode. Mehr dazu gibts später. public static void main(String[] args) { // Hier kann man nun Code schreiben der dann später von oben nach unten ausgeführt wird. // Befehl für eine Textausgabe auf dem Bildschirm: System.out.println("Hallo Welt"); // Genug mit dem Intro... //----------------------------------------------------------------------------- // In Java gibt es Variablen, um Daten temporär zu speichern. Diese bekommen immer einen festen Typen zugewiesen, // sodass klar ist welche Art von Daten in den Variablen enthalten sind. Das hat einige Vorteile z.B. lassen // sich nicht einfach Buchstaben mit Zahlen multiplizieren. Nachteil: Man muss sich zuvor überlegen was in der // Variable enthalten sein soll und manchmal Daten in andere Typen konvertieren. // Wichtige Datentypen: // Wahr/Falsch boolean bit = true; // Ganzzahl (32 Bit) int ganzzahl = 0; // Ganzzahl (64 Bit) long riesenganzzahl = 0; // Kommazahl mit doppelter Präzision. Standard Kommazahl in Java double kommazahlDouble = 0.0; // Zeichenkette (eigentlich nicht primitiv aber wird in Java mehr oder weniger so behandelt) String zeichenkette = "Hier könnte Ihre Werbung stehen!"; // Eher selten verwendete primitive Datentypen: // Ganzzahl (8 Bit) byte ganzzahlbyte = 127; // Ganzzahl (16 Bit) short ganzzahlshort = 0; // Kommazahl (wird in Java seltener verwendet, da etwas ungenauer) float kommazahl = 0.0f; // Ein einzelner Buchstabe char buchstabe = 'a'; //----------------------------------------------------------------------------- // Rechnen // Es gibt die ganz normalen Rechenzeichen, also: // * Multiplikation // / Division // + Addition // - Subtraktion // Beispiele: int ganzzahlAddition = 1 + 1; int ganzzahlMultiplikation = 2 * 2; System.out.println("Ergebnisse: Addition: " + ganzzahlAddition + " Multiplikation: " + ganzzahlMultiplikation); // Obacht! Ganzzahl Division kann schief laufen. Bsp.: // Rechne 2 / 4 ==> Ergebnis ist keine Ganzzahl. int obachtDivision = ganzzahlAddition / ganzzahlMultiplikation; System.out.println("Erwarte Zahl 1/2, Ergebnis: " + obachtDivision); // Begründung: Beide Zahlen sind Integer, weshalb eine Integer-Division ausgeführt wird. // Dabei wird das Ergebnis ganz normal berechnet, jedoch alle Zahlen hinter dem Komma abgeschnitten. // Bspw. würde 1.9 nicht zu 2 gerundet werden, sondern die 9 abgeschnitten, also Ergebnis 1. // Wie kann das behoben werden? // Durch Casting! // Casting bedeutet gießen auf Deutsch. Das heißt man "gießt" einen Datentypen in einen anderen. // In die größer Richtung (kleiner nach größer, also bspw. int --> float --> double) geht das auch ohne Verluste. // Die andere Richtung geht auch, jedoch mit Informationsverlust. double division = ganzzahlAddition / (double)ganzzahlMultiplikation; System.out.println("Ergebnis Division: " + division); // Kurzschreibweisen: // Will man eine Rechenoperation auf eine Variable ausführen und direkt wieder in diese hinein schreiben, // kann man das so schreiben: int pluseins = 0; pluseins = pluseins + 1; // Damit wurde die Variable pluseins um 1 erhöht. // Um nicht den Variablennamen zweimal schreiben zu müssen, kann man auch die Kurzform nutzen: pluseins += 1; // Dies geht auch mit anderen Operatoren z.B.: // += Addition // -= Subtraktion // *= Multiplikation // /= Division // Für Addition und Subtraktion gibt es noch eine weitere Kurzform, da plus/minus 1 besonders oft verwendet wird: pluseins++; // Um die Variable um 1 zu erhöhen pluseins--; // Um die Variable um 1 zu verkleinern // ---------------------------------------------------------- // Zeichenketten: Können in Java ganz einfach mit einem + verkettet werden. // Bspw.: String str1 = "Ananas"; String str2 = "Cocobello"; 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); } }