Java: Spickzettel

1. Was ist Java?

• Java-Quellcode wird zu Bytecode, den die JVM auf jedem System ausführt
• JDK = Entwickeln, JRE/JVM = Ausführen
• Für Produktion eine LTS-Version nutzen (hier: 21)
• Java ist streng typisiert und verwaltet Speicher automatisch (Garbage Collector)
• Ab Java 11 startet java Datei.java kleine Programme direkt

java -version          # zeigt die Laufzeitumgebung
javac -version         # zeigt den Compiler (nur im JDK)

2. Das erste Programm im Detail

• Java-Code steht in Klassen; public static void main(String[] args) ist der Startpunkt
• System.out.println gibt mit Zeilenumbruch aus, printf formatiert
• Namenskonventionen: Klassen Gross, Methoden/Variablen klein, Konstanten GROSS
• Dateiname = Name der öffentlichen Klasse
• Javadoc-Kommentare beschreiben die API

public class Hallo {
    public static void main(String[] args) {
        System.out.println("Hallo, Welt!");
        System.out.print("Ohne Zeilenumbruch, ");
        System.out.println("dann geht es weiter.");
        System.out.printf("Zahl: %d, Kommazahl: %.2f, Text: %s%n", 42, 3.14159, "Java");
    }
}

3. Variablen und Datentypen

• Primitive Typen: byte, short, int, long, float, double, char, boolean; String ist eine Klasse
• int und double sind die Standardtypen
• var lässt den Compiler den Typ erkennen; final macht eine Variable unveränderlich
• Casting (int) x schneidet ab; 7 / 2 ist 3
• Objekte mit .equals() vergleichen; Geld mit BigDecimal

public class Typen {
    public static void main(String[] args) {
        int alter = 17;
        long einwohner = 83_000_000L;       // Unterstriche machen Zahlen lesbar
        double preis = 19.99;
        char note = 'A';
        boolean volljaehrig = alter >= 18;
        String name = "Mia";

        System.out.println(name + " ist " + alter + ", Note " + note + ", volljährig: " + volljaehrig);
        System.out.println(einwohner + " / " + preis);
        System.out.println(Integer.MAX_VALUE + " " + Integer.MIN_VALUE + " " + Long.MAX_VALUE);
        System.out.println(Double.MAX_VALUE);
    }
}

4. Operatoren und Ausdrücke

• / bei int schneidet ab, % liefert den Rest
• == für primitive Typen; Objekte mit .equals()
• && und || werten kurz aus
• bedingung ? a : b ist die Kurzform von if/else
• instanceof mit Pattern Matching prüft und benennt in einem Schritt
• Math.addExact meldet Überläufe

public class Rechnen {
    public static void main(String[] args) {
        int a = 17, b = 5;
        System.out.println(a + " + " + b + " = " + (a + b));
        System.out.println(a / b + " Rest " + a % b);
        System.out.println((double) a / b);
        int i = 5;
        System.out.println(i++ + " " + i);     // erst benutzen, dann erhöhen
        System.out.println(++i + " " + i);     // erst erhöhen, dann benutzen
        i += 10; i *= 2;
        System.out.println(i);
        System.out.println(Math.pow(2, 10) + " " + Math.sqrt(144) + " " + Math.abs(-7) + " " + Math.max(3, 9));
        System.out.println(Math.round(2.5) + " " + Math.round(-2.5) + " " + Math.floor(-2.5) + " " + Math.ceil(2.1));
    }
}

5. Strings und Text

• Strings sind unveränderlich; Methoden liefern neue Strings
• Vergleichen mit .equals(), nie mit ==
• split, substring, replace, contains, strip, repeat, join im Alltag
• StringBuilder für viele Änderungen; Textblöcke """ für mehrzeiligen Text
• String.formatted(...) und printf formatieren
• Collator sortiert sprachrichtig

public class Texte {
    public static void main(String[] args) {
        String s = "Java macht Spaß";
        System.out.println(s.length());
        System.out.println(s.charAt(0) + " " + s.indexOf("macht") + " " + s.indexOf("x"));
        System.out.println(s.toUpperCase() + " | " + s.toLowerCase());
        System.out.println(s.substring(5) + " | " + s.substring(0, 4));
        System.out.println(s.replace("a", "4") + " | " + s.contains("Spaß") + " | " + s.startsWith("Java"));
        System.out.println("  Leerraum  ".trim() + "|" + "  Leerraum  ".strip() + "|");
        System.out.println(String.join(", ", "a", "b", "c") + " " + "ab".repeat(3) + " " + "".isEmpty() + " " + "  ".isBlank());
    }
}

6. Bedingungen: if und switch

• if-Bedingungen müssen boolean sein; immer { } setzen
• Klassisches switch braucht break; der moderne Ausdruck mit -> nicht
• switch kann einen Wert liefern, mit yield in Blöcken
• Pattern Matching zerlegt Typen und Records direkt im switch
• Früh zurückgeben statt tief verschachteln

public class Note {
    public static void main(String[] args) {
        int punkte = 73;
        if (punkte >= 90) {
            System.out.println("sehr gut");
        } else if (punkte >= 75) {
            System.out.println("gut");
        } else if (punkte >= 50) {
            System.out.println("bestanden");
        } else {
            System.out.println("nicht bestanden");
        }
    }
}

7. Schleifen

• for für feste Anzahl, while für Bedingungen, do-while läuft mindestens einmal
• for (Typ x : sammlung) ist die einfachste Art, über Arrays und Listen zu laufen
• break beendet, continue überspringt; Marken verlassen mehrere Schleifen
• Verschachtelte Schleifen bauen Tabellen und Muster

public class Zaehlen {
    public static void main(String[] args) {
        for (int i = 1; i <= 5; i++) {
            System.out.print(i + " ");
        }
        System.out.println();
        int summe = 0;
        for (int i = 1; i <= 100; i++) summe += i;
        System.out.println(summe);
        for (int i = 10; i > 0; i -= 3) System.out.print(i + " ");
        System.out.println();
    }
}

8. Methoden

• static Rückgabetyp name(Parameter) { ... return wert; }
• Parameter werden kopiert; bei Objekten der Verweis
• Überladen: gleicher Name, andere Parameter
• Varargs int... zahlen; Rekursion braucht eine Abbruchbedingung
• Eine Methode, eine Aufgabe; mit Javadoc dokumentieren

public class Methoden {
    static int addiere(int a, int b) {
        return a + b;
    }

    static void gruss(String name) {
        System.out.println("Hallo " + name + "!");
    }

    static boolean istGerade(int n) {
        return n % 2 == 0;
    }

    public static void main(String[] args) {
        System.out.println(addiere(3, 4));
        gruss("Mia");
        System.out.println(istGerade(10) + " " + istGerade(7));
        int ergebnis = addiere(addiere(1, 2), 3);
        System.out.println(ergebnis);
    }
}

9. Arrays

• int[] a = new int[5] oder {1, 2, 3}; Index ab 0; a.length ist die Größe
• Außerhalb des Bereichs gibt es eine ArrayIndexOutOfBoundsException
• Arrays.toString, sort, copyOf, fill, equals sind die wichtigsten Helfer
• Zuweisung b = a kopiert nur den Verweis, clone() oder copyOf kopieren die Daten
• Mehrdimensional: int[][] m

import java.util.Arrays;

public class Felder {
    public static void main(String[] args) {
        int[] zahlen = {5, 3, 9, 1, 7};             // direkt mit Werten
        String[] namen = new String[3];             // 3 Plätze, anfangs null
        double[] preise = new double[4];            // anfangs 0.0
        namen[0] = "Mia";

        System.out.println(zahlen[0] + " " + zahlen[zahlen.length - 1] + " " + zahlen.length);
        System.out.println(Arrays.toString(namen) + " " + Arrays.toString(preise));
        zahlen[1] = 30;
        System.out.println(Arrays.toString(zahlen));
        try {
            System.out.println(zahlen[5]);
        } catch (ArrayIndexOutOfBoundsException e) {
            System.out.println("Fehler: " + e.getMessage());
        }
    }
}

10. Collections: List, Set und Map

• Collections sind generisch: List<String>, Map<String, Integer>
• ArrayList, HashSet, HashMap sind die Standardwahl; Tree... sortiert, LinkedHash... merkt die Reihenfolge
• List.of, Set.of, Map.of sind unveränderlich
• merge, computeIfAbsent, getOrDefault machen Maps bequem
• ArrayDeque für Stapel und Schlangen
• Sortieren mit Comparator.comparing(...)

import java.util.*;

public class Listen {
    public static void main(String[] args) {
        List<String> namen = new ArrayList<>();
        namen.add("Mia");
        namen.add("Tom");
        namen.add(1, "Zoe");                 // an Index einfügen
        System.out.println(namen + " " + namen.size());
        System.out.println(namen.get(0) + " " + namen.indexOf("Tom") + " " + namen.contains("Max"));
        namen.remove("Zoe");
        namen.set(0, "Mia2");
        System.out.println(namen);

        for (String n : namen) System.out.print(n + ";");
        System.out.println();

        List<Integer> zahlen = new ArrayList<>(List.of(5, 3, 9, 1));
        Collections.sort(zahlen);
        System.out.println(zahlen + " max " + Collections.max(zahlen) + " " + Collections.frequency(zahlen, 3));
        zahlen.removeIf(z -> z > 4);
        zahlen.replaceAll(z -> z * 10);
        System.out.println(zahlen);
    }
}

11. Klassen und Objekte

• Klasse = Bauplan (Felder + Methoden), Objekt = Exemplar; new ruft den Konstruktor
• Kapselung: Felder private, Zugriff über Methoden
• this ist das aktuelle Objekt; static gehört zur Klasse
• equals und hashCode immer gemeinsam überschreiben
• Objekte liegen im Heap, Variablen halten Verweise; null vermeiden, Optional nutzen

public class Hund {
    // Felder (Zustand)
    private String name;
    private int alter;

    // Konstruktor: legt das Objekt an
    public Hund(String name, int alter) {
        this.name = name;
        this.alter = alter;
    }

    // Methoden (Verhalten)
    public String bellen() {
        return name + " sagt: Wuff!";
    }

    public void geburtstag() {
        alter++;
    }

    // Getter
    public String getName() { return name; }
    public int getAlter() { return alter; }

    @Override
    public String toString() {
        return "Hund[" + name + ", " + alter + "]";
    }

    public static void main(String[] args) {
        Hund rex = new Hund("Rex", 3);
        Hund mimi = new Hund("Mimi", 5);
        rex.geburtstag();
        System.out.println(rex.bellen() + " " + rex.getAlter());
        System.out.println(rex + " " + mimi);
    }
}

12. Vererbung, Interfaces und Polymorphie

• class B extends A erbt; super(...) ruft den Elternkonstruktor, @Override überschreibt bewusst
• Polymorphie: Es gilt die Methode des tatsächlichen Objekts
• abstract für Vorlagen; interface für Verträge und Fähigkeiten (mehrere möglich)
• Programmiere gegen Interfaces, bevorzuge Komposition
• Jede Klasse erbt von Object

public class Tiere {
    static class Tier {
        protected String name;
        Tier(String name) { this.name = name; }
        String laut() { return "..."; }
        String vorstellen() { return name + " macht " + laut(); }
    }
    static class Hund extends Tier {
        Hund(String name) { super(name); }            // Konstruktor der Oberklasse
        @Override String laut() { return "Wuff"; }
    }
    static class Katze extends Tier {
        Katze(String name) { super(name); }
        @Override String laut() { return "Miau"; }
        @Override String vorstellen() { return super.vorstellen() + " (und schnurrt)"; }
    }

    public static void main(String[] args) {
        Tier[] tiere = { new Hund("Rex"), new Katze("Mimi"), new Tier("Etwas") };
        for (Tier t : tiere) System.out.println(t.vorstellen());      // Polymorphie
    }
}

13. Records, Enums und versiegelte Typen

• record Punkt(int x, int y) {} erzeugt Konstruktor, Getter, equals, hashCode, toString
• Enums sind Typen mit festen Konstanten, mit Feldern und Methoden
• sealed begrenzt erlaubte Untertypen; switch prüft Vollständigkeit
• Records und sealed Interfaces bilden Daten mit mehreren Varianten sauber ab

public class Aufnahme {
    record Person(String name, int alter) {
        Person {                                      // kompakter Konstruktor: Prüfung
            if (alter < 0) throw new IllegalArgumentException("Alter < 0");
        }
        String gruss() { return "Hallo, ich bin " + name; }
        static Person kind(String name) { return new Person(name, 0); }
    }

    public static void main(String[] args) {
        Person mia = new Person("Mia", 17);
        System.out.println(mia);                       // toString automatisch
        System.out.println(mia.name() + " " + mia.alter() + " " + mia.gruss());
        System.out.println(mia.equals(new Person("Mia", 17)) + " " + Person.kind("Tom"));
        try { new Person("X", -1); } catch (IllegalArgumentException e) { System.out.println(e.getMessage()); }
    }
}

14. Ausnahmen (Exceptions)

• try { } catch (Typ e) { } finally { }; throw new ... löst aus, throws meldet an
• Checked Exceptions musst du behandeln, RuntimeExceptions nicht
• Spezifische catch-Blöcke vor allgemeinen
• try-with-resources schließt Ressourcen automatisch
• Eigene Ausnahmen erweitern Exception oder RuntimeException; Ursache mitgeben

public class Fangen {
    public static void main(String[] args) {
        try {
            System.out.println("vorher");
            int x = Integer.parseInt("abc");
            System.out.println("wird nie erreicht " + x);
        } catch (NumberFormatException e) {
            System.out.println("Ungültige Zahl: " + e.getMessage());
        } finally {
            System.out.println("läuft immer");
        }
        System.out.println("Programm läuft weiter");
    }
}

15. Generics

• Generics = Typparameter: class Box<T>, <T> void f(T x)
• Der Compiler prüft Typen und spart Casts
• T extends Comparable<T> schränkt Typparameter ein
• Wildcards: ? extends T zum Lesen, ? super T zum Schreiben (PECS)
• Typlöschung: zur Laufzeit gibt es die Typparameter nicht mehr
• Keine "raw types" (List ohne <>)

import java.util.*;

public class Ohne {
    @SuppressWarnings({"rawtypes", "unchecked"})
    public static void main(String[] args) {
        List liste = new ArrayList();            // "raw type": nicht tun!
        liste.add("Text");
        liste.add(42);
        try {
            String s = (String) liste.get(1);    // ClassCastException erst zur Laufzeit
        } catch (ClassCastException e) {
            System.out.println("Laufzeitfehler: " + e.getMessage().substring(0, 40));
        }
    }
}

16. Lambdas und Streams

• Lambdas (a, b) -> a + b und Methodenreferenzen String::length ersetzen kleine Klassen
• Funktionale Interfaces: Function, Predicate, Consumer, Supplier
• Stream = Quelle → filter/map/sorted → Endoperation (collect, count, reduce)
• Collectors.groupingBy, partitioningBy, toMap, joining für Auswertungen
• Streams sind lazy und einmal verwendbar

import java.util.*;
import java.util.function.*;

public class Lambdas {
    public static void main(String[] args) {
        Function<Integer, Integer> quadrat = x -> x * x;
        BiFunction<Integer, Integer, Integer> plus = (a, b) -> a + b;
        Predicate<String> leer = s -> s.isEmpty();
        Supplier<String> lieferant = () -> "Wert";
        Consumer<String> ausgabe = s -> System.out.println("> " + s);
        UnaryOperator<String> gross = String::toUpperCase;           // Methodenreferenz

        System.out.println(quadrat.apply(7) + " " + plus.apply(3, 4) + " " + leer.test("") + " " + lieferant.get());
        ausgabe.accept(gross.apply("hallo"));
        System.out.println(quadrat.andThen(x -> x + 1).apply(5));    // verketten
        System.out.println(leer.negate().test("x"));

        List<String> namen = new ArrayList<>(List.of("Zoe", "Anna", "Tom"));
        namen.sort((a, b) -> a.length() - b.length());
        namen.forEach(n -> System.out.print(n + " "));
        System.out.println();
    }
}

17. Dateien und Ein-/Ausgabe

• Modern: Path und Files (readString, writeString, readAllLines, lines, walk)
• Dateioperationen werfen IOException (checked)
• Große Dateien zeilenweise lesen (BufferedReader, Files.lines), Ressourcen mit try-with-resources schließen
• Path.of(...), resolve, normalize statt Zeichenketten für Pfade
• Scanner liest Eingaben; für JSON Jackson oder Gson

import java.io.IOException;
import java.nio.file.*;
import java.util.*;

public class Dateien {
    public static void main(String[] args) throws IOException {
        Path ordner = Files.createTempDirectory("kurs");
        Path datei = ordner.resolve("notiz.txt");               // Pfad zusammensetzen

        Files.writeString(datei, "Zeile 1\nZeile 2\n");
        Files.writeString(datei, "Zeile 3\n", StandardOpenOption.APPEND);

        String inhalt = Files.readString(datei);
        List<String> zeilen = Files.readAllLines(datei);
        System.out.println(zeilen + " " + inhalt.length());
        System.out.println(Files.exists(datei) + " " + Files.size(datei) + " " + datei.getFileName());

        Path kopie = ordner.resolve("kopie.txt");
        Files.copy(datei, kopie);
        try (var strom = Files.list(ordner)) {
            strom.map(p -> p.getFileName().toString()).sorted().forEach(System.out::println);
        }
        Files.delete(kopie);
        Files.delete(datei);
        Files.delete(ordner);
        System.out.println(Files.exists(ordner));
    }
}

18. Datum und Zeit

• java.time: LocalDate, LocalTime, LocalDateTime, ZonedDateTime, Instant
• Alle Objekte sind unveränderlich; plusDays(...) liefert ein neues
• ChronoUnit.DAYS.between, Period, Duration für Zeitspannen
• DateTimeFormatter.ofPattern("dd.MM.yyyy") zum Formatieren und Einlesen
• Zeitpunkte als Instant/UTC speichern; Clock macht Code testbar

import java.time.*;
import java.time.format.*;

public class Zeit {
    public static void main(String[] args) {
        LocalDate d = LocalDate.of(2025, 3, 8);
        System.out.println(d + " " + d.getDayOfWeek() + " " + d.getMonth() + " " + d.getDayOfYear() + " " + d.isLeapYear());

        LocalDate morgen = d.plusDays(1);
        LocalDate in3Monaten = d.plusMonths(3);
        System.out.println(morgen + " " + in3Monaten + " " + d.minusWeeks(2) + " " + d.withDayOfMonth(1));

        LocalDateTime dt = LocalDateTime.of(2025, 12, 24, 18, 30);
        System.out.println(dt + " " + dt.toLocalTime() + " " + dt.getHour());
        System.out.println(d.isBefore(LocalDate.of(2025, 12, 24)) + " " + d.equals(LocalDate.parse("2025-03-08")));
    }
}

19. Threads und Nebenläufigkeit

• Thread, Runnable, start(), join() sind die Grundlage; besser sind Pools (ExecutorService)
• Gemeinsame Daten schützen: synchronized, Atomic*, ConcurrentHashMap
• Future und CompletableFuture liefern Ergebnisse asynchron
• Virtual Threads (Java 21) erlauben sehr viele gleichzeitige Aufgaben
• Unveränderliche Objekte vermeiden Probleme von vornherein

public class Faeden {
    public static void main(String[] args) throws InterruptedException {
        Thread t1 = new Thread(() -> {
            try { Thread.sleep(100); } catch (InterruptedException e) { }
            System.out.println("t1 fertig");
        });
        Thread t2 = new Thread(() -> System.out.println("t2 fertig"));
        t1.start();
        t2.start();
        t1.join();                      // warten, bis t1 beendet ist
        t2.join();
        System.out.println("alle fertig");
    }
}

20. Tests, Pakete und Projektaufbau

• Pakete spiegeln die Ordnerstruktur; import holt Klassen aus anderen Paketen
• Maven und Gradle verwalten Abhängigkeiten, Build und Tests (Standardstruktur src/main und src/test)
• JUnit 5: @Test, assertEquals, assertThrows
• Arrange – Act – Assert; Grenz- und Fehlerfälle testen
• Abhängigkeiten über Interfaces hereingeben, damit sie sich ersetzen lassen

src/main/java/de/meinefirma/shop/Warenkorb.java

package de.meinefirma.shop;

import java.util.List;
import de.meinefirma.shop.modell.Artikel;

public class Warenkorb { ... }

21. Sauberer Java-Code und häufige Fehler

• Strings und Objekte mit .equals() vergleichen; null mit Optional oder Standardwerten entschärfen
• Listen nicht während der Iteration ändern (removeIf)
• Geld mit BigDecimal; long-Rechnungen mit L-Literalen
• Unveränderliche Sichten zurückgeben; moderne Sprachmittel nutzen
• Logger statt System.out, Eingaben prüfen, Abhängigkeiten pflegen

public class Fehler1 {
    public static void main(String[] args) {
        String eingabe = new String("ja");
        System.out.println((eingabe == "ja") + " " + eingabe.equals("ja"));
        System.out.println("ja".equals(eingabe));          // sicher gegen null auf der linken Seite
    }
}

22. Nachschlagen: Spickzettel

// Klasse, Konstruktor, Methode
public class Person {
    private final String name;
    public Person(String name) { this.name = name; }
    public String getName() { return name; }
}

// Interface, Record, Enum, sealed
interface Form { double flaeche(); }
record Punkt(int x, int y) {}
enum Tag { MO, DI, MI }
sealed interface S permits A, B {}

// Generics
<T extends Comparable<T>> T max(List<T> l) { ... }

// Lambda und Methodenreferenz
Function<Integer, Integer> f = x -> x * 2;
list.forEach(System.out::println);

// Ausnahmen
try { ... } catch (IOException | RuntimeException e) { ... } finally { ... }
try (var r = Files.newBufferedReader(p)) { ... }

// Schleifen
for (int i = 0; i < n; i++) { }
for (var x : liste) { }
while (bedingung) { }

// switch-Ausdruck
String s = switch (tag) { case MO, DI -> "früh"; default -> "spät"; };