JavaTutorial/PrimitiveDatentypen.java

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);

    }

}