Kurs Java + AI

Einführung. Was ist ein Algorithmus. Die grundlegenden Konstrukte einer Programmiersprache.

• Verstehen, was eine Variable ist und was nicht, einfache Datentypen, wie man schreibt.
• Verstehen, wie man Variablen richtig benennt, camel cases.
• Verstehen, was Schleifen sind und den Unterschied zwischen for-, while- und do-while-Schleifen.
• Verstehen der Reihenfolge, in der Operationen ausgeführt werden.
• Verstehen, was "Kompilieren" ist.
• Verstehen, für welche Art von Projekten Java verwendet wird.

Fortgeschrittene Konstrukte und Operatoren.

• Kenntnisse der mathematischen, binären (einschließlich Shift), logischen Operatoren.
• Verständnis des Binärsystems, Umwandlung in oder aus dem Dezimalsystem, Spaltenaddition, Verschiebung.
• Verständnis der Booleschen Algebra, Wahrheitstabelle, XOR, OR, AND, NOT.
• Verstehen des ternären Operators (Elvis-Operator).
• Git (einführend).

Fortgeschrittene Konstrukte und Operatoren (Praxis).

Arrays und mehrdimensionale Arrays.

• Verstehen, was ein eindimensionales Feld ist.
• Verstehen, was eine Matrix und ein mehrdimensionales Array sind.
• In der Lage sein, ein Array zu umgehen, ArrayIndexOutOfBound verstehen.
• Die Aufgabe des Sortierens verstehen und in der Lage sein, eine Blasensortierung durchzuführen.
• Verstehen, wie sich ein Array von einer Variablen unterscheidet und welche Daten gespeichert werden können.

Arrays und mehrdimensionale Arrays (Praxis).

Das Konzept von Klasse und Objekt. Funktionen von Methoden. Rekursion. Fehlersuche.

• Verstehen, was eine Klasse und ein Objekt sind (ohne Vererbung, Verkapselung oder Polymorphismus).
• Verstehen, was eine Funktion ist.
• Verstehen, wie man Funktionen richtig benennt.
• Verstehen, was ein Aufrufstapel ist.
• Verstehen, wie und warum Code in Funktionen aufgeteilt werden sollte (Refactoring).
• Verstehen, was Rekursion und Ausstieg aus der Rekursion sind.
• Verstehen von StackOverflowException.
• Verstehen, wie man einen Haltepunkt setzt, wo man den Aufrufstapel sieht, wie man durch den Code geht.

Git-Versionskontrollsysteme.

• Verstehen, was Verpflichtungen sind, Geschichte.
• Verstehen, was Zweige sind.
• Verstehen, was Push, Fetch, Merge und Pull sind.
• Verstehen, was eine Pull-Anfrage ist.
• Verstehen, wie Git in realen Projekten eingesetzt wird (Master, Feature Branches, Code Reviews).

Tests.

• Was sind Tests und wofür werden sie eingesetzt?
• Arten von Code- und Anwendungstests im Allgemeinen.
• Was ist TDD und TLD.
• Kennenlernen von Maven.

Der Beginn der objektorientierten Programmierung.

• Verstehen, was ein Heap ist und wie er sich von einem Stack unterscheidet.
• Verstehen von Schnittstelle, Marker-Schnittstelle, Klasse und Objekt.
• Verstehen von Feldern und Methoden, statischen Feldern und Methoden.
• Vertrautheit mit dem Begriff Domänenmodell und Verständnis dafür, dass wir es modellieren.
• Verständnis der klassischen Vererbung, finale Klassen.
• Verstehen, wie Konstruktoren funktionieren.
• Verständnis der Vererbung durch Komposition.

Objektorientierte Programmierung. Fortsetzung.

• Abstrakte Klassen. Wie sie sich von Schnittstellen unterscheiden.
• Verständnis von Polymorphismus. Frühe und späte Bindung. Die Tabelle der virtuellen Methoden.
• Aufzählungen verstehen.
• Verstehen von hashCode und equals().
• Verschiedene Arten von Referenzen.

Ausnahmen. API-Entwicklung. Was passiert, wenn eine Methode null zurückgibt?

• Die verschiedenen Ansätze zur Fehlerbehandlung verstehen: Code-Status-Rückgabe, exit(), spezielle Objektrückgabe, Ausnahmen.
• Verstehen, warum Ausnahmen benötigt werden.
• Aufzählungen verstehen.
• Den Unterschied zwischen checked und unchecked verstehen.
• try-catch-finally, rethrow verstehen.
• Verstehen der NullPointerException.
• Verstehen der Semantik von IllegalException, IllegalArgumentException.
• Verstehen der Nullsicherheit, NPE.
• Verstehen, welche Ansätze es anstelle der Rückgabe von null gibt: Ausnahmen, Optional, null object, leere Liste.
• Verstehen von Optional.
• Verstehen des Null-Objekt-Musters.
• Verstehen von Nullable-Annotationen.

Die Komplexität der Algorithmen, O-groß.

• Verstehen, was O-groß, O-klein, Theta ist.
• Den Merge-Sortieralgorithmus verstehen.
• Verstehen der linearen und binären Suche.

Generics, Sammlungen.

• Verstehen von einfachen Generic.
• Verstehen von extends, <?>.
• Verstehen, wie man eine generische Methode erstellt.
• Syntax für den Aufruf einer statischen Methode aus generischen Methoden.
• Verstehen von Sammlungen, list, set, map.
• Moderne Sammlungen verstehen (Guava).
• Verstehen von boxing/unboxing.

Sammlungen, Datenstrukturen, Fortsetzung 1.

• Verstehen von Queue, Dequeue und ihren Nachfolgern, was ist FIFO, LIFO.
• HashSet, HashMap verstehen, warum wir equals und hashCode brauchen.
• In der Lage sein, einen Iterator zu erstellen.

Sammlungen, Datenstrukturen, Fortsetzung 2.

• Verstehen, was ein Binärbaum ist, Durchlaufen eines Binärbaums.
• Verstehen, was ein Graph ist, Typen von Graphen.
• Verstehen von Algorithmen zur Durchquerung von Graphen.

Stream API.

• Funktionale Schnittstelle, Lambda-Ausdruck.
• Stream-Pipelines, Terminal- und Förderoperationen.
• Sammler.

IO/NIO.

• Verstehen, wie man eine Datei Byte für Byte liest.
• Verstehen, wie man eine Datei Byte für Byte schreibt.
• Verstehen, wie man eine Datei als String liest und schreibt.
• Verstehen der Verwendung von Dateien.
• Verstehen von try-with-resources.
• Ein allgemeines Verständnis für den Unterschied zwischen synchroner und asynchroner Programmierung.

Java Annotations, Reflection.

• Verstehen, warum Annotations verwendet werden.
• Die Fähigkeit, eine Anweisung zu erstellen.
• Verständnis von RetentionPolicy, Target, etc.
• Die Fähigkeit, die in einer Instruktion definierten Methoden zu umgehen.

SQL, JDBC.

• Verstehen, was ein relationales Modell ist.
• Verstehen von Primärschlüsseln, 1, 2, 3 Normalform.
• Verstehen von einfacher DQL, DDL.
• Verstehen, was eine Transaktion (ACID) ist.
• Verstehen, wie man die Datenbank von Java aus "ansteuert".

SQL. Hibernate.

• Was ist ORM, welche Aufgaben löst es.
• Was ist der Entity-Manager in Hibernate.
• Entitätserstellung und Beziehungen zwischen Entitäten.
• Eine kurze Einführung in HQL.

MongoDB. Schreiben eines einfachen ORM.

• Verstehen, was JSON und BSON sind.
• Den Unterschied zwischen SQL- und NoSQL-Datenbanken verstehen.
• Verstehen, was Mongo ist.
• Verstehen, wie man in einer Datenbank liest und schreibt.

Die Grundlagen von Betriebssystemen.

• Verstehen, welche Aufgaben das Betriebssystem löst.
• Verstehen der Unterschiede zwischen den wichtigsten Betriebssystemen.
• Verstehen von Prozessen und Threads, Mutexes, Semaphoren.

Linux OS.

• Verstehen, wie das Dateisystem funktioniert.
• Verstehen von stdout, stderr. Verstehen von >, &>, 2>1, etc.
• Grundlegende Terminalbefehle: Arbeiten mit Dateien, cat, less, tail, ps, top, kill.
• Verstehen von Piping.
• Grundlegende Bash-Skripte.

Objektorientiertes Design.

• Verstehen aller Buchstaben in SOLID.
• Verstehen der Grundlagen der Unix-Philosophie.
• Verstehen von winzigen Typen.
• Verstehen von Unwahrscheinlichkeiten, tiefen Kopien.
• Erstes Muster Fabrikmethode. Daher: Verständnis des privaten Konstruktors, statische Erzeugung einer Instanz.
• Allgemeines Verständnis für den Unterschied zwischen synchroner und asynchroner Programmierung

Multithreading.

• Verstehen, was Thread und Runnable sind.
• Verstehen, API von Threads.
• Verstehen, wie man einen Thread und viele Threads erstellt und ausführt.
• Verstehen von Race Condition und Dead Lock.
• Verstehen von volatile.
• Verstehen von synchronized.
• Fähigkeit, Mutex und Semaphore in Java zu verwenden.
• Verstehen von atomaren Operationen.
• Grundlegende Gleichzeitigkeitspaket-Tools.
• Verstehen, wie man Deadlock und Race Condition löst.
• Verstehen des Observer-Musters, des Wortes callback.

Networking, HTTP, Web.

• Verstehen des OSI-Modells.
• Verstehen der HTTP-Methoden und ihrer Grenzen.
• Verständnis von Headern und Cookies.
• Verstehen des Lebenszyklus einer Anfrage vom Browser zum Programm und zurück. Statistiken.

Servlets, Chain Of Responsibility.

• Die Fähigkeit, ein Projekt mit Modulen in Maven zu erstellen. - Verstehen, wie man Servlet implementiert. - Verstehen, wie man eine HTTP-Anfrage mit curl sendet. - Was Filter sind. - Verstehen des "Chain of Responsibility" Musters.

Einführung in die Theorie der Microservices.

• Cluster-Manager. Das Konzept der Skalierung.
• Verstehen, was eine monolithische Architektur ist, ihre Vor- und Nachteile.
• Verstehen, was eine Microservice-Architektur ist und ihre Vor- und Nachteile.

REST API.

• Sich mit Web- und Routing-Http-Anfragen vertraut machen und die Arbeit mit Web- und Routing-Http-Anfragen üben.

Einführung in das Spring Framework.

• Was ist IoC, DI?
• Wie der Container aufgebaut ist, das Funktionsprinzip.

Spring Boot, MVC und Daten.

• Wozu ist Spring Boot gut?
• Die Highlights der Arbeit mit MVC in Spring Boot.
• Spring Boot Repositories.

Festlegung der Aufgabenstellung für das Abschlussprojekt.

• Verstehen, welche Aufgabe durchgeführt werden soll.
• Verstehen, welche Technologie verwendet werden soll.
• Verstehen, was am Ende erwartet wird.
• Verstehen, wie, wo und warum man Javadoc schreibt.
• Über die Architektur des Projekts nachdenken.
• Agile kennenlernen.

API-Entwicklung. Muster überprüfen.

• Verstehen von Proxy-, Fassaden-, Bridge- und Adapter-Mustern und der Unterschiede zwischen ihnen.

HTML-Grundlagen.

• Verstehen der Struktur eines HTML-Dokuments.
• Verstehen von Tags und Attributen.
• Fähigkeit, Überschriften, Absätze, Listen und Links zu erstellen.
• Verstehen von semantischen Tags (Kopfzeile, Fußzeile, Abschnitt).
• Fähigkeit, mit Formularen und Eingabeelementen zu arbeiten.

CSS-Grundlagen.

• Verstehen von Selektoren und Eigenschaften.
• Verstehen des Block- und Ribbon-Modells.
• Die Grundlagen der Arbeit mit Flexbox und Grid.
• Verwendung von Farben, Schriftarten, Einzügen.
• Responsives Layout (Media-Queries).

JavaScript-Grundlagen.

• Verstehen von Variablen, Funktionen, Schleifen.
• Ereignisse und Ereignisbehandlung im Browser.
• Arbeiten mit dem DOM: Elemente suchen, Inhalte ändern, Stile.
• Grundlagen der Arbeit mit der Fetch-API für HTTP-Anfragen.
• Verständnis der Asynchronität (async/await, promises).

Frontend-Praxis.

• Erstellen einer einfachen Seite mit einem Formular.
• Erstellen einer interaktiven Schnittstelle mit Schaltflächen und Event-Handlern.
• Einbindung des Frontends in eine einfache REST-API.

Einführung in die KI für Entwickler.

• Was ist künstliche Intelligenz und große Sprachmodelle (LLMs).
• Wie KI bei der Erstellung von Webanwendungen hilft.
• Beispiele für die Anwendung von KI in realen Projekten.

Lovable.

• Eine Einführung in Lovable, ein Werkzeug für die schnelle Entwicklung von Webanwendungen.
• Automatische Frontend-Generierung.
• Integration mit dem Backend.
• Übung zur Erstellung eines Anwendungsprototyps.

Verwendung von KI für das Frontend.

• Wie man HTML/CSS/JS mit AI generiert.
• Werkzeuge zur automatischen Generierung von Komponenten.
• Beispiele für die Integration in den Workflow.

Software-Entwicklung.

• Verstehen, was ein Prompt ist.
• Wie man Abfragen an die KI richtig formuliert.
• Techniken zum Verfeinern und Optimieren von Prompts.
• Praktisches Schreiben von Prompts für die Code- und Schnittstellengenerierung.

Beschreibung.

• Das Projekt umfasst die Implementierung einer Webanwendung oder einer Website, die mehrere Seiten umfasst. Auf der praktischen Ebene demonstrieren die Studierenden die Kenntnisse, die sie während ihres Studiums erworben haben. Es wird mit Datenbanken gearbeitet, in der Regel werden die Daten in einer der SQL-DB gespeichert und müssen zwischen den Programmläufen gespeichert werden.

Verteidigung des Projekts.

• Es ist notwendig, die Praxis zu bestehen, die eine Demonstration des Arbeitsprojekts, Antworten auf alle Fragen im Zusammenhang mit dem Projekt, eine Demonstration des Codes auf Anfrage bietet. Und separat wird die Theorie zum gesamten Kursprogramm und zu allen Themen bestanden. Die Theorie wird in Form eines Bewerbungsgesprächs für eine Stelle als Junior Developer vor einem externen, unabhängigen Experten abgelegt. Sie können für beide Blöcke zwischen 0 und 100 Punkten erhalten.