Einführung in Java-Programmierung - Informatik Grundkurs Q1

JAVA Grundlagen - Datentypen und Variablen

Stellt euch vor, ihr müsst verschiedene Gegenstände in Schachteln sortieren - genau so funktionieren Datentypen in Java! Es gibt zwei Hauptkategorien: primitive Typen (werden direkt gespeichert) und komplexe Typen (werden über Referenzen angesprochen).

Die wichtigsten primitiven Datentypen sind int für ganze Zahlen, double für Kommazahlen, boolean für true/false-Werte und char für einzelne Zeichen. String ist dagegen ein komplexer Datentyp für ganzen Text.

Bei der Deklaration legt ihr den Datentyp fest, bei der Initialisierung gebt ihr den ersten Wert. Variablennamen müssen mit einem Buchstaben beginnen und dürfen keine Leerzeichen enthalten.

Vergleichsoperatoren wie ==, !=, <, > helfen euch dabei, Werte zu vergleichen und geben immer einen boolean-Wert zurück. Das ist die Grundlage für alle Entscheidungen in euren Programmen.

Tipp: Primitive Datentypen beginnen immer mit Kleinbuchstaben, da es gleichnamige Klassen gibt!

Logische Operatoren und mathematische Funktionen

Jetzt wird's richtig mächtig! Logische Operatoren verknüpfen mehrere Bedingungen miteinander. Mit && (UND) müssen beide Bedingungen wahr sein, mit || (ODER) reicht eine wahre Bedingung aus.

Der !-Operator dreht einen Wahrheitswert ins Gegenteil um - aus true wird false und umgekehrt. Das exklusive ODER (^) ist nur dann wahr, wenn genau eine der beiden Bedingungen erfüllt ist.

Für mathematische Berechnungen stellt Java praktische Funktionen bereit: Math.sqrt(x) für Wurzeln, Math.PI für die Kreiszahl π und Math.pow() für Potenzen.

Mit Math.random() generiert ihr Zufallszahlen zwischen 0 und 1 - multipliziert sie einfach mit eurem gewünschten Maximalwert!

Merkhilfe: && ist strenger als || - beim UND müssen ALLE Bedingungen stimmen, beim ODER reicht EINE!

Kontrollstrukturen - If und Switch

Endlich könnt ihr euren Code Entscheidungen treffen lassen! Die if-Anweisung ist wie eine Weggabelung - je nach Bedingung wird ein anderer Pfad gewählt. Mit else if könnt ihr mehrere Bedingungen hintereinander prüfen.

if (note >= 4) {
    System.out.println("Bestanden!");
} else {
    System.out.println("Durchgefallen!");
}

Die switch-Anweisung ist perfekt, wenn ihr viele verschiedene Werte einer Variable abfragen wollt. Statt endloser if-else-Ketten nutzt ihr case-Zweige für jeden möglichen Wert.

Das break nach jedem case ist super wichtig - sonst "rutscht" das Programm in die nächsten Fälle durch! Der default-Zweig fängt alle anderen Werte ab, die nicht explizit behandelt wurden.

Wichtig: Switch funktioniert nur mit ganzzahligen Datentypen und Strings - nicht mit double oder boolean!

Schleifen für wiederholende Aufgaben

Schleifen sind eure Zeitsparer! Statt 100 Zeilen zu schreiben, lasst ihr das Programm die Arbeit wiederholen. Es gibt drei Schleifentypen: while, do-while und for.

Die while-Schleife prüft die Bedingung am Anfang - wenn sie falsch ist, läuft die Schleife gar nicht erst. Die do-while-Schleife führt den Code mindestens einmal aus, da sie erst am Ende prüft.

for (int i = 0; i < 10; i++) {
    System.out.println("Durchlauf: " + i);
}

Die for-Schleife ist ideal für Zählvorgänge. Ihr definiert Startwert, Bedingung und Schrittweite in einer kompakten Zeile. Sie ist besonders praktisch für Arrays.

Jede Schleife hat ihren Einsatzzweck: while für unbekannte Wiederholungen, do-while wenn mindestens ein Durchlauf nötig ist, for zum Zählen.

Achtung: Endlosschleifen entstehen, wenn die Bedingung nie false wird - prüft eure Schleifen immer!

Eingabe, Ausgabe und Arrays

Mit der Scanner-Klasse macht ihr eure Programme interaktiv! Nach dem Import java.util.Scanner erstellt ihr ein Scanner-Objekt und könnt verschiedene Datentypen einlesen: nextInt() für ganze Zahlen, nextLine() für Text.

Scanner input = new Scanner(System.in);
int zahl = input.nextInt();

Für die Ausgabe nutzt ihr System.out.println() (mit Zeilenumbruch) oder System.out.print() (ohne Zeilenumbruch). Variablen verknüpft ihr mit dem +-Operator.

Arrays sind wie Schubladenschränke - jede Schublade hat eine Nummer (Index) und kann einen Wert speichern. Alle Werte müssen denselben Datentyp haben. Der Index startet bei 0!

Arrays deklariert ihr mit int[] name = new int[größe] oder füllt sie direkt: int[] zahlen = {1, 2, 3, 4, 5}. Mit name.length erfahrt ihr die Array-Größe.

Wichtig: Array-Indizes starten bei 0 - bei 5 Elementen sind die Indizes 0 bis 4!

Array-Anwendungen in der Praxis

Arrays werden richtig spannend, wenn ihr sie für konkrete Aufgaben nutzt! Zufallszahlen füllt ihr mit einer for-Schleife und Math.random() ins Array. Für das Maximum durchlauft ihr alle Elemente und merkt euch den größten Wert.

int max = array[0];
for (int i = 1; i < array.length; i++) {
    if (array[i] > max) {
        max = array[i];
    }
}

Den Durchschnitt berechnet ihr, indem ihr alle Werte addiert und durch die Anzahl teilt. Arrays umkehren könnt ihr entweder mit einem zweiten Array oder durch geschicktes Vertauschen der Elemente.

Beim Umkehren mit einem Array tauscht ihr die Positionen: Erstes Element mit Letztem, Zweites mit Vorletztem usw. Eine Hilfsvariable speichert dabei temporär einen der Werte.

Diese Array-Operationen sind Grundbausteine für komplexere Algorithmen - übt sie gut, denn sie kommen in vielen Programmieraufgaben vor!

Tipp: Nutzt aussagekräftige Variablennamen wie max oder durchschnitt - das macht euren Code verständlicher!

Suchalgorithmen verstehen und anwenden

Suchalgorithmen helfen euch dabei, bestimmte Werte in großen Datenmengen zu finden. Die lineare Suche ist der einfachste Ansatz - ihr durchlauft das Array von Anfang bis Ende und vergleicht jedes Element.

for (int i = 0; i < array.length; i++) {
    if (array[i] == suchWert) {
        System.out.println("Gefunden an Position: " + i);
    }
}

Die binäre Suche ist deutlich effizienter, funktioniert aber nur bei sortierten Arrays. Ihr teilt das Suchgebiet immer in der Mitte und entscheidet, in welcher Hälfte ihr weitersucht.

Bei der Laufzeit zeigt sich der große Unterschied: Lineare Suche braucht im schlimmsten Fall O$n$ Schritte, binäre Suche nur O(log n). Bei 1000 Elementen sind das 1000 vs. 10 Schritte!

Die binäre Suche halbiert den Suchbereich bei jedem Schritt - deshalb ist sie so schnell. Der Preis: Das Array muss sortiert sein.

Faustregel: Lineare Suche für kleine oder unsortierte Arrays, binäre Suche für große sortierte Datenmengen!

Selection Sort - Sortieren durch Auswählen

Sortieralgorithmen bringen Ordnung in eure Daten! Selection Sort ist intuitiv verständlich: Ihr sucht das kleinste Element und tauscht es an die erste Position, dann das zweitkleinste an die zweite Position usw.

Der Algorithmus teilt das Array gedanklich in einen sortierten und einen unsortierten Bereich. Anfangs ist nur der sortierte Bereich leer, am Ende ist das ganze Array sortiert.

for (int i = 0; i < array.length; i++) {
    int minIndex = i;
    for (int j = i + 1; j < array.length; j++) {
        if (array[j] < array[minIndex]) {
            minIndex = j;
        }
    }
    // Tauschen der Elemente
}

Die Laufzeit ist immer O(n²) - egal ob das Array schon teilweise sortiert ist oder völlig durcheinander. Das macht Selection Sort vorhersagbar, aber nicht besonders schnell.

Der Vorteil: Selection Sort macht die wenigsten Tauschoperationen und ist einfach zu verstehen und implementieren.

Eigenschaft: Selection Sort ist "stabil" - die Reihenfolge gleicher Elemente bleibt erhalten!

Insertion Sort - Sortieren durch Einfügen

Insertion Sort funktioniert wie das Sortieren von Spielkarten in der Hand: Ihr nehmt eine Karte und fügt sie an der richtigen Stelle in die bereits sortierte Kartensammlung ein.

Der Algorithmus startet beim zweiten Element und fügt es in den bereits sortierten Teil (anfangs nur das erste Element) ein. Dann das dritte Element, dann das vierte usw.

for (int i = 1; i < array.length; i++) {
    for (int j = i; j > 0 && array[j] < array[j-1]; j--) {
        // Elemente tauschen
        int temp = array[j];
        array[j] = array[j-1];
        array[j-1] = temp;
    }
}

Die Laufzeit variiert stark: Bei bereits sortierten Arrays nur O$n$, bei völlig unsortierten O(n²). Das macht Insertion Sort besonders gut für teilweise sortierte Daten.

Insertion Sort ist "adaptiv" - je besser die Daten schon sortiert sind, desto schneller wird er. Deshalb wird er oft bei kleinen Arrays oder als Ergänzung zu anderen Algorithmen verwendet.

Vorteil: Insertion Sort arbeitet "in-place" - braucht keinen zusätzlichen Speicherplatz!

Bubble Sort und Algorithmus-Vergleich

Bubble Sort ist der berühmteste Sortieralgorithmus - leider nicht wegen seiner Effizienz! Er vergleicht benachbarte Elemente und tauscht sie, wenn sie in der falschen Reihenfolge stehen.

Das größte Element "blubbert" wie eine Luftblase nach oben (daher der Name). Nach dem ersten Durchlauf steht das größte Element am Ende, nach dem zweiten das zweitgrößte usw.

for (int i = array.length - 1; i > 0; i--) {
    for (int j = 0; j < i; j++) {
        if (array[j] > array[j + 1]) {
            // Elemente tauschen
        }
    }
}

Algorithmus-Vergleich: Alle drei haben O(n²) Laufzeit, aber unterschiedliche Stärken. Selection Sort macht die wenigsten Tauschoperationen, Insertion Sort ist am schnellsten bei vorsortieren Daten.

Bubble Sort ist am langsamsten, da er die meisten Tauschoperationen braucht. Er wird hauptsächlich zum Lernen verwendet, nicht in der Praxis. Für echte Projekte gibt es effizientere Algorithmen wie Quicksort oder Mergesort.

Fazit: Wählt Selection Sort für große unsortierte Arrays, Insertion Sort für kleine teilsortierte Arrays!