FAQ-Glossar zur Java Schulung

In der Java Schulung verstehen wir unter einem Algorithmus eine eindeutig formulierte, endliche Schrittfolge, die ein konkretes Problem zuverlässig löst. Wir arbeiten konsequent vom Anwendungsfall aus: Ausgangspunkt ist eine verständliche Aufgabenbeschreibung (z. B. »Finde in einer Liste den gesuchten Teilnehmernamen«), die wir anschließend in kontrollierte, testbare Programmschritte übersetzen.

Didaktisch üben wir zunächst einfache Verfahren wie lineare Suche oder einfache Sortierung und bewerten sie entlang dreier Kriterien: Korrektheit, Verständlichkeit und Aufwand bei wachsender Datenmenge. Im Verlauf des Kurses setzen wir dieselben Ideen mit Collections und Streams um und vergleichen imperative mit deklarativen Lösungen. Ziel ist, dass Teilnehmende die algorithmische Idee erkennen, begründen und in Java sauber implementieren können.

Beispielcode aus der Java Schulung:

// Beispielcode aus der Java Schulung: Teilnehmer per linearer Suche finden
String[] teilnehmer = {"Anna", "Bernd", "Carla", "Daniel"};

int findeTeilnehmer(String[] liste, String name){
    for(int i = 0; i < liste.length; i++){
        if(liste[i].equals(name)){
            return i; // Position zurückgeben
        }
    }
    return -1; // nicht gefunden
}

Die Methode prüft alle Elemente sequenziell. Im Kurs variieren wir die Aufgabe (Groß-/Kleinschreibung, leere Listen, Mehrfachtreffer) und leiten daraus robuste Vorbedingungen und Tests ab.

Für die Einstiegsübungen der Java Schulung genügen in der Regel die Typen int, double und boolean. Damit modellieren wir z. B. Schulungsdauer (int), Preise bzw. Zwischenwerte (double) und einfache Zustände wie Online/Präsenz (boolean).

Wir thematisieren früh die Grenzen von double bei Geldbeträgen und bereiten damit die spätere Umstellung auf BigDecimal vor. Teilnehmende lernen an praktischen Mini-Szenarien, wie sich Rechenregeln, Typkompatibilität und automatische Typumwandlungen (z. B. bei Ausdrücken) auf das Ergebnis auswirken.

Beispielcode aus der Java Schulung:

// Beispielcode aus der Java Schulung: einfache Variablen
int schulungsTage = 4;
boolean istOnline = true;
double tagesPreis = 450.0;

Die Kombination bildet ein realistisches Kleinmodell (Dauer, Format, Preis). Darauf aufbauend üben wir Ausdrücke und if/else-Entscheidungen.

In der Java Schulung nutzen wir Strings für Bezeichnungen, Statusmeldungen und einfache Formatierungen (z. B. Konsolenausgaben). Wichtiger Grundsatz ist ihre Unveränderlichkeit: Jede Operation erzeugt einen neuen String.

Wir beleuchten die Folgen für Performance (Konkatenation in Schleifen) und zeigen Alternativen wie StringBuilder. Zudem besprechen wir equals vs. ==, Zeichensätze und einfache Normalisierung (Trimmen, Case-Handling) für robuste Vergleiche.

Beispielcode aus der Java Schulung:

// Beispielcode aus der Java Schulung: Begrüßungstext
String kursTitel = "Java Grundlagen Schulung";
System.out.println("Willkommen zur " + kursTitel + "!");

Die Ausgabe verdeutlicht String-Konkatenation. Im Kurs vergleichen wir das mit String.format und StringBuilder in Schleifen.

Variablen benennen Werte und machen Programmzustand verständlich. In der Java Schulung achten wir auf sprechende Namen, passenden Gültigkeitsbereich (Scope) und möglichst geringe Sichtbarkeit.

Wir üben, Variablen nahe an der Nutzung zu deklarieren, unveränderliche Zustände mit final zu kennzeichnen und temporäre Hilfsvariablen nach Möglichkeit zu vermeiden, um Lesbarkeit und Testbarkeit zu erhöhen.

Beispielcode aus der Java Schulung:

// Beispielcode aus der Java Schulung: sprechende Variablen
int tage = 4;
String trainerName = "Herr Ellmann";

Aussagekräftige Namen reduzieren Erklärbedarf im Code-Review. Im Kurs prüfen wir, wo final sinnvoll ist.

Für Kontrollfluss und Validierung verwenden wir häufig Vergleichsoperatoren (==, !=, <, >, <=, >=) und logische Operatoren (&&, ||, !). Sie sind zentral, um Annahmen über Eingaben abzusichern.

Wir besprechen Truth-Table-Denken, Kurzschlussauswertung (Short Circuit) und typische Stolperfallen wie == bei Strings. Übungen stärken das präzise Formulieren zusammengesetzter Bedingungen.

Beispielcode aus der Java Schulung:

// Beispielcode aus der Java Schulung: Bereichsprüfung
int tage = 4;
boolean imGueltigenBereich = (tage >= 3) && (tage <= 5);

Beide Teilbedingungen müssen erfüllt sein. Im Kurs leiten wir Grenzfälle ab und testen sie explizit.

Mit if/else steuern wir den Ablauf abhängig von Zuständen (z. B. Online/Präsenz). Wir betonen einfache, gut lesbare Bedingungen und vermeiden verschachtelte Kaskaden, wenn Guard-Clauses oder getrennte Methoden klarer sind.

In Übungen zerlegen wir mehrstufige Entscheidungen in kleine Prüfschritte und zeigen, wie frühe Rückgaben (early return) die Komplexität reduzieren.

Beispielcode aus der Java Schulung:

// Beispielcode aus der Java Schulung: einfache Verzweigung
boolean istOnline = true;
if(istOnline){
    System.out.println("Java Schulung findet online statt.");
}else{
    System.out.println("Java Schulung findet in Hamburg statt.");
}

Wir variieren Bedingungen (z. B. Stadt abhängig vom Format) und reflektieren die Lesbarkeit im Code-Review.

Schleifen wiederholen Anweisungen, z. B. beim Durchlaufen von Arrays oder Listen. Wir beginnen mit for, foreach und while und wählen die Form passend zum Problem: foreach für reine Iteration, for/while bei Index- oder Abbruchkontrolle.

Im Kurs üben wir Schleifeninvarianten, vermeiden Seiteneffekte und prüfen, wann eine Stream-Lösung die Lesbarkeit weiter erhöht.

Beispielcode aus der Java Schulung:

// Beispielcode aus der Java Schulung: Themenliste ausgeben
String[] themen = {"Variablen", "Schleifen", "Klassen"};
for(String t : themen){
    System.out.println("Thema: " + t);
}

foreach ist kompakt und ausdrucksstark. Später vergleichen wir die äquivalente Stream-Variante.

Methoden kapseln eine Aufgabe hinter einem Namen. Über Parameter definieren wir Eingaben, über den Rückgabewert das Ergebnis. In der Java Schulung achten wir auf klare Verantwortlichkeiten und kleine Einheiten.

Wir formulieren Verträge (»Was kommt rein? Was kommt raus?«), reduzieren Nebeneffekte und machen Logik durch gute Namen selbsterklärend. Das ist die Grundlage für präzise Unit-Tests.

Beispielcode aus der Java Schulung:

// Beispielcode aus der Java Schulung: Tagespreis berechnen
int berechneTagespreis(int preisProTag, int tage){
    return preisProTag * tage;
}

Klare Signatur, deterministisches Verhalten. Im Kurs ergänzen wir Vorbedingungsprüfungen und Tests.

Parameter sind die Platzhalter in der Methodendefinition; Argumente sind die konkreten Werte beim Aufruf. In der Java Schulung legen wir Wert auf aussagekräftige Parameternamen und sinnvolle Reihenfolgen.

Wir zeigen, wann Overloads nützlich sind, wann Builder/Records klarer sind und wie IDE-Unterstützung durch gute Namen verbessert wird.

Beispielcode aus der Java Schulung:

// Beispielcode aus der Java Schulung
int gesamt = berechneTagespreis(450, 4); // 450 und 4 sind Argumente

Die Definition steuert Lesbarkeit am Aufrufort. Wir üben, Namen so zu wählen, dass der Aufruf selbsterklärend ist.

Rückgabewerte machen Ergebnisse explizit. In der Java Schulung entscheiden wir bewusst, ob ein einfacher Typ genügt oder ein Objekt mehr Aussagekraft bietet (z. B. Wert + Status).

Wir vermeiden versteckte Zustandsänderungen und nutzen Rückgabewerte als Grundlage für Tests und Folgeberechnungen.

Beispielcode aus der Java Schulung:

// Beispielcode aus der Java Schulung
int summe = berechneTagespreis(450, 4);
System.out.println("Preis Java Schulung: " + summe + " EUR");

Das Ergebnis wird weiterverwendet. Im Kurs ergänzen wir Varianten mit BigDecimal für exakte Beträge.

Klassen beschreiben Daten und zugehöriges Verhalten. In der Java Schulung modellieren wir domänennah (z. B. Schulung mit Titel/Tagen) und definieren eine minimal notwendige, gut lesbare Schnittstelle.

Wir besprechen Feldsichtbarkeiten, Invarianten und einfache Entwurfsregeln wie »eine Klasse – eine Verantwortung«.

Beispielcode aus der Java Schulung:

// Beispielcode aus der Java Schulung: einfache Klasse
class Schulung {
    String titel;
    int tage;
    Schulung(String t, int tg){ titel = t; tage = tg; }
}

Im Kurs ergänzen wir Methoden (z. B. Preisberechnung) und diskutieren Kapselung (private Felder + Getter).

Ein Objekt ist eine konkrete Instanz einer Klasse. In der Java Schulung erzeugen wir Objekte mit Konstruktoren oder Fabrikmethoden und arbeiten über deren öffentliche Schnittstelle.

Wir zeigen, wie Objekte Zustände tragen, und diskutieren, wann Unveränderlichkeit (immutability) Vorteile in Tests und Nebenläufigkeit schafft.

Beispielcode aus der Java Schulung:

// Beispielcode aus der Java Schulung
Schulung grundkurs = new Schulung("Java Grundlagen Schulung", 4);

Aus dem Bauplan (Klasse) entsteht ein Exemplar. Wir prüfen, ob der Zustand nach Konstruktion konsistent ist.

Konstruktoren stellen gültige Startzustände her. In der Java Schulung setzen wir Pflichtwerte durch und vermeiden halbinitialisierte Objekte.

Wir erörtern, wann überladene Konstruktoren sinnvoll sind, wann Fabrikmethoden/Builder klarer sind und wie final Felder Absichten dokumentiert.

Beispielcode aus der Java Schulung:

// Beispielcode aus der Java Schulung
class Schulung {
    final String titel;
    final int tage;
    Schulung(String t, int tg){ this.titel = t; this.tage = tg; }
}

final signalisiert Unveränderlichkeit nach Konstruktion. Im Kurs ergänzen wir Validierungen (z. B. tage > 0).

Arrays speichern eine feste Anzahl gleichartiger Elemente bei minimalem Overhead. In der Java Schulung setzen wir sie ein, wenn die Größe bekannt ist und Indexzugriff benötigt wird.

Früh vergleichen wir Arrays mit List/ArrayList, um Vor- und Nachteile (Größe, API-Komfort) einzuordnen.

Beispielcode aus der Java Schulung:

// Beispielcode aus der Java Schulung
int[] tage = {1, 2, 3, 4};
System.out.println("Starttag: " + tage[0]);

Index beginnt bei 0. Im Kurs behandeln wir Bounds-Checks und die sichere Übergabe an Methoden.

ArrayList wächst dynamisch und bietet eine einfache API für viele Einstiegsszenarien (add, get, remove). In der Java Schulung typisieren wir sie mit Generics für Typsicherheit.

Wir vergleichen Laufzeitverhalten grob mit LinkedList und zeigen, warum in der Praxis oft List als Interface im Code steht.

Beispielcode aus der Java Schulung:

// Beispielcode aus der Java Schulung
List<String> themen = new ArrayList<>();
themen.add("Variablen");
themen.add("Objekte");

List<String> hält den Vertrag abstrakt; die Implementierung (ArrayList) kann später getauscht werden.

List steht für geordnete Sammlungen mit Indexzugriff. In der Java Schulung programmieren wir gegen das Interface, nicht gegen die Implementierung, um Austauschbarkeit und Testbarkeit zu erhöhen.

Wir stellen häufig verwendete Methoden vor (size, get, contains) und diskutieren unveränderliche Listen für sichere Übergaben.

Beispielcode aus der Java Schulung:

// Beispielcode aus der Java Schulung
List<String> inhalteTag1 = List.of("Syntax", "Variablen", "Kontrolle");

List.of erzeugt eine unveränderliche Liste. Wir zeigen Konsequenzen für Add/Remove-Operationen.

Map ordnet Schlüssel einem Wert zu, z. B. Tag → Thema. In der Java Schulung nutzen wir sie für schnelles Nachschlagen und vermeiden lineare Suchen in Listen.

Wir üben grundlegende Operationen (put, get, containsKey) und sprechen über Schlüsselqualität (Immutability, equals/hashCode) für zuverlässiges Verhalten.

Beispielcode aus der Java Schulung:

// Beispielcode aus der Java Schulung
Map<Integer, String> agenda = new HashMap<>();
agenda.put(1, "Grundlagen");
agenda.put(2, "OOP");

Mit get(1) erhalten wir das Thema von Tag 1. Wir zeigen, wann LinkedHashMap/TreeMap Vorteile bieten.

Packages strukturieren Code fachlich und steuern Sichtbarkeit. In der Java Schulung ordnen wir Beispiele in sinnvolle Namensräume ein und halten Imports gezielt und übersichtlich.

Wir thematisieren Paketkonventionen (klein, sprechend) und das Vermeiden zyklischer Abhängigkeiten.

Beispielcode aus der Java Schulung:

// Beispielcode aus der Java Schulung
package de.sematrain.schulung;
import java.util.List;

Das Package definiert den Namensraum; Imports binden benötigte Typen ein. Wildcard-Imports diskutieren wir kritisch.

Wir arbeiten mit einer IDE (z. B. IntelliJ/Eclipse), dem JDK zum Kompilieren und der JVM/JRE zur Ausführung. In der Java Schulung richten wir die Umgebung schrittweise ein und erläutern die Rollen der Komponenten.

Ziel ist ein reibungsloser Build-und-Run-Prozess, unabhängig von IDE-Spezialfunktionen.

Beispielcode aus der Java Schulung:

// Im Kurs: Projekt aufsetzen, JDK wählen, erste Klasse anlegen

Wir nutzen einfache Konsolenprojekte als Basis und erweitern später mit Build-Tools.

Bei riskanten Operationen (Datei, Netzwerk) kapseln wir Fehlerfälle kontrolliert. In der Java Schulung unterscheiden wir checked und unchecked Exceptions und zeigen sinnvolle Reaktionen (Log, alternative Rückgabe, erneutes Werfen).

Der finally-Block dient Aufräumarbeiten; moderne Varianten (try-with-resources) zeigen wir als bevorzugte Praxis.

Beispielcode aus der Java Schulung:

// Beispielcode aus der Java Schulung
try{
    Files.readString(Path.of("agenda.txt"));
}catch(IOException ex){
    System.err.println("Fehler in der Java Schulung: " + ex.getMessage());
}finally{
    // Ressourcen säubern
}

Im Kurs ersetzen wir das Muster durch try-with-resources, wo möglich, um Ressourcenlecks zu vermeiden.

Exceptions signalisieren außergewöhnliche Situationen. In der Java Schulung definieren wir klare Fehlerpfade, schreiben präzise Meldungen und vermeiden das Unterdrücken von Ursachen.

Wir erstellen bei Bedarf eigene Exception-Typen, um Fachfehler von technischen Fehlern zu trennen.

Beispielcode aus der Java Schulung:

// Beispielcode aus der Java Schulung
try{
    int p = 450 / 0;
}catch(ArithmeticException ex){
    System.err.println("Division durch 0 in der Java Schulung!");
}

Beispiel für eine Runtime-Exception. Wir besprechen, wann Validierung dem Fangen vorzuziehen ist.

Abstraktion fokussiert das Wesentliche und blendet Implementationsdetails aus. In der Java Schulung gestalten wir Verträge (Interfaces) und trennen Benutzung von Implementierung für testbaren, austauschbaren Code.

Wir nutzen Abhängigkeitsumkehr (Dependency Inversion), um Kernlogik unabhängig von technischen Details zu halten.

Beispielcode aus der Java Schulung:

// Beispielcode aus der Java Schulung: Vertrag + Nutzung
public interface ZahlungsDienst { void zahle(BigDecimal betrag); }
public class Rechnung {
  private final ZahlungsDienst svc;
  public Rechnung(ZahlungsDienst s){ this.svc = s; }
  public void begleichen(BigDecimal b){ svc.zahle(b); }
}

Rechnung kennt nur den Vertrag. Im Kurs injizieren wir Test-Doubles, um Verhalten isoliert zu prüfen.

Abstrakte Klassen bündeln gemeinsame Baselogik und Zustand, wenn Implementierungen viel teilen. In der Java Schulung vergleichen wir sie mit Interfaces (Default-Methoden) und leiten Einsatzkriterien ab.

Regel: Nur verwenden, wenn echte gemeinsame Implementierung sinnvoll ist; ansonsten Interface bevorzugen.

Beispielcode aus der Java Schulung:

// Beispielcode aus der Java Schulung
public abstract class Kurs {
  protected final String titel;
  public Kurs(String t){ this.titel = t; }
  public abstract int tage();
}

Ableitungen erben Felder/Logik, müssen aber tage() definieren. Wir achten auf stabile Basisklassenverträge.

Interfaces definieren Verträge ohne Implementation. In der Java Schulung nutzen wir sie, um Kopplung zu reduzieren, Varianten zu ermöglichen und Tests zu vereinfachen.

Wir sprechen Default-Methoden, funktionale Interfaces und sinnvolle Granularität an.

Beispielcode aus der Java Schulung:

// Beispielcode aus der Java Schulung
public interface Bewertung { int punkte(); }

Für Tests können einfache Fakes eingesetzt werden. So bleibt Fachlogik schnell überprüfbar.

Kapselung schützt interne Daten und hält Invarianten aufrecht. In der Java Schulung arbeiten wir mit privaten Feldern und wohldefinierten Zugriffsmethoden.

Wir vermeiden das unkontrollierte Offenlegen von Zuständen und zeigen, wie kapselnde Methoden Validierung aufnehmen.

Beispielcode aus der Java Schulung:

// Beispielcode aus der Java Schulung
class Teilnehmer {
  private String name;
  public Teilnehmer(String n){ this.name = n; }
  public String getName(){ return name; }
}

Interne Darstellung bleibt anpassbar. Wir ergänzen Validierung in Settern/Konstruktoren.

Vererbung nur bei echter IS-A-Beziehung. In der Java Schulung bevorzugen wir Komposition für flexible, robuste Designs und setzen Vererbung gezielt ein.

Wir beleuchten Risiken (Fragile Base Class) und definieren klare Richtlinien.

Beispielcode aus der Java Schulung:

// Beispielcode aus der Java Schulung
class AufbauKurs extends Kurs {
  public AufbauKurs(String t){ super(t); }
  @Override public int tage(){ return 4; }
}

Begründete IS-A-Beziehung. Im Kurs evaluieren wir Alternativen (Delegation/Komposition).

Polymorphismus erlaubt austauschbare Implementierungen hinter einem gemeinsamen Interface. In der Java Schulung nutzen wir ihn, um Strategien variabel zu halten, ohne Aufrufer anzupassen.

Das erleichtert Erweiterungen und Tests, insbesondere in Kombination mit DI.

Beispielcode aus der Java Schulung:

// Beispielcode aus der Java Schulung
interface PreisRegel { int berechne(int basis, int tage); }

Wir implementieren mehrere Regeln (Rabatt, Staffel) und wählen sie zur Laufzeit aus.

Generics sichern Typen zur Compile-Zeit und vermeiden Casts. In der Java Schulung typisieren wir Collections konsequent, um Fehler früh zu erkennen.

Wir besprechen Wildcards (<?>, <? extends T>, <? super T>) und typische Einsatzmuster.

Beispielcode aus der Java Schulung:

// Beispielcode aus der Java Schulung
List<String> teilnehmer = new ArrayList<>();

Die Liste nimmt nur Strings auf. Wir zeigen Compiler-Fehlermeldungen als Lernhilfe.

Kern sind List, Set, Map sowie Hilfsklassen (Collections.*). In der Java Schulung vergleichen wir Eigenschaften (Anordnung, Duplikate, Zugriff) und wählen Strukturen problemgerecht.

Wir koppeln das mit Streams für moderne Datenverarbeitung.

Beispielcode aus der Java Schulung:

// Beispielcode aus der Java Schulung
Collections.sort(teilnehmer);

Sortiert nach natürlicher Ordnung. Wir zeigen Comparator für benutzerdefinierte Reihenfolgen.

Iterator ist das Fundament sequentieller Traversierung und in manchen APIs weiterhin notwendig. In der Java Schulung nutzen wir ihn, wenn explizite Kontrolle über den Durchlauf erforderlich ist.

Wir diskutieren remove() und Iterator-Sicherheit bei Änderungen.

Beispielcode aus der Java Schulung:

// Beispielcode aus der Java Schulung
Iterator<String> it = teilnehmer.iterator();
while(it.hasNext()){
  System.out.println(it.next());
}

Explizite Kontrolle über Iterationsschritte. Wir kontrastieren mit foreach/Streams.

Wir verwenden @Override zur Absicherung von Überschreibungen, @Test (JUnit) für Unit-Tests sowie JPA-Annotationen in ORM-Beispielen. In der Java Schulung besprechen wir, wie Annotationen Compiler/Frameworks steuern.

Wichtig ist der bewusste Einsatz: Bedeutung, Lebensdauer (Retention) und Ziele (Target).

Beispielcode aus der Java Schulung:

// Beispielcode aus der Java Schulung
@Override
public String toString(){ return "Java Schulung"; }

@Override verhindert Tippfehler in Methodensignaturen und erhöht Quellcode-Sicherheit.

JUnit ist das Standard-Framework für Unit-Tests. In der Java Schulung arbeiten wir mit Arrange–Act–Assert, prägnanten Testnamen und klarer Testabdeckung.

Wir entkoppeln Fachlogik von IO und zeigen Test-Doubles für deterministische Tests.

Beispielcode aus der Java Schulung:

// Beispielcode aus der Java Schulung
@Test
void preisBerechnung_ok(){
  assertEquals(1800, berechneTagespreis(450, 4));
}

Deterministischer Test einer reinen Funktion. Wir ergänzen Grenzfälle und Negativtests.

Logs dienen Diagnose und Nachvollziehbarkeit. In der Java Schulung wählen wir sinnvolle Log-Level, schreiben klare, maschinenlesbare Nachrichten und vermeiden sensible Daten.

Wir integrieren Logging in Fehlerpfade und messen Nutzen statt Menge.

Beispielcode aus der Java Schulung:

// Beispielcode aus der Java Schulung
Logger log = Logger.getLogger("Schulung");
log.info("Start Java Schulung");

Konsistente, kontextreiche Nachrichten verkürzen Diagnosezeiten. Wir besprechen strukturierte Logs.

JDBC ist der Standard für direkten Datenbankzugriff. In der Java Schulung verwenden wir es für einfache CRUD-Beispiele und schärfen Bewusstsein für Ressourcenmanagement und Parametrisierung.

Für komplexere Domänen zeigen wir die Ablösung durch ORM und besprechen Trade-offs.

Beispielcode aus der Java Schulung:

// Beispielcode aus der Java Schulung (stark vereinfacht)
// Connection conn = DriverManager.getConnection(...);
// PreparedStatement ps = conn.prepareStatement("SELECT * FROM TEILNEHMER");

Fokus: try-with-resources, PreparedStatements gegen SQL-Injection, klare Mappings.

ORM bildet Objekte auf Tabellen ab und erhöht Produktivität bei komplexen Domänen. In der Java Schulung thematisieren wir Entity-Mapping, Beziehungen, Lazy/Eager-Loading und Transaktionen.

Wir betonen Domänenmodellierung und zeigen, wo explizite SQL-Kontrolle vorzuziehen ist.

Beispielcode aus der Java Schulung:

// Beispielcode aus der Java Schulung
@Entity class Teilnehmer { @Id Long id; String name; }

Annotationen definieren Mapping-Regeln. Wir ergänzen Beziehungen und Validierung (Bean Validation).

Threads führen Code parallel aus. In der Java Schulung demonstrieren wir Erzeugung, Lebenszyklus und typische Risiken (Race Conditions, Sichtbarkeit).

Wir empfehlen hohe Abstraktionen (Executor, CompletableFuture), wo passend.

Beispielcode aus der Java Schulung:

// Beispielcode aus der Java Schulung
new Thread(() -> System.out.println("Java Schulung – Nebenläufigkeit")).start();

Einstieg über Runnable/Lambda. Danach wechseln wir zu Executor-basierter Verwaltung.

Synchronisation koordiniert konkurrierende Zugriffe auf gemeinsamen Zustand. In der Java Schulung zeigen wir synchronized, Locks und atomare Typen sowie deren Kosten.

Wir prüfen Alternativen (immutables Design, Thread confinement) für einfachere Correctness.

Beispielcode aus der Java Schulung:

// Beispielcode aus der Java Schulung
class Zaehler {
  private int n;
  public synchronized void inc(){ n++; }
}

Das Schlüsselwort schützt vor gleichzeitigen Änderungen. Wir messen Auswirkungen auf Durchsatz/Latenz.

Autoboxing wandelt primitive Typen automatisch in Wrapper (und zurück). In der Java Schulung thematisieren wir Mehr-Objekt-Erzeugung, Null-Risiken und Vergleichssemantik.

Wir entscheiden bewusst, wann primitive Typen vorzuziehen sind.

Beispielcode aus der Java Schulung:

// Beispielcode aus der Java Schulung
List<Integer> tage = new ArrayList<>();
for(int i = 1; i <= 4; i++){ tage.add(i); } // Autoboxing

Jeder int wird zu Integer. Wir zeigen messbar, dass massives Boxing Leistung kosten kann.

Für Geldbeträge vermeiden wir Binärrundungen von double. In der Java Schulung verwenden wir BigDecimal mit definiertem MathContext und RoundingMode für reproduzierbare Ergebnisse.

Wir zeigen bewährte Patterns für Summen, Rabatte und Steuerberechnungen.

Beispielcode aus der Java Schulung:

// Beispielcode aus der Java Schulung
BigDecimal preisProTag = new BigDecimal("450.00");
BigDecimal gesamt = preisProTag.multiply(new BigDecimal("4"));

String-Konstruktor vermeidet Präzisionsfehler. Wir ergänzen scale/rounding in Praxisübungen.

Lambdas sind kompakte Funktionsliterale für funktionale APIs. In der Java Schulung setzen wir sie für Streams, Comparatoren und Callbacks ein.

Wir achten auf Lesbarkeit, Side-Effect-Armut und geben Hinweise zur Fehlersuche bei komplexen Pipelines.

Beispielcode aus der Java Schulung:

// Beispielcode aus der Java Schulung
teilnehmer.stream()
          .filter(n -> n.startsWith("M"))
          .forEach(System.out::println);

Kurze, zielgerichtete Lambdas erhöhen Lesbarkeit. Wir extrahieren bei Bedarf Methodenreferenzen.

Streams ermöglichen deklarative Verarbeitungsschritte (map, filter, reduce). In der Java Schulung lernen wir, Pipelines lesbar zu komponieren und Seiteneffekte zu vermeiden.

Wir vergleichen Sequenz- mit Parallel-Streams und besprechen, wann Parallelisierung tatsächlich hilft.

Beispielcode aus der Java Schulung:

// Beispielcode aus der Java Schulung
List<String> upper = themen.stream().map(String::toUpperCase).toList();

map transformiert Elemente. Wir ergänzen Sammeloperationen (collect) und eigene Collector-Beispiele.

Optional drückt aus, dass ein Wert fehlen kann, ohne null zu verwenden. In der Java Schulung nutzen wir es für Rückgaben, nicht als Feldtyp, und vermeiden so Null-Zeiger-Fehler.

Wir üben typische Muster: orElse, orElseGet, orElseThrow und map/flatMap.

Beispielcode aus der Java Schulung:

// Beispielcode aus der Java Schulung
Optional<String> trainer = Optional.of("Herr Ellmann");

Bewusste Behandlung leerer Fälle. Wir zeigen Anti-Pattern (Optional als Parameter/Feld).

Enums repräsentieren feste, benannte Werte. In der Java Schulung nutzen wir sie für Formate, Stati oder Kategorien, um Magische Strings zu vermeiden.

Wir ergänzen bei Bedarf Felder/Methoden am Enum für domänenspezifisches Verhalten.

Beispielcode aus der Java Schulung:

// Beispielcode aus der Java Schulung
enum Format { ONLINE, PRAESENZ }

Typsichere Alternativen zu Strings. Wir zeigen Switch-Expressions über Enums.

Clean Code bedeutet lesbare, wartbare Einheiten mit klaren Namen, kleinen Funktionen und aussagekräftigen Tests. In der Java Schulung refaktorisieren wir Beispiele systematisch.

Wir priorisieren Verständlichkeit vor Mikro-Optimierungen und dokumentieren Absichten im Code statt in Kommentaren.

Beispielcode aus der Java Schulung:

// Beispielcode aus der Java Schulung (Leitsatz, kein ausführbarer Code)
int preis(int basis, int tage){ return basis * tage; } // klein, eindeutig

Kleine, fokussierte Funktionen sind leichter zu testen und zu ändern. Wir zeigen schrittweises Refactoring.

Das Jigsaw-Modulsystem strukturiert große Codebasen in klar abgegrenzte Module. In der Java Schulung erstellen wir eine einfache Modulstruktur und besprechen Exports/Requires sowie Kapselung auf Modulebene.

Wir bewerten, wann Modularisierung realen Mehrwert liefert (Sicherheit, Wartbarkeit).

Beispielcode aus der Java Schulung:

// Beispielcode aus der Java Schulung
module de.sematrain.schulung { requires java.sql; }

module-info.java definiert Abhängigkeiten/Exports. Wir bauen ein Minimalbeispiel durch.

Wir arbeiten mit kleinen, getesteten Einheiten, klaren Schnittstellen, präzisem Logging und expliziten Fehlerpfaden. In der Java Schulung integrieren wir diese Grundsätze in jede Übung.

Code-Reviews, automatische Tests und einfache Metriken helfen, Qualität messbar zu halten.

Beispielcode aus der Java Schulung:

// Beispielcode aus der Java Schulung (Leitprinzip)
int preis(int pProTag, int tage){
    if(tage <= 0) throw new IllegalArgumentException("tage > 0");
    return pProTag * tage;
}

Vorbedingungen prüfen, dann rechnen: Einfache Regeln erhöhen Robustheit und Fehlermeldungsqualität.