📚 Lernmaterial zur Klausurvorbereitung

Daten systemübergreifend bereitstellen – OOP, JSON/XML, Git, Pseudocode

📋 Lernübersicht – Alle Themen für die Klausur

Hake die Themen ab, die du bereits beherrschst. Dein Fortschritt wird gespeichert.

🗃️ SQL – Datenbankabfragen

SELECT mit WHERE-BedingungenWichtig
INNER JOIN (Tabellen verknüpfen)Wichtig
GROUP BY mit Aggregatfunktionen (COUNT, SUM, AVG)Wichtig
HAVING (Filterung nach Gruppierung)Wichtig
ORDER BY (Sortierung)Mittel
INSERT INTO (Datensätze einfügen)Wichtig
UPDATE mit SET und WHEREWichtig
DELETE mit WHEREMittel

📄 Datenaustauschformate

JSON-Syntax (Objekte, Arrays, Datentypen)Wichtig
JSON-Datentypen (String, Number, Boolean, null)Wichtig
XML-Syntax (Tags, Attribute, Verschachtelung)Wichtig
Wohlgeformt vs. Gültig bei XMLWichtig
Vor- und Nachteile JSON vs. XMLWichtig
Anwendungsfälle für JSON und XMLMittel

🔷 OOP – Objektorientierte Programmierung (C#)

Klassen und ObjekteMittel
Zugriffsmodifikatoren (public, private, protected)Wichtig
Vererbung (: Basisklasse)Wichtig
Konstruktoren und base()Wichtig
Abstrakte Klassen und MethodenWichtig
Virtual und OverrideWichtig
Polymorphie (dynamische Bindung)Wichtig
Kapselung (Daten schützen)Mittel
Properties (get/set)Mittel
Code lesen und Ausgabe bestimmenWichtig
Eigene Klassen schreibenWichtig

🔀 Git – Versionskontrolle

Grundkonzept: Lokal vs. Remote RepositoryWichtig
git add (Staging)Wichtig
git commit (Lokaler Snapshot)Wichtig
git push (Auf Remote übertragen)Wichtig
git pull (Vom Remote holen)Mittel
Branches (Entwicklungszweige)Wichtig
Merge (Branches zusammenführen)Mittel
Merge-Konflikte erkennen und lösenWichtig
Vorteile von VersionskontrolleMittel

⚙️ Algorithmen & Pseudocode

Pseudocode-Syntax (WENN, FÜR, SOLANGE)Wichtig
Schleifen (Listen durchlaufen)Wichtig
Bedingungen (Filterung)Wichtig
Summen berechnenWichtig
Maximum/Minimum findenMittel
Zählen mit BedingungMittel
Algorithmen nachvollziehen (Trace)Wichtig
Eigene Algorithmen schreibenWichtig

📊 Punkteverteilung in der Klausur

Themenbereich	Punkte	Anteil
SQL – Abfragen und Datenmanipulation	22	22%
JSON & XML – Datenaustauschformate	18	18%
OOP – Objektorientierte Programmierung	28	28%
Git – Versionskontrolle	16	16%
Algorithmen & Pseudocode	16	16%
Gesamt	100	100%

💡 Lerntipp: OOP hat den größten Anteil – investiere hier besonders viel Zeit! SQL und JSON/XML sind auch sehr wichtig. Bei Git und Pseudocode reicht solides Grundwissen.

Objektorientierte Programmierung in C#

Die vier Säulen der OOP

Kapselung Daten und Methoden werden in Klassen zusammengefasst und vor unberechtigtem Zugriff geschützt

Vererbung Klassen können Eigenschaften und Methoden von anderen Klassen übernehmen

Polymorphie Objekte können verschiedene Formen annehmen – gleiche Methode, unterschiedliches Verhalten

Abstraktion Komplexität wird versteckt, nur relevante Details werden nach außen gezeigt

Zugriffsmodifikatoren

Modifikator	Zugriff	Verwendung
`public`	Von überall	Öffentliche Schnittstellen, API-Methoden
`private`	Nur innerhalb der Klasse	Interne Implementierungsdetails, Attribute
`protected`	Klasse + abgeleitete Klassen	Attribute/Methoden für Vererbung
`internal`	Innerhalb der Assembly	Projektinterne Klassen

abstract vs. virtual

public abstract class Tier
{
    // ABSTRACT: Keine Implementierung, MUSS überschrieben werden
    public abstract void GibLaut();
    
    // VIRTUAL: Hat Implementierung, KANN überschrieben werden
    public virtual string GetInfo()
    {
        return "Ich bin ein Tier";
    }
}

public class Hund : Tier
{
    // MUSS implementiert werden (abstract)
    public override void GibLaut()
    {
        Console.WriteLine("Wuff!");
    }
    
    // Optional: virtual überschreiben
    public override string GetInfo()
    {
        return base.GetInfo() + " - genauer: ein Hund";
    }
}

Merksatz:
• abstract = "Du MUSST das implementieren!"
• virtual = "Du KANNST das überschreiben, musst aber nicht."

Konstruktoren und base()

public class Fahrzeug
{
    protected string marke;
    
    // Konstruktor der Basisklasse
    public Fahrzeug(string marke)
    {
        this.marke = marke;
    }
}

public class Auto : Fahrzeug
{
    private int tueren;
    
    // base() ruft den Konstruktor der Basisklasse auf
    public Auto(string marke, int tueren) : base(marke)
    {
        this.tueren = tueren;
    }
}

Wichtig für die Prüfung: base() sorgt dafür, dass die geerbten Attribute korrekt initialisiert werden. Der Konstruktor der Basisklasse wird VOR dem eigenen Konstruktorcode ausgeführt.

Polymorphie in Aktion

// Variable vom Typ der Basisklasse...
Tier meinTier = new Hund();

// ...aber zur LAUFZEIT wird die Methode von Hund aufgerufen!
meinTier.GibLaut();  // Ausgabe: "Wuff!"

// Das ist Polymorphie: Die tatsächliche Methode wird
// anhand des ECHTEN Objekttyps bestimmt, nicht des Variablentyps

Prüfungsfalle: Bei der Frage "Was wird ausgegeben?" immer schauen: Welcher Typ steht nach new? Das bestimmt, welche überschriebene Methode aufgerufen wird!

Datenaustauschformate: JSON & XML

JSON (JavaScript Object Notation)

{
    "artikel": {
        "nummer": "A-001",
        "bezeichnung": "USB-Kabel",
        "preis": 4.99,
        "verfuegbar": true,
        "lagerorte": [
            { "name": "Halle A", "menge": 50 },
            { "name": "Halle B", "menge": 30 }
        ]
    }
}

Datentypen in JSON

Typ	Beispiel	Hinweis
String	`"Hallo Welt"`	Immer in doppelten Anführungszeichen
Number	`42`, `3.14`	Keine Anführungszeichen!
Boolean	`true`, `false`	Kleingeschrieben, keine Anführungszeichen
Array	`["a", "b", "c"]`	Eckige Klammern
Object	`{"key": "value"}`	Geschweifte Klammern
null	`null`	Kein Wert vorhanden

XML (eXtensible Markup Language)

<?xml version="1.0" encoding="UTF-8"?>
<artikel>
    <nummer>A-001</nummer>
    <bezeichnung>USB-Kabel</bezeichnung>
    <preis waehrung="EUR">4.99</preis>
    <verfuegbar>true</verfuegbar>
    <lagerorte>
        <lagerort>
            <name>Halle A</name>
            <menge>50</menge>
        </lagerort>
    </lagerorte>
</artikel>

Vergleich JSON vs. XML

Aspekt	JSON	XML
Lesbarkeit	✅ Kompakter	⚠️ Mehr Text
Datentypen	✅ Native Typen	⚠️ Alles Text
Kommentare	❌ Nicht möglich	✅ Möglich
Schema	⚠️ JSON Schema	✅ DTD, XSD

Wohlgeformt vs. Gültig (XML)

Wohlgeformt Syntaxregeln erfüllt:
• Ein Wurzelelement
• Tags geschlossen
• Korrekte Verschachtelung

Gültig Wohlgeformt UND entspricht Schema (DTD/XSD):
• Erlaubte Elemente
• Richtige Reihenfolge
• Korrekte Datentypen

Git – Versionskontrolle

Grundkonzepte

Repository Projektverzeichnis mit Versionshistorie

Commit Snapshot des Projekts

Branch Unabhängiger Entwicklungszweig

Merge Branches zusammenführen

Lokal vs. Remote

Lokal	Remote
Auf deinem Rechner	Auf Server (GitHub...)
Offline nutzbar	Für Teamarbeit

Der Git-Workflow

git add

→

git commit

→

git push

git add datei.cs          # Zum Staging
git commit -m "Nachricht"  # Lokal committen
git push                   # Auf Remote
git pull                   # Vom Remote holen

Merge-Konflikte

Entstehen wenn zwei Branches die gleiche Stelle unterschiedlich geändert haben.

Lösung: Datei öffnen → Konfliktmarker finden → Entscheiden → Speichern → Committen

Algorithmen & Pseudocode

Typische Pseudocode-Elemente:
WENN ... DANN ... SONST | FÜR JEDE ... IN ... | SOLANGE ... TUE | RÜCKGABE

Beispiel: Maximum finden

FUNKTION findeMaximum(zahlen):
    maximum = zahlen[0]
    FÜR JEDE zahl IN zahlen:
        WENN zahl > maximum DANN:
            maximum = zahl
    RÜCKGABE maximum

Beispiel: Filtern

FUNKTION findeUnterMindestbestand(artikel):
    ergebnisListe = leere Liste
    FÜR JEDEN art IN artikel:
        WENN art.bestand < art.mindest DANN:
            füge art zu ergebnisListe hinzu
    RÜCKGABE ergebnisListe

Beispiel: Summe berechnen

FUNKTION berechneGesamtwert(artikel):
    summe = 0
    FÜR JEDEN art IN artikel:
        summe = summe + (art.menge * art.preis)
    RÜCKGABE summe