Prog2 vorbereiten: Lücken aus Prog1 gezielt schließen

Ein einheitliches „Prog2“ gibt es nicht. Je nach Hochschule heißt das Modul auch Programmieren II, Programmierung 2 oder Softwareentwicklung II, und die Inhalte unterscheiden sich. Wenn du Modulhandbücher verschiedener Hochschulen vergleichst, tauchen aber immer wieder dieselben Themen auf:

• Objektorientierung vertieft: Vererbung, Polymorphie, abstrakte Klassen, Interfaces.
• Generics und das Collection-Framework: Listen, Sets, Maps, Iteratoren.
• Ausnahmen, Enums, oft auch Dateien und Tests mit JUnit.
• Datenstrukturen und Algorithmen: Stapel, Warteschlangen, verkettete Listen, Bäume, Sortieren, Rekursion.

Was genau bei dir drankommt, steht im Modulhandbuch deines Studiengangs. Schau dort vor Semesterbeginn nach und streiche Themen, die bei dir fehlen. Alles Weitere in diesem Artikel ist bewusst allgemein gehalten.

Prog2 baut auf Prog1 auf, ohne es zu wiederholen. Diese fünf Grundlagen werden ab der ersten Woche vorausgesetzt:

1. Methoden mit Parametern und Rückgabewert. Wer return und System.out.println verwechselt, scheitert an jeder Datenstruktur-Aufgabe.
2. Arrays und Schleifen über Indizes. Sortierverfahren bestehen fast nur daraus.
3. Klassen, Objekte, Konstruktoren und this. Ohne sie verstehst du weder Vererbung noch eine verkettete Liste.
4. Referenzen statt Werte. Zwei Variablen können auf dasselbe Objekt zeigen. == vergleicht bei Objekten Referenzen, equals den Inhalt.
5. Rekursion. Bäume und viele Sortierverfahren sind rekursiv. Wer den Aufrufstapel nicht im Kopf durchspielen kann, verliert hier den Anschluss.

Schreib auf Papier auf, was dieses Programm ausgibt, bevor du weiterliest:

1public class Main {2    static void grow(int[] values) {3        values[0] = 99;4    }5
6    static void reset(int number) {7        number = 0;8    }9
10    static int sum(int n) {11        if (n == 0) {12            return 0;13        }14        return n + sum(n - 1);15    }16
17    public static void main(String[] args) {18        int[] values = {1, 2, 3};19        int number = 7;20        grow(values);21        reset(number);22        String a = new String("Java");23        String b = new String("Java");24        System.out.println(values[0]);25        System.out.println(number);26        System.out.println(a == b);27        System.out.println(a.equals(b));28        System.out.println(sum(4));29    }30}

99
7
false
true
10

So wertest du aus:

• 99 richtig? Du weißt, dass ein Array als Referenz übergeben wird. Die Methode ändert das Original.
• 7 richtig? Du weißt, dass ein int kopiert wird. Die Änderung in reset bleibt lokal.
• false und true richtig? Du kennst den Unterschied zwischen == und equals. Mehr dazu steht im Kapitel Strings.
• 10 richtig? Du kannst Rekursion verfolgen: 4 + 3 + 2 + 1 + 0.

Jede falsche Zeile zeigt dir ein Thema, das du vor Prog2 wiederholen solltest. Solche Ausgabe-Aufgaben sind auch in Klausuren beliebt. Wie du sie systematisch übst, steht in „Was gibt das Programm aus?“: so übst du die Klausuraufgabe.

Rechne mit 30 bis 60 Minuten pro Tag, fünf Tage pro Woche. Das passt in die vorlesungsfreie Zeit, auch neben einem Nebenjob.

Woche 1: Methoden, Arrays, Strings

Wiederhole Methoden und Rekursion und schreibe jeden Tag zwei bis drei kleine Methoden: Maximum eines Arrays, Wort rückwärts, Zahl auf Primzahl prüfen. Wichtig ist, dass du jede Methode selbst schreibst und mit mehreren Eingaben ausprobierst.

Woche 2: Klassen und Vererbung

Lies Klassen und Objekte und danach Vererbung und Interfaces. Baue eine kleine Klassenhierarchie, etwa Shape mit Circle und Rectangle, und berechne Flächen über ein Interface. So siehst du Polymorphie in Aktion, bevor sie in der Vorlesung kommt.

Woche 3: Collections, Ausnahmen, Generics

Arbeite Listen und Maps durch, dann Ausnahmen und Enums. Zähle zum Beispiel Wörter in einem Text mit einer Map<String, Integer>. Generics kennst du dann schon aus der Praxis, bevor du eigene generische Klassen schreibst.

Woche 4: erste Algorithmen und Datenstrukturen

Starte mit einfachen Sortierverfahren und Rekursion und Backtracking. Implementiere Bubble Sort und Insertion Sort selbst und spiele sie an einem Array mit fünf Zahlen auf Papier durch. Wenn danach noch Zeit ist, wirf einen Blick auf Listen, Stapel und Warteschlangen.

Wenn du merkst, dass die Lücken größer sind, geh einen Schritt zurück. Unser Artikel zur richtigen Reihenfolge der Java-Themen zeigt dir, was worauf aufbaut.

Lesen allein reicht nicht. Diese Regeln machen den Unterschied:

• Selbst schreiben. Fremden Code nachvollziehen fühlt sich nach Verstehen an. Erst wenn du ihn ohne Vorlage schreibst, weißt du, ob es sitzt.
• Erst vorhersagen, dann ausführen. Überlege vor jedem Start, was herauskommen soll. Weicht das Ergebnis ab, hast du etwas gelernt.
• Typische Fehler kennen. Jeder unserer Lernartikel endet mit einem Abschnitt „Typische Fehler“. Lies ihn, bevor du die Aufgaben löst.
• Auch ohne Autovervollständigung. Viele Prog-Klausuren werden auf Papier geschrieben. Tipps dazu stehen in Java-Klausur auf Papier: Code schreiben ohne IDE üben.

Für genau diese Lücke ist Jario gebaut. Der Kurs Java-Grundlagen geht in 12 Kapiteln von der ersten Ausgabe bis zu Streams und Generics. Du kannst gezielt bei dem Kapitel einsteigen, das dir im Selbsttest Probleme gemacht hat. Danach setzt der Kurs Algorithmen in Java an: 8 Kapitel zu Suchen, Sortieren, Rekursion, Bäumen, Heaps, Hashing und Graphen, also Themen aus Prog2.

Jede Aufgabe prüfst du mit „Prüfen“ gegen Tests. Hängst du fest, gibt dir der KI-Tutor Hinweise in kleinen Schritten, ohne die Lösung zu verraten. Er kennt die Aufgabe, deinen Code und das Testergebnis. Die Autovervollständigung im Editor kannst du ausschalten, wenn du für eine Papierklausur übst. Und weil alles im Browser läuft, brauchst du kein eingerichtetes JDK.

Mach den Selbsttest, notiere deine Lücken und arbeite sie mit dem Vier-Wochen-Plan ab. Wenn Methoden, Klassen, Referenzen und Rekursion sitzen, ist Prog2 kein Neuanfang mehr, sondern die Fortsetzung von etwas, das du schon kannst. In Jario kannst du direkt im Browser mit dem Kapitel anfangen, das dir am meisten fehlt.