Erste Schritte
- Untersuchen der Java-Technologie
- Analysieren einer einfachen Java-Anwendung.
- Ausführen von Java-Anwendungen.
Objektorientierte Programmierung
- Definieren von Modellierkonzepten: Abstraktion, Kapselung und Pakete.
- Diskutieren der Wiederverwendung von Java-Anwendungscode.
- Definieren von Klasse, Mitglied, Attribut, Methode, Konstruktor und Paket.
- Verwenden der Zugriffsmodifikatoren "privat" und "öffentlich" gemäß den Richtlinien der Kapselung.
- Aufrufen einer Methode für ein bestimmtes Objekt.
- Verwenden der Online-Dokumentation der Java-API
Identifikatoren, Schlüsselwörter und Typen
- Verwenden von Kommentaren in einem Quellprogramm.
- Unterscheiden zwischen gültigen und ungültigen Identifikatoren.
- Erkennen von Java-Schlüsselwörtern.
- Auflisten der acht Primitiv-Typen.
- Definieren von Literalwerten für numerische und Texttypen.
- Definieren der Begriffe einfache (Primitiv-) Variable und Referenzvariable.
- Deklarieren von Variablen des Klassentyps (class).
- Konstruieren eines Objekts mit "new".
- Beschreiben der Standardinitialisierung.
- Beschreiben der Bedeutung einer Referenzvariablen.
- Darlegen der Konsequenzen des Zuweisens von Variablen vom Klassentyp (class).
Ausdrücke und Ablaufsteuerung
- Unterscheiden zwischen Instanz- und lokalen Variablen.
- Beschreiben des Initialisierens von Instanzvariablen.
- Erkennen, Beschreiben und Verwenden von Java-Operatoren.
- Unterscheiden zwischen zulässigen und unzulässigen Zuweisungen von Primitiv-Typen.
- Identifizieren von Booleschen Ausdrücken und deren Voraussetzungen in Steuerungskonstrukten
- Erkennen von Zuweisungskompatibilität und erforderlichen Typumwandlungen (Casts) in Grundtypen.
- Verwenden von if-, switch-, for-, while- und do-Konstrukten und den bezeichneten (label) Varianten von break und continue als Strukturen für die Ablaufsteuerung in einem Programm.
Arrays
- Deklarieren und Erstellen von Arrays von Primitiv-, Klassen- und Array-Typen.
- Erläutern, warum Elemente eines Arrays initialisiert werden.
- Erläutern, wie die Elemente eines Arrays initialisiert werden.
- Bestimmen der Anzahl der Elemente in einem Array.
- Erstellen eines multidimensionalen Arrays.
- Schreiben von Code zum Kopieren von Array-Werten aus einem Array in einen anderen.
Klassen-Design
- Definieren von Vererbung, Polymorphismus, Überladen (overloading), Außerkraftsetzung (overriding) und virtuellem Methodenaufruf.
- Verwenden der Zugriffsmodifikatoren "geschützt" und "standard" (paketfreundlich).
- Beschreiben der Konzepte des Überladens von Konstruktoren und Methoden.
- Beschreiben des vollständigen Vorgangs der Konstruktion und Initialisierung von Objekten.
Komplexe Leistungsmerkmale von Klassen
- Erstellen statischer Variablen, Methoden und Initialisierer.
- Erstellen finaler Klassen, Methoden und Variablen.
- Erstellen und Verwenden von Enum-Typen (Aufzählung).
- Verwenden der statischen Importanweisung.
- Erstellen abstrakter Klassen und Methoden.
- Erstellen und Verwenden einer Schnittstelle.
Ausnahmen und Assertions
- Definieren von Ausnahmen.
- Verwenden von try-, catch- und finally-Anweisungen.
- Beschreiben von Ausnahmenkategorien.
- Identifizieren gängiger Ausnahmen.
- Entwickeln von Programmen zum Behandeln eigener Ausnahmen.
- Verwenden von Assertions.
- Unterscheiden zwischen geeigneter und ungeeigneter Verwendung von Assertions.
- Aktivieren von Assertions zur Laufzeit.
Sammlungen (Collection) und das generische Framework
- Beschreiben der allgemeinen Implementierungen der Hauptschnittstellen im Collections-Framework.
- Untersuchen der Map-Schnittstelle.
- Untersuchen der legacy-Sammlungsklassen.
- Erstellen einer "natürlichen" (natural ordering) und einer "benutzerdefinierten Ordnung" (custom ordering) durch Implementierung der Comparable- und Comparator-Schnittstellen (Vergleichsoperatoren).
- Verwenden generischer Sammlungen.
- Verwenden von Typparametern in generischen Klassen.
- Umschreiben ("Refactor") von vorhandenem, nicht generischem Code.
- Schreiben eines Programms zum Iterieren über eine Sammlung.
- Untersuchen der erweiterten for-Schleife.
E/A-Grundlagen
- Schreiben eines Programms, das Befehlszeilenargumente und Systemeigenschaften verwendet.
- Untersuchen der Properties-Klasse (Eigenschaften).
- Konstruieren von Knoten (node) und Verarbeiten von Streams sowie deren angemessene Verwendung.
- Serialisieren und Deserialisieren von Objekten.
- Unterscheiden zwischen Lese- und Schreibvorgängen gegenüber Streams und angemessenes Auswählen der jeweiligen Vorgänge.
Konsolen-E/A und Datei-E/A
- Lesen von Daten von der Konsole.
- Schreiben von Daten auf die Konsole.
- Beschreiben von Dateien und Datei-E/A.
Erstellen von grafischen Java-Benutzeroberflächen mithilfe der Swing-API
- Beschreiben von JFC Swing.
- Definieren von Swing.
- Identifizieren der Swing-Pakete.
- Beschreiben der Bausteine für grafische Benutzeroberflächen (GUI): Container, Komponenten und Layout-Manager.
- Untersuchen der Top-Level-, allgemeinen und speziellen Eigenschaften von Containern.
- Untersuchen von Komponenten.
- Untersuchen von Layout-Managern.
- Beschreiben des Einzelthread-Modells von Swing.
- Erstellen einer GUI mithilfe von Swing-Komponenten.
Behandeln von GUI-erzeugten Ereignissen
- Definieren von Ereignissen und der Ereignisbehandlung.
- Untersuchen des Java SE-Ereignismodells.
- Beschreiben von GUI-Verhalten.
- Bestimmen der Benutzeraktion, die ein Ereignis verursacht hat.
- Entwickeln von Ereignis-Listenern.
- Beschreiben der Concurrency (Nebenläufigkeit) in Swing-basierten GUIs und Beschreiben der Leistungsmerkmale der SwingWorker-Klasse.
GUI-basierte Anwendungen
- Beschreiben der Vorgehensweise zum Erstellen von Menüleisten, Menüs und Menüelementen in einer grafischen Java-Benutzeroberfläche.
- Kenntnis, wie Farbe und Schriftart einer Komponente zu ändern sind.
Threads
- Definieren eines Threads.
- Erstellen gesonderter Threads in einem Java-Programm sowie Steuern des Codes und der Daten, die von diesem Thread verwendet werden.
- Steuern der Ausführung eines Threads und Schreiben von plattformunabhängigem Code mit Threads
- Beschreiben der Schwierigkeiten, die auftreten können, wenn mehrere Threads Daten gemeinsam nutzen.
- Verwenden von wait und notify für die Kommunikation zwischen Threads.
- Verwenden von synchronized zum Schutz von Daten vor Beschädigung.
Networking
- Entwickeln von Code zum Einrichten der Netzwerkverbindung.
- Kenntnis von TCP/IP
- Verwenden der ServerSocket- und Socket-Klassen zum Implementieren von TCP/IP-Clients und -Servern.
