Informatik Abschlussprüfung

Willkommen zurück

Bereit für die Prüfung?

Dieses Lernportal deckt alle 8 Prüfungsthemen der Fachinformatiker-Abschlussprüfung ab. Arbeite die Module a–h systematisch durch.

🃏 OOP-Karten 🖥️ Code-Tracing 🔍 UML Aufgaben 💻 Klassen→Code 📋 Strukt→Code

8

Lernmodule

18

OOP-Flashcards

8

Tracing-Quizze

15+

Lücken-Aufgaben

📋 Alle Prüfungsthemen

a) Ausdrücke, Operatoren, Datentypen
b) Struktogramm aus Programm erzeugen
c) Welche Ausgabe erscheint?
d) OOP-Begriffe erläutern
e) UML-Diagramm Begriffe kennen
f) UML aus Text erstellen / Fehler finden
g) Klassendiagramm → Code ergänzen
h) Struktogramm → Code ergänzen

💡 Empfohlene Reihenfolge

1. a) Ausdrücke – Basis für alles
2. d+e) OOP & UML – Begriffe lernen
3. b) Struktogramme – Diagramme verstehen
4. c) Code-Tracing – Ausgaben üben
5. f) UML Aufgaben – Fehler finden
6. g+h) Code ergänzen – alles zusammen

Modul a)

Ausdrücke & Grundlagen

Datentypen, Operatoren, Typumwandlung und Ausdruck-Auswertung – die Basis für alle anderen Themen.

Primitive Datentypen (Java)

Typ	Größe	Wertebereich	Standardwert	Beispiel
`byte`	8 Bit	−128 … 127	0	`byte b = 10;`
`short`	16 Bit	−32 768 … 32 767	0	`short s = 1000;`
`int`	32 Bit	−2 147 483 648 … 2 147 483 647	0	`int x = 42;`
`long`	64 Bit	±9.2 × 10¹⁸	0L	`long l = 99L;`
`float`	32 Bit	±3.4 × 10³⁸	0.0f	`float f = 3.14f;`
`double`	64 Bit	±1.8 × 10³⁰⁸	0.0	`double d = 3.14;`
`boolean`	1 Bit	true / false	false	`boolean ok = true;`
`char`	16 Bit	'' … ''	''	`char c = 'A';`
`String`	Objekt	beliebige Zeichenkette	null	`String s = "Hi";`

Operatoren & Priorität

Prioritätsregel (hoch → niedrig): ++/-- (unär) → * / % → + - → < > <= >= → == != → && → || → ?: → = += -=

Arithmetik	Bedeutung	Beispiel
`+, -, *, /`	Grundrechenarten	`10 / 3 → 3`
`%`	Modulo (Rest)	`10 % 3 → 1`
`++x`	Prä-Inkrement (erst erhöhen)	`x=5; y=++x → x=6,y=6`
`x++`	Post-Inkrement (erst nutzen)	`x=5; y=x++ → x=6,y=5`
`+=, -=, *=`	Kombinierte Zuweisung	`x += 3` = `x = x+3`

Vergleich / Logik	Bedeutung	Ergebnis
`==, !=`	Gleich / Ungleich	boolean
`<, >, <=, >=`	Vergleichsoperatoren	boolean
`&&`	Logisch UND (Kurzschluss)	false, wenn 1. false
`\|\|`	Logisch ODER (Kurzschluss)	true, wenn 1. true
`!`	Logische Negation	`!true → false`

Typumwandlung (Casting)

Implizite Konvertierung (automatisch)

            // Kleiner → Größer: kein Cast nötig
            int i = 42;
            long l = i;   // OK
            double d = i; // OK → 42.0
            // Reihenfolge: byte→short→int→long→float→double
          

Expliziter Cast (erzwungen)

            // Größer → Kleiner: Cast-Operator nötig!
            double d = 9.99;
            int i = (int) d; // → 9 (Nachkomma weg!)
            int a = 7, b = 2;
            double r = (double) a / b; // → 3.5
          

Kontrollstrukturen

`if / else if / else`

            if (x > 0) {
              System.out.println("positiv");
            } else if (x == 0) {
              System.out.println("null");
            } else {
              System.out.println("negativ");
            }
          

`switch`-Anweisung

            switch (tag) {
              case 1: System.out.println("Mo"); break;
              case 2: System.out.println("Di"); break;
              default: System.out.println("?");
            }
          

`for` / `for-each`

            for (int i = 0; i < 5; i++) { ... }
            
            int[] arr = {1, 2, 3};
            for (int x : arr) {
              System.out.println(x);
            }
          

`while` / `do-while`

            while (n < 3) { n++; }  // kopfgesteuert
            
            do {
              System.out.println(n);
              n++;
            } while (n < 3); // fußgesteuert
          

String-Methoden (häufig in Prüfungen)

Methode	Bedeutung	Beispiel
`s.length()`	Anzahl Zeichen	`"Hallo".length() → 5`
`s.charAt(i)`	Zeichen an Index i	`"Hallo".charAt(1) → 'a'`
`s.substring(a,b)`	Teilstring von a bis b (exkl.)	`"Hallo".substring(1,3) → "al"`
`s.toUpperCase()`	Großbuchstaben	`"hi".toUpperCase() → "HI"`
`s.equals(t)`	Inhalt vergleichen (nicht ==!)	`"a".equals("a") → true`
`s.contains("x")`	Enthält Teilstring?	`"Hallo".contains("al") → true`
`s + t`	Konkatenation (auch mit Zahlen)	`"x=" + 5 → "x=5"`

🧩 Übungen: Ausdrücke auswerten

Aufgabe: Wähle das korrekte Ergebnis des Java-Ausdrucks.

Aufgabe 1 / 6 – Ganzzahldivision & Modulo

int a = 17, b = 5;
System.out.println(a / b);
System.out.println(a % b);

3 und 3 3 und 2 3.4 und 2 4 und 2

Aufgabe 2 / 6 – Pre vs. Post-Inkrement

int x = 5;
int y = x++;
int z = ++x;
System.out.println(y + " " + z + " " + x);

5 7 7 6 7 7 5 6 7 6 6 7

Aufgabe 3 / 6 – Typumwandlung (Casting)

double d = 7.9;
int i = (int) d;
System.out.println(i);

8 (gerundet) 7 7.9 Compilerfehler

Aufgabe 4 / 6 – String-Konkatenation

int a = 2, b = 3;
System.out.println("Summe: " + a + b);
System.out.println("Summe: " + (a + b));

Summe: 5 und Summe: 5 Summe: 23 und Summe: 5 Summe: 23 und Summe: 23 Compilerfehler

Aufgabe 5 / 6 – Logische Operatoren

int x = 4;
boolean r = (x > 2) && (x % 2 == 0);
System.out.println(r);

true false 1 Compilerfehler

Aufgabe 6 / 6 – Ternärer Operator

int n = 0;
String s = (n != 0) ? "nicht null" : "null";
System.out.println(s);

nicht null null 0 false

Modul b)

Struktogramme

Nassi-Shneiderman-Diagramme – visuelle Darstellung von Algorithmen. Lerne alle Grundelemente und übe Code → Struktogramm.

Grundelemente im Überblick

① Sequenz (Folge)

x = 5

y = x * 2

Ausgabe y

Anweisungen werden von oben nach unten ausgeführt.

② Bedingte Anweisung (if/else)

x > 0

WAHRAusgabe "positiv"

FALSCHAusgabe "negativ"

Trapezform zeigt die Bedingung. Links = WAHR, Rechts = FALSCH.

③ Zählschleife (for)

i=0..4

Schleifenkopf: i < 5; i++

Ausgabe i

Linker Balken = Schleifentyp. Bedingung oben im Körper.

④ While-Schleife (kopfgesteuert)

SOLANGE

Bedingung: n < 3

Ausgabe n
n = n + 1

Bedingung wird VOR jedem Durchlauf geprüft. Kann 0× laufen.

⑤ Do-While-Schleife (fußgesteuert)

MIND. 1×

Eingabe n

Ausgabe n

SOLANGE n < 0

Bedingung steht UNTEN. Körper wird mindestens 1× ausgeführt.

⑥ Fallunterscheidung (switch)

FALL: note

1Ausgabe "Sehr gut"

2Ausgabe "Gut"

3Ausgabe "Befr."

sonstAusgabe "Keine Note"

Jede Spalte = ein case. Die letzte Spalte = default.

⑦ Vollständiges Beispiel: Summe gerader Zahlen 1–10

summe = 0

i=1..10

Schleifenkopf: i <= 10; i++

i % 2 == 0

WAHRsumme = summe + i

FALSCH– (nichts)

Ausgabe summe

Berechnet 2+4+6+8+10 = 30. Zeigt Schachtelung: Schleife enthält Bedingung.

🧩 Übung: Code → Struktogramm-Lücken ausfüllen

Aufgabe: Sieh dir den Java-Code an und fülle die Lücken im Struktogramm darunter aus.

Strukt-Aufgabe 1 / 4 ⭐ Leicht

Java-Code

              int summe = 0;
              for (int i = 1; i <= 5; i++) {
                summe = summe + i;
              }
              System.out.println(summe);
            

Struktogramm (Lücken ausfüllen)

summe =

i=1..

i <= 5; i++

summe = summe +

Ausgabe

Strukt-Aufgabe 2 / 4 ⭐⭐ Mittel

Java-Code

              int x = 10;
              while (x > 0) {
                if (x % 2 == 0) {
                  System.out.println(x);
                }
                x = x - 2;
              }
            

Struktogramm (Lücken ausfüllen)

x =

SOLANGE

x >

x % 2 ==

WAHRAusgabe x

FALSCH–

x = x -

Strukt-Aufgabe 3 / 4 ⭐⭐ Mittel

Java-Code

              int n;
              do {
                n = scanner.nextInt();
              } while (n < 1);
              System.out.println("Eingabe: " + n);
            

Welches Struktogramm-Element passt?

Kopfgesteuerte Schleife (while) – Bedingung oben Fußgesteuerte Schleife (do-while) – Bedingung unten Zählschleife (for) – mit Zähler Bedingte Anweisung (if/else)

Strukt-Aufgabe 4 / 4 ⭐⭐⭐ Schwer

Java-Code

              for (int i=1; i<=3; i++) {
                for (int j=1; j<=i; j++) {
                  System.out.print("*");
                }
                System.out.println();
              }
            

Struktogramm (Lücken ausfüllen)

i=1..

i<=3; i++

j=1..

j<=i; j++

Ausgabe ""

Ausgabe Zeilenumbruch

Modul c)

Code-Tracing – Welche Ausgabe erscheint?

Analysiere den Code Zeile für Zeile und trage die exakte Konsolenausgabe ein. Groß-/Kleinschreibung und Leerzeichen zählen!

💡 Tracing-Strategie

1. Variablen-Tabelle anlegen: Name | Typ | aktueller Wert
2. Zeile für Zeile durchgehen – bei jeder Zuweisung den Wert aktualisieren
3. Schleifen: Zähler mitführen, Bedingung vor jedem Durchlauf prüfen
4. Integer-Division: 7/2 = 3 (kein Rest), Modulo: 7%2 = 1
5. print = kein Zeilenumbruch, println = mit Zeilenumbruch

Aufgabe 1 / 8 ⭐ Leicht – for-Schleife

          int x = 1;
          for (int i = 0; i < 4; i++) {
            x = x * 2;
            System.out.println(x);
          }
        

Exakte Konsolenausgabe (eine Zeile pro println):

Aufgabe 2 / 8 ⭐ Leicht – Division & Ternär

          int a = 10, b = 3;
          System.out.println(a / b);
          System.out.println(a % b);
          System.out.println(a > b ? "groesser" : "kleiner");
        

Aufgabe 3 / 8 ⭐⭐ Mittel – Array & for-each

          int[] arr = {3, 1, 4, 1, 5};
          int sum = 0;
          for (int val : arr) {
            if (val % 2 != 0) sum += val;
          }
          System.out.println("Summe: " + sum);
        

Aufgabe 4 / 8 ⭐⭐ Mittel – geschachtelte Schleifen

          for (int i = 1; i <= 3; i++) {
            for (int j = 1; j <= i; j++) {
              System.out.print("*");
            }
            System.out.println();
          }
        

Tipp: print macht keinen Zeilenumbruch, println() schon.

Aufgabe 5 / 8 ⭐⭐ Mittel – String-Methoden

          String s = "Hallo";
          System.out.println(s.length());
          System.out.println(s.toUpperCase());
          System.out.println(s.charAt(1));
          System.out.println(s.substring(1, 4));
        

Aufgabe 6 / 8 ⭐⭐ Mittel – while & Post-Dekrement

          int i = 5;
          while (i > 0) {
            System.out.println(i--);
          }
        

Tipp: i-- gibt erst den alten Wert aus, dann verringert es i.

Aufgabe 7 / 8 ⭐⭐⭐ Schwer – String-Konkatenation & Casting

          int a = 5, b = 2;
          System.out.println(a + b);
          System.out.println("Wert: " + a + b);
          System.out.println("Wert: " + (a + b));
          System.out.println((double) a / b);
        

Aufgabe 8 / 8 ⭐⭐⭐ Schwer – Methode & Schleife

          static int quadrat(int n) {
            return n * n;
          }
          // In main():
          int summe = 0;
          for (int i = 1; i <= 4; i++) {
            if (i % 2 != 0)
              summe += quadrat(i);
          }
          System.out.println("Ergebnis: " + summe);
        

Tipp: Nur ungerade i (1,3) fließen ein. quadrat(1)=1, quadrat(3)=9.

Modul d)

OOP Begriffe

Klicke auf eine Karte, um sie umzudrehen. Lerne alle 18 Grundbegriffe der objektorientierten Programmierung.

OOP Grundlage

Klasse

→ klicken zum Aufdecken

Bauplan/Vorlage für Objekte. Definiert Attribute (Felder) und Methoden.

class Auto { String farbe; void fahren() {} }

OOP Grundlage

Objekt

→ klicken zum Aufdecken

Konkrete Instanz einer Klasse mit eigenen Attributwerten. Erstellt mit new.

Auto meinAuto = new Auto("rot");

OOP Prinzip

Vererbung

→ klicken zum Aufdecken

Kindklasse erbt Attribute und Methoden der Elternklasse (extends). Ermöglicht Wiederverwendung.

class ElektroAuto extends Auto { int akku; }

OOP Prinzip

Polymorphie

→ klicken zum Aufdecken

Gleicher Methodenname, unterschiedliches Verhalten je nach Objekt (via @Override). Eine Elternklassenreferenz kann Kindklassenobjekte halten.

Auto a = new ElektroAuto(); a.fahren();

OOP Prinzip

Kapselung

→ klicken zum Aufdecken

Interne Details verbergen. Attribute private, Zugriff nur über public Getter/Setter. Schützt Datenintegrität.

private int alter; public int getAlter() { return alter; }

OOP Prinzip

Abstraktion

→ klicken zum Aufdecken

Vereinfachung der Realität auf das Wesentliche. Komplexe Details werden hinter einfachen Schnittstellen verborgen.

Auto.fahren() – das WIE ist intern, das WAS ist extern.

Klassen-Typ

Abstrakte Klasse

→ klicken zum Aufdecken

Mit abstract deklariert. Kann NICHT instanziiert werden. Enthält abstrakte Methoden (ohne Körper), die Unterklassen implementieren müssen.

abstract class Form { abstract double flaeche(); }

Klassen-Typ

Interface

→ klicken zum Aufdecken

Rein abstrakte Schnittstelle (nur Methodensignaturen). Klasse kann mehrere Interfaces implementieren (implements). Kein Zustand.

interface Fahrbar { void fahren(); }
class Auto implements Fahrbar { ... }

Methoden

Konstruktor

→ klicken zum Aufdecken

Spezielle Methode mit Klassenname, kein Rückgabetyp. Wird bei new aufgerufen. Initialisiert Attribute. Kann überladen werden.

Auto(String farbe) { this.farbe = farbe; }

Schlüsselwort

this

→ klicken zum Aufdecken

Referenz auf das aktuelle Objekt. Unterscheidet lokale Parameter von Attributen gleichen Namens.

void setName(String name) { this.name = name; }

Schlüsselwort

super

→ klicken zum Aufdecken

Referenz auf die Elternklasse. super() ruft Elternkonstruktor auf. super.methode() ruft überschriebene Methode der Elternklasse auf.

class Hund extends Tier { Hund() { super("Hund"); } }

Methoden

Überschreiben (@Override)

→ klicken zum Aufdecken

Kindklasse ersetzt Implementierung einer geerbten Methode. Gleiche Signatur. @Override ist optional, aber empfohlen.

@Override public void fahren() { System.out.println("elektrisch"); }

Methoden

Überladen (Overloading)

→ klicken zum Aufdecken

Mehrere Methoden mit gleichem Namen, aber unterschiedlichen Parametern (Anzahl oder Typ). In derselben Klasse.

void print(int x) {}
void print(String s) {}
void print(int x, int y) {}

Modifikatoren

static

→ klicken zum Aufdecken

Gehört zur Klasse, nicht zum Objekt. Kann ohne Instanz aufgerufen werden. Klassenvariable/-methode.

static int anzahl = 0;
Auto.getAnzahl(); // kein new nötig

Sichtbarkeit

Zugriffsmodifikatoren

→ klicken zum Aufdecken

public: überall · private: nur eigene Klasse · protected: Klasse + Unterklassen · (kein): gleiche Package

private int x; // nur diese Klasse
public void zeige() {} // alle

Entwurf

Getter & Setter

→ klicken zum Aufdecken

Getter: liest ein private Attribut (getX()). Setter: schreibt ein private Attribut (setX(wert)), kann Validierung enthalten.

public String getName() { return name; }
public void setName(String n) { this.name = n; }

Konzept

Aggregation

→ klicken zum Aufdecken

„Hat-ein" Beziehung. Das Teil kann unabhängig existieren. Im UML: leere Raute (◇─) am Ganzen.

class Team { List<Person> mitglieder; }
// Person existiert auch ohne Team

Konzept

Komposition

→ klicken zum Aufdecken

Starke „Hat-ein" Beziehung. Das Teil kann NICHT unabhängig existieren – stirbt mit dem Ganzen. Im UML: ausgefüllte Raute (◆─).

class Haus { Raum zimmer; }
// Raum ohne Haus sinnlos

Modul e)

UML Begriffe

Unified Modeling Language – Notation, Beziehungstypen, Multiplizitäten und Klassendiagramm-Aufbau.

Aufbau eines UML-Klassendiagramms

Jede Klasse besteht aus 3 Bereichen:

«abstract» Fahrzeug

- marke: String

- baujahr: int

+ anzahl: int (static=unterstrichen)

+ fahren(): void

+ getMarke(): String

# berechne(n: int): double

- intern(): void

          + = public
          - = private
          # = protected
          ~ = package
        

Beziehungstypen im Überblick

──▷

Vererbung

Volle Linie, offene Pfeilspitze (Dreieck). Kind → Eltern. Java: extends

- -▷

Realisierung

Gestrichelte Linie, offene Pfeilspitze. Klasse → Interface. Java: implements

────

Assoziation

Einfache Linie. „kennt" oder „nutzt". Optional mit Pfeil für Richtung.

◇───

Aggregation

Leere Raute am Ganzen. Teil kann ohne Ganzes existieren. (schwache Bindung)

◆───

Komposition

Ausgefüllte Raute am Ganzen. Teil existiert NICHT ohne Ganzes. (starke Bindung)

- - →

Abhängigkeit

Gestrichelte Linie mit Pfeil. Eine Klasse nutzt eine andere temporär (z.B. als Parameter).

Multiplizitäten (Kardinalitäten)

Notation	Bedeutung	Beispiel
`1`	Genau eine Instanz	Jeder Auftrag hat genau 1 Kunden
`0..1`	Null oder eine Instanz	Person hat 0 oder 1 Führerschein
`` oder `0..`	Beliebig viele (auch keine)	Kunde hat 0..* Bestellungen
`1..*`	Mindestens eine	Team hat mindestens 1 Mitglied
`2..5`	Feste Spanne	Auto hat 2 bis 5 Türen

Vollständiges Beispiel-Diagramm (Vererbung + Interface)

«interface»Fahrbar

– keine Attribute –

+ fahren(): void

+ bremsen(): void

▲

implements
(- -▷)

«abstract»Fahrzeug

- marke: String

# geschwindigkeit: int

+ fahren(): void

+ getMarke(): String

▲

extends
(──▷)

Auto

- tueren: int

+ fahren(): void

+ getTueren(): int

Motorrad

- hatBeiwagen: boolean

+ fahren(): void

Schnellreferenz-Glossar

+ (public)

Von überall zugreifbar. Keine Einschränkung.

- (private)

Nur innerhalb der eigenen Klasse sichtbar.

# (protected)

Klasse und alle Unterklassen. Auch gleiche Package.

~ (package)

Nur Klassen im gleichen Package sichtbar.

Kursiv = abstrakt

Kursive Klassennamen oder Methoden = abstract.

Unterstrichen = static

Unterstrichene Attribute/Methoden = static.

«interface»

Stereotype für Interfaces im Klassendiagramm.

«abstract»

Stereotype für abstrakte Klassen.

Navigierbarkeit

Pfeilspitze zeigt, in welche Richtung zugegriffen werden kann.

Rollenname

Beschriftung einer Assoziation an der Pfeilspitze (z.B. „fahrer").

Attribut-Syntax

Sichtbarkeit name: Typ = Standardwert

Methoden-Syntax

Sichtbarkeit name(param: Typ): Rückgabetyp

Modul f)

UML Aufgaben

Aus einem Text ein UML-Diagramm ableiten und Fehler in vorhandenen Diagrammen erkennen.

Teil 1: Fehler im UML-Diagramm finden

Aufgabe: Betrachte das Diagramm und wähle, welche Aussage den Fehler korrekt beschreibt.

Fehler-Aufgabe 1 / 3 ⭐ Leicht

Das folgende Diagramm beschreibt: „Hund erbt von Tier". Finde den Fehler:

Hund

- name: String

+ bellen(): void

▲

extends
← Fehler hier?

Tier

# alter: int

+ essen(): void

Die Klasse Tier sollte abstract sein Der Vererbungspfeil zeigt in die falsche Richtung – er muss von Hund auf Tier zeigen Hund fehlt ein Konstruktor im Diagramm Das Attribut alter sollte private sein

Fehler-Aufgabe 2 / 3 ⭐⭐ Mittel

Finde zwei Fehler in diesem Klassendiagramm:

Bankkonto

+ kontostand: double ← ?

- inhaber: String

+ einzahlen(betrag): ← ?

+ getKontostand(): double

kontostand sollte private sein; einzahlen() fehlt Parametertyp und Rückgabetyp inhaber sollte public sein; getKontostand() sollte private sein Die Klasse braucht einen Konstruktor; kontostand fehlt ein Standardwert kontostand sollte static sein; einzahlen() sollte abstract sein

Fehler-Aufgabe 3 / 3 ⭐⭐⭐ Schwer

Text: „Ein Haus besteht aus Räumen. Ein Raum kann ohne ein Haus nicht existieren. Die Multiplizität ist: 1 Haus hat 1 bis viele Räume."
Was ist am folgenden Diagramm falsch?

Haus

- adresse: String

+ getAdresse(): String

◇──

1 *

Raum

- groesse: double

+ getGroesse(): double

Die Multiplizität * sollte 1..* sein; die Raute sollte ausgefüllt sein (◆, Komposition) Die Beziehung sollte Vererbung sein (──▷), kein Aggregation Die Raute gehört an die Raum-Seite, nicht an die Haus-Seite Der Rückgabetyp von getAdresse() fehlt

Teil 2: Aus Text ein UML-Diagramm ableiten

Aufgabe: Lies den Beschreibungstext und beantworte die Fragen zum korrekten UML-Diagramm.

Text→UML 1 / 3 ⭐ Leicht

Beschreibung: „Es gibt eine Klasse Tier mit dem privaten Attribut name (String) und der öffentlichen Methode essen() (kein Rückgabewert). Die Klasse Hund erbt von Tier und hat zusätzlich die Methode bellen()."

Frage: Welche UML-Notation ist für das Attribut name in der Klasse Tier korrekt?

+ name: String - name: String # name: String name: String

Text→UML 2 / 3 ⭐⭐ Mittel

Beschreibung: „Eine Bibliothek verwaltet Bücher. Ein Buch gehört immer zu genau einer Bibliothek und kann nicht ohne sie existieren. Eine Bibliothek kann beliebig viele Bücher haben."

Welche Beziehung und Multiplizität ist korrekt?

Aggregation (◇); Bibliothek 1 — * Buch Komposition (◆) an Bibliothek; Bibliothek 1 — 1..* Buch Vererbung (──▷); Buch erbt von Bibliothek Assoziation (────); Bibliothek * — * Buch

Text→UML 3 / 3 ⭐⭐⭐ Schwer

Beschreibung: „Das Interface Druckbar hat die Methode drucken(). Die Klasse Dokument implementiert dieses Interface und hat zusätzlich das private Attribut inhalt (String) sowie die öffentliche Methode speichern(): boolean."

Welche Aussage über das korrekte UML-Diagramm ist falsch?

Druckbar wird mit «interface» Stereotype gekennzeichnet Der Pfeil von Dokument zu Druckbar ist gestrichelt mit offener Pfeilspitze (- -▷) Dokument verwendet extends für die Verbindung zu Druckbar inhalt wird als - inhalt: String notiert

Modul g)

Klassendiagramm → Code ergänzen

Ein Klassendiagramm ist vorgegeben. Ergänze die fehlenden Zeilen im Java-Quelltext.

UML-Klassendiagramm

Person

- name: String

- alter: int

+ Person(name: String, alter: int)

+ getName(): String

+ getAlter(): int

+ setAlter(a: int): void

Java-Quelltext (Lücken ausfüllen)

              public class Person {
                 String name;
                 int alter;
              
                public (String name, int alter) {
                  .name = name;
                  this.alter = alter;
                }
              
                public String getName() {
                  return ;
                }
              
                public int getAlter() { return alter; }
              
                public void setAlter(int a) {
                   = a;
                }
              }
            

💡 L1+2: Attribut ist private (-) → Schlüsselwort private
💡 L3: Konstruktor hat denselben Namen wie die Klasse
💡 L4: Schlüsselwort für das aktuelle Objekt
💡 L5: Getter gibt das Attribut zurück
💡 L6: Setter braucht this.alter um das Attribut zu setzen

UML-Klassendiagramm

«abstract»Tier

# name: String

+ Tier(name: String)

+ lautGeben(): void

+ getName(): String

▲ extends

Hund

- rasse: String

+ Hund(name: String, rasse: String)

+ lautGeben(): void

Java-Quelltext (Lücken ausfüllen)

              abstract class Tier {
                protected String name;
                public Tier(String name) { this.name = name; }
                public abstract void lautGeben();
                public String getName() { return name; }
              }
              
              class Hund  Tier {
                private String rasse;
              
                public Hund(String name, String rasse) {
                  ;
                  this.rasse = rasse;
                }
              
                
                public void lautGeben() {
                  System.out.println("Wuff!");
                }
              }
            

💡 L8: Vererbung in Java = extends
💡 L12: Elternkonstruktor aufrufen: super(name)
💡 L16: Annotation für überschriebene Methoden

UML-Klassendiagramm

«interface»Berechenbar

– keine Attribute –

+ berechneFlaeche(): double

+ berechneUmfang(): double

▲ implements (- -▷)

Rechteck

- breite: double

- hoehe: double

+ Rechteck(b: double, h: double)

+ berechneFlaeche(): double

+ berechneUmfang(): double

Java-Quelltext (Lücken ausfüllen)

               Berechenbar {
                double berechneFlaeche();
                double berechneUmfang();
              }
              
              class Rechteck  Berechenbar {
                private double breite, hoehe;
              
                public Rechteck(double b, double h) {
                  breite = b; hoehe = h;
                }
              
                public double berechneFlaeche() {
                  return ;
                }
              
                public double berechneUmfang() {
                  return ;
                }
              }
            

💡 L1: Deklaration eines Interface
💡 L6: Klasse, die Interface umsetzt: implements
💡 L14: Fläche Rechteck = Breite × Höhe
💡 L18: Umfang Rechteck = 2 × (Breite + Höhe)

Modul h)

Struktogramm → Code ergänzen

Ein Struktogramm ist vorgegeben. Ergänze den fehlenden Java-Quelltext.

Struktogramm

summe = 0

i=1..n

Schleifenkopf: i <= n; i++

summe = summe + i

Ausgabe summe

Java-Code (Lücken ausfüllen)

              int summe = ;
              for (int i = ; i  n; i++) {
                summe = summe + ;
              }
              System.out.println();
            

Struktogramm

x = 100

SOLANGE

x > 1

x % 2 == 0

WAHRx = x / 2

FALSCHx = x * 3 + 1

Ausgabe x

Java-Code (Lücken ausfüllen)

              int x = ;
              while () {
                if (x % 2 == ) {
                  x = x / ;
                } else {
                  x = x * 3 + ;
                }
              }
              System.out.println(x);
            

Struktogramm

MIND. 1×

Eingabe zahl

zahl < 0

WAHRAusgabe "Ungültig"

FALSCH– (nichts)

SOLANGE zahl < 0

Ausgabe "OK: " + zahl

Java-Code (Lücken ausfüllen)

              int zahl;
               {
                zahl = scanner.nextInt();
                if () {
                  System.out.println("Ungültig");
                }
              } while ();
              System.out.println("OK: " + );
            

💡 Fußgesteuerte Schleife in Java = do { ... } while (Bedingung);

Struktogramm

FALL: ampel

"rot"Ausgabe "Stop!"

"gelb"Ausgabe "Achtung!"

"gruen"Ausgabe "Fahren!"

sonstAusgabe "Fehler"

Java-Code (Lücken ausfüllen)

              switch () {
                case "rot":
                  System.out.println("Stop!");
                  ;
                case "gelb":
                  System.out.println("Achtung!");
                  break;
                case "gruen":
                  System.out.println("Fahren!"); break;
                :
                  System.out.println("Fehler");
              }
            

Modul 05

Lückentext-Training

Ergänze die fehlenden Code-Stellen. Auf „Prüfen" klicken, um deine Antworten zu überprüfen.

Ergänze den Code für eine Klasse Form mit Unterklassen Kreis und Rechteck:

          abstract class Form {
            abstract double flaeche();
          }
          
          class Kreis  Form {
            double radius;
            public double flaeche() {
              return .PI * radius * radius;
            }
          }
          
          class Rechteck extends Form {
            double breite, hoehe;
            public double flaeche() {
              return ;
            }
          }
        

Diese Methode soll die Summe aller geraden Zahlen von 1 bis n berechnen. Ergänze die fehlenden Teile:

          int summeGerade(int n) {
            int summe = ;
            for (int i = 1; ; i++) {
              if (i % 2 == ) {
                summe  i;
              }
            }
            return summe;
          }
        

Ergänze die Klasse Person mit Konstruktor und Getter:

          class Person {
            private String name;
            private int alter;
          
            (String name, int alter) {
              .name = name;
              this.alter = alter;
            }
          
            public String getName() {
              return ;
            }
          }
        

Bereit für die Prüfung?

📋 Alle Prüfungsthemen

💡 Empfohlene Reihenfolge

Ausdrücke & Grundlagen

Primitive Datentypen (Java)

Operatoren & Priorität

Typumwandlung (Casting)

Implizite Konvertierung (automatisch)

Expliziter Cast (erzwungen)

Kontrollstrukturen

if / else if / else

switch-Anweisung

for / for-each

while / do-while

String-Methoden (häufig in Prüfungen)

🧩 Übungen: Ausdrücke auswerten

Struktogramme

Grundelemente im Überblick

① Sequenz (Folge)

② Bedingte Anweisung (if/else)

③ Zählschleife (for)

④ While-Schleife (kopfgesteuert)

⑤ Do-While-Schleife (fußgesteuert)

⑥ Fallunterscheidung (switch)

⑦ Vollständiges Beispiel: Summe gerader Zahlen 1–10

🧩 Übung: Code → Struktogramm-Lücken ausfüllen

Code-Tracing – Welche Ausgabe erscheint?

💡 Tracing-Strategie

OOP Begriffe

UML Begriffe

Aufbau eines UML-Klassendiagramms

Beziehungstypen im Überblick

Multiplizitäten (Kardinalitäten)

Vollständiges Beispiel-Diagramm (Vererbung + Interface)

Schnellreferenz-Glossar

UML Aufgaben

Teil 1: Fehler im UML-Diagramm finden

Teil 2: Aus Text ein UML-Diagramm ableiten

Klassendiagramm → Code ergänzen

Struktogramm → Code ergänzen

Lückentext-Training

`if / else if / else`

`switch`-Anweisung

`for` / `for-each`

`while` / `do-while`