Aufgabe 3

.idea/GitLink.xml

@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="uk.co.ben_gibson.git.link.SettingsState">
+    <option name="host" value="e0f86390-1091-4871-8aeb-f534fbc99cf0" />
+  </component>
+</project>

gui/AngestellterGui.java

@@ -0,0 +1,207 @@
+/**
+ * Klasse für die Darstellung von Angestellten.
+ */
+package gui;
+
+import java.awt.BorderLayout;
+import java.awt.event.ActionEvent;
+import java.awt.event.ActionListener;
+
+import javax.swing.JButton;
+import javax.swing.JDesktopPane;
+import javax.swing.JInternalFrame;
+import javax.swing.JPanel;
+import javax.swing.JScrollPane;
+import javax.swing.JTable;
+import javax.swing.table.DefaultTableModel;
+
+import personen.Angestellter;
+import personen.Person;
+
+/**
+ * Diese Klasse ist für die Darstellung der Angestellten
+ * zuständig.
+ * 
+ * @author konrad
+ */
+public class AngestellterGui extends InternalFrameElternklasse {
+
+	/** Referenz auf das Feld der Angestellten. */
+	private Angestellter angestelltenFeld[];
+
+	// Graphische Elemente der Oberfläche
+	private JTable table;
+	private DefaultTableModel model;
+	private JPanel panel;
+	private JScrollPane scrollPane;
+
+	/**
+	 * @param title Titel im Kopf des Fensters.
+	 * @param angestelltenFeld Referenz auf das Feld der Angestellten.
+	 * @param desktop Referenz auf die Arbeitsfläche.
+	 * @param gui Referenz auf die zentrale GUI-Klasse.
+	 */
+	public AngestellterGui(String title, Angestellter angestelltenFeld[],
+		JDesktopPane desktop, Gui gui) {
+		this(title, true, angestelltenFeld, desktop, gui);
+	}
+
+	
+	/**
+	 * @param title Titel im Kopf des Fensters.
+	 * @param resizable Flag, ob die Größe des Fensters änderbar ist.
+	 * @param angestelltenFeld Referenz auf das Feld der Angestellten.
+	 * @param desktop Referenz auf die Arbeitsfläche.
+	 * @param gui Referenz auf die zentrale GUI-Klasse.
+	 */
+	public AngestellterGui(String title, boolean resizable,
+			Angestellter angestelltenFeld[],
+			JDesktopPane desktop, Gui gui) {
+		this(title, resizable, true, angestelltenFeld, desktop, gui);
+	}
+
+	
+	/**
+	 * @param title Titel im Kopf des Fensters.
+	 * @param resizable Flag, ob die Größe des Fensters änderbar ist.
+	 * @param closable Flag, ob das Fenster ganz geschlossen werden kann.
+	 * @param angestelltenFeld Referenz auf das Feld der Angestellten.
+	 * @param desktop Referenz auf die Arbeitsfläche.
+	 * @param gui Referenz auf die zentrale GUI-Klasse.
+	 */
+	public AngestellterGui(String title, boolean resizable, boolean closable,
+			Angestellter angestelltenFeld[],
+			JDesktopPane desktop, Gui gui) {
+		this(title, resizable, closable, true, angestelltenFeld, desktop, gui);
+	}
+
+	
+	/**
+	 * @param title Titel im Kopf des Fensters.
+	 * @param resizable Flag, ob die Größe des Fensters änderbar ist.
+	 * @param closable Flag, ob das Fenster ganz geschlossen werden kann.
+	 * @param maximizable Flag, ob das Fenster maximiert werden kann.
+	 * @param angestelltenFeld Referenz auf das Feld der Angestellten.
+	 * @param desktop Referenz auf die Arbeitsfläche.
+	 * @param gui Referenz auf die zentrale GUI-Klasse.
+	 */
+	public AngestellterGui(String title, boolean resizable, boolean closable, boolean maximizable,
+			Angestellter angestelltenFeld[],
+			JDesktopPane desktop, Gui gui) {
+		this(title, resizable, closable, maximizable, true, angestelltenFeld, desktop, gui);
+	}
+
+
+	/**
+	 * Umfangreichster Konstruktor zum Erzeugen eines Fensters
+	 * für Angestellte, das als JInternalFrame einem JDesktop
+	 * hinzugefügt werden kann.
+	 * @param title Titel im Kopf des Fensters.
+	 * @param resizable Flag, ob die Größe des Fensters änderbar ist.
+	 * @param closable Flag, ob das Fenster ganz geschlossen werden kann.
+	 * @param maximizable Flag, ob das Fenster maximiert werden kann.
+	 * @param iconifiable Flag, ob das Fenster zum Icon minimiert werden kann.
+	 * @param angestelltenFeld Referenz auf das Feld der Angestellten.
+	 * @param desktop Referenz auf die Arbeitsfläche.
+	 * @param gui Referenz auf die zentrale GUI-Klasse.
+	 */
+	public AngestellterGui(String title, boolean resizable, boolean closable, boolean maximizable,
+			boolean iconifiable,
+			Angestellter angestelltenFeld[],
+			JDesktopPane desktop, Gui gui) {
+		super(title, resizable, closable, maximizable, iconifiable,
+					desktop, gui);
+		
+		this.angestelltenFeld = angestelltenFeld;
+		
+		this.model = new DefaultTableModel();
+		this.table = new JTable(this.model);
+		
+		// Erstellen eines Panels für den Inhalt des internen Frames
+        this.panel = new JPanel(new BorderLayout());
+		
+		this.scrollPane = new JScrollPane(this.table);
+		panel.add(scrollPane, BorderLayout.CENTER);
+
+		// Knopf zum Speichern von Änderungen erstellen
+		JButton speichernButton = new JButton("Änderungen speichern");
+		speichernButton.addActionListener(new ActionListener() {
+			public void actionPerformed(ActionEvent e) {
+				aenderungenSpeichern();
+			}
+		});		
+		panel.add(speichernButton, BorderLayout.SOUTH);
+
+		this.add(panel);
+
+		// x, y, breite, hoehe
+		this.setBounds(33, 47, 192, 202);
+		this.setVisible(true);
+		String spaltenNamen[] = { "Name", "Personalnummer" };
+		erzeugeTabelle(angestelltenFeld, spaltenNamen);
+	}
+
+
+    /**
+     * Implementierung der abstrakten Methode aus InternalFrameElternklasse.
+     * Diese Methode wird aufgerufen, wenn das Fenster geschlossen wird.
+     * Sie ist dafür zuständig, die spezifische Referenz in der Gui-Klasse
+     * auf null zu setzen.
+     */
+    @Override
+    protected void handleFrameClosed() {
+        if (mainGuiRef != null) { // mainGuiRef kommt von InternalFrameElternklasse
+            mainGuiRef.setAngestelltenGuiToNull();
+        }
+    }
+
+    
+    /**
+	 * Das Datenmodell der Tabelle mit Daten befüllen.
+	 * @param datenQuelle 1D-Feld mit Angestellten-Objekten.
+	 * @param spaltenNamen 1D-Feld mit den Namen bzw. 
+	 * 		Überschriften der Spalten.
+	 */
+	private void erzeugeTabelle(Object datenQuelle[], String spaltenNamen[]) {
+		// Erstellen der Daten für die Tabelle
+		Object[][] daten = new Object[datenQuelle.length][spaltenNamen.length];
+		for(int zeile = 0; zeile < datenQuelle.length; zeile++) {
+			int spalte = 0;
+			daten[zeile][spalte] = ((Person)datenQuelle[zeile]).getName();
+			spalte++;
+			daten[zeile][spalte] = ((Angestellter)datenQuelle[zeile]).getPersonalNr();
+		}
+		this.model.setRowCount(datenQuelle.length);
+		this.model.setDataVector(daten, spaltenNamen);
+		this.setVisible(true);
+	}
+
+	
+	/**
+	 * Die interaktiven Änderungen in der Tabelle
+	 * im Feld der Angestellten speichern. 
+	 */
+	private void aenderungenSpeichern() {
+		int zeilenN = this.model.getRowCount();
+		int spaltenN = this.model.getColumnCount();
+		String name; 
+		int personalNr;
+		for(int zeile = 0; zeile < zeilenN; zeile++) {
+			name = (String)(this.model.getValueAt(zeile, 0));
+			Object o = this.model.getValueAt(zeile, 1);
+			personalNr = 0;
+			// Greift, sobald einmal eine Zelle geändert worden ist
+			if(o instanceof String) {
+				String text = (String)o;
+				personalNr = Integer.parseInt(text);
+			}
+			// Greift, solange eine Zelle noch nicht geändert worden ist
+			if(o instanceof Integer) {
+				personalNr = (Integer)(this.model.getValueAt(zeile, 1));
+			}
+			angestelltenFeld[zeile].setName(name);
+			angestelltenFeld[zeile].setPersonalNr(personalNr);
+		}
+	}
+	
+}

gui/DHStudentGui.java

@@ -0,0 +1,212 @@
+/**
+ * Klasse für die Darstellung von DH-Studenten.
+ */
+package gui;
+
+import java.awt.BorderLayout;
+import java.awt.event.ActionEvent;
+import java.awt.event.ActionListener;
+
+import javax.swing.JButton;
+import javax.swing.JDesktopPane;
+import javax.swing.JInternalFrame;
+import javax.swing.JPanel;
+import javax.swing.JScrollPane;
+import javax.swing.JTable;
+import javax.swing.table.DefaultTableModel;
+
+import personen.Person;
+import personen.studenten.DHStudent;
+import personen.studenten.Student;
+
+/**
+ * Diese Klasse ist für die Darstellung der DH-Studenten
+ * zuständig.
+ * 
+ * @author konrad
+ */
+public class DHStudentGui extends InternalFrameElternklasse {
+
+	/** Referenz auf das Feld der DH-Studenten. */
+	private DHStudent dhStudentenFeld[];
+
+	// Graphische Elemente der Oberfläche
+	private JTable table;
+	private DefaultTableModel model;
+	private JPanel panel;
+	private JScrollPane scrollPane;
+
+	/**
+	 * @param title Titel im Kopf des Fensters.
+	 * @param angestelltenFeld Referenz auf das Feld der DH-Studenten.
+	 * @param desktop Referenz auf die Arbeitsfläche.
+	 * @param gui Referenz auf die zentrale GUI-Klasse.
+	 */
+	public DHStudentGui(String title, DHStudent dhStudentenFeld[],
+			JDesktopPane desktop, Gui gui) {
+		this(title, true, dhStudentenFeld, desktop, gui);
+	}
+
+	
+	/**
+	 * @param title Titel im Kopf des Fensters.
+	 * @param resizable Flag, ob die Größe des Fensters änderbar ist.
+	 * @param angestelltenFeld Referenz auf das Feld der DH-Studenten.
+	 * @param desktop Referenz auf die Arbeitsfläche.
+	 * @param gui Referenz auf die zentrale GUI-Klasse.
+	 */
+	public DHStudentGui(String title, boolean resizable,
+			DHStudent dhStudentenFeld[],
+			JDesktopPane desktop, Gui gui) {
+		this(title, resizable, true, dhStudentenFeld, desktop, gui);
+	}
+
+
+	/**
+	 * @param title Titel im Kopf des Fensters.
+	 * @param resizable Flag, ob die Größe des Fensters änderbar ist.
+	 * @param closable Flag, ob das Fenster ganz geschlossen werden kann.
+	 * @param angestelltenFeld Referenz auf das Feld der DH-Studenten.
+	 * @param desktop Referenz auf die Arbeitsfläche.
+	 * @param gui Referenz auf die zentrale GUI-Klasse.
+	 */
+	public DHStudentGui(String title, boolean resizable, boolean closable,
+			DHStudent dhStudentenFeld[],
+			JDesktopPane desktop, Gui gui) {
+		this(title, resizable, closable, true, dhStudentenFeld, desktop, gui);
+	}
+
+	
+	/**
+	 * @param title Titel im Kopf des Fensters.
+	 * @param resizable Flag, ob die Größe des Fensters änderbar ist.
+	 * @param closable Flag, ob das Fenster ganz geschlossen werden kann.
+	 * @param maximizable Flag, ob das Fenster maximiert werden kann.
+	 * @param angestelltenFeld Referenz auf das Feld der DH-Studenten.
+	 * @param desktop Referenz auf die Arbeitsfläche.
+	 * @param gui Referenz auf die zentrale GUI-Klasse.
+	 */
+	public DHStudentGui(String title, boolean resizable, boolean closable, boolean maximizable,
+			DHStudent dhStudentenFeld[],
+			JDesktopPane desktop, Gui gui) {
+		this(title, resizable, closable, maximizable, true,
+				dhStudentenFeld, desktop, gui);
+	}
+
+
+	/**
+	 * Umfangreichster Konstruktor zum Erzeugen eines Fensters
+	 * für DH-Studenten, das als JInternalFrame einem JDesktop
+	 * hinzugefügt werden kann.
+	 * @param title Titel im Kopf des Fensters.
+	 * @param resizable Flag, ob die Größe des Fensters änderbar ist.
+	 * @param closable Flag, ob das Fenster ganz geschlossen werden kann.
+	 * @param maximizable Flag, ob das Fenster maximiert werden kann.
+	 * @param iconifiable Flag, ob das Fenster zum Icon minimiert werden kann.
+	 * @param angestelltenFeld Referenz auf das Feld der Angestellten.
+	 * @param desktop Referenz auf die Arbeitsfläche.
+	 * @param gui Referenz auf die zentrale GUI-Klasse.
+	 */
+	public DHStudentGui(String title, boolean resizable, boolean closable, boolean maximizable,
+			boolean iconifiable,
+			DHStudent dhStudentenFeld[],
+			JDesktopPane desktop, Gui gui) {
+		super(title, resizable, closable, maximizable, iconifiable,
+				desktop, gui);
+		
+		this.dhStudentenFeld = dhStudentenFeld;
+		
+		this.model = new DefaultTableModel();
+		this.table = new JTable(this.model);
+		
+		// Erstellen eines Panels für den Inhalt des internen Frames
+        this.panel = new JPanel(new BorderLayout());
+		
+		this.scrollPane = new JScrollPane(this.table);
+		panel.add(scrollPane, BorderLayout.CENTER);
+
+		// Knopf zum Speichern von Änderungen erstellen
+		JButton speichernButton = new JButton("Änderungen speichern");
+		speichernButton.addActionListener(new ActionListener() {
+			public void actionPerformed(ActionEvent e) {
+				aenderungenSpeichern();
+			}
+		});		
+		panel.add(speichernButton, BorderLayout.SOUTH);
+
+		this.add(panel);
+
+		// x, y, breite, hoehe
+		this.setBounds(180, 250, 400, 250);
+		this.setVisible(true);
+		String spaltenNamen[] = { "Name", "Semester", "Kurs" };
+		erzeugeTabelle(dhStudentenFeld, spaltenNamen);
+	}
+
+
+    /**
+     * Implementierung der abstrakten Methode aus InternalFrameElternklasse.
+     * Diese Methode wird aufgerufen, wenn das Fenster geschlossen wird.
+     * Sie ist dafür zuständig, die spezifische Referenz in der Gui-Klasse
+     * auf null zu setzen.
+     */
+    @Override
+    protected void handleFrameClosed() {
+        if (mainGuiRef != null) { // mainGuiRef kommt von InternalFrameElternklasse
+            mainGuiRef.setDhStudentGuiToNull();
+        }
+    }
+
+    
+    /**
+	 * Das Datenmodell der Tabelle mit Daten befüllen.
+	 * @param datenQuelle 1D-Feld mit DH-Studenten-Objekten.
+	 * @param spaltenNamen 1D-Feld mit den Namen bzw. 
+	 * 		Überschriften der Spalten.
+	 */
+	private void erzeugeTabelle(Object datenQuelle[], String spaltenNamen[]) {
+		// Erstellen der Daten für die Tabelle
+		Object[][] daten = new Object[datenQuelle.length][spaltenNamen.length];
+		for(int zeile = 0; zeile < datenQuelle.length; zeile++) {
+			int spalte = 0;
+			daten[zeile][spalte++] = ((Person)datenQuelle[zeile]).getName();
+			daten[zeile][spalte++] = ((Student)datenQuelle[zeile]).getSemester();
+			daten[zeile][spalte] = ((DHStudent)datenQuelle[zeile]).getKurs();
+		}
+		this.model.setRowCount(datenQuelle.length);
+		this.model.setDataVector(daten, spaltenNamen);
+		this.setVisible(true);
+	}
+
+
+	/**
+	 * Die interaktiven Änderungen in der Tabelle
+	 * im Feld der DH-Studenten speichern. 
+	 */
+	private void aenderungenSpeichern() {
+		int zeilenN = this.model.getRowCount();
+		int spaltenN = this.model.getColumnCount();
+		String name; 
+		int semester;
+		String kurs;
+		for(int zeile = 0; zeile < zeilenN; zeile++) {
+			name = (String)(this.model.getValueAt(zeile, 0));
+			Object o = this.model.getValueAt(zeile, 1);
+			semester = 0;
+			// Greift, sobald einmal eine Zelle geändert worden ist
+			if(o instanceof String) {
+				String text = (String)o;
+				semester = Integer.parseInt(text);
+			}
+			// Greift, solange eine Zelle noch nicht geändert worden ist
+			if(o instanceof Integer) {
+				semester = (Integer)(this.model.getValueAt(zeile, 1));
+			}
+			kurs = (String)(this.model.getValueAt(zeile, 2));
+			dhStudentenFeld[zeile].setName(name);
+			dhStudentenFeld[zeile].setSemester(semester);
+			dhStudentenFeld[zeile].setKurs(kurs);
+		}
+	}
+	
+}

gui/Gui.java

@@ -0,0 +1,274 @@
+/**
+ * Zentrale Klassee für das Erstellen des GUI.
+ */
+package gui;
+
+import javax.swing.JDesktopPane;
+import javax.swing.JFrame;
+import javax.swing.JInternalFrame;
+import javax.swing.JMenu;
+import javax.swing.JMenuBar;
+import javax.swing.JMenuItem;
+import javax.swing.JOptionPane;
+import javax.swing.SwingUtilities;
+
+import personen.Angestellter;
+import personen.IKlausurSchreiber;
+import personen.IMitarbeiter;
+import personen.Lehrbeauftragter;
+import personen.studenten.DHStudent;
+import personen.studenten.Student;
+
+import java.awt.event.ActionEvent;
+import java.awt.event.ActionListener;
+import java.awt.event.ComponentAdapter;
+import java.awt.event.ComponentEvent;
+import java.beans.PropertyVetoException;
+
+/**
+ * Diese Klasse ist die zentrale Klasse zum Erstellen des GUI
+ * 
+ * @author konrad
+ */
+public class Gui extends JFrame {
+	
+	private IMitarbeiter mitarbeiterFeld[];
+	private Lehrbeauftragter lehrbeauftragtenFeld[];
+	private IKlausurSchreiber prueflinge[];
+	private DHStudent dhStudentenFeld[];
+	private Student studentenFeld[];
+	
+	private JDesktopPane desktop;
+	private JMenuBar menuBar;
+	
+	private AngestellterGui angestellterGui;
+	private StudentGui studentGui;
+	private DHStudentGui dhStudentGui;
+	
+    // Instanzen der Klasse InternalFrameHilfsklasseZumOeffnen für jeden Fenstertyp
+    private InternalFrameHilfsklasseZumOeffnen<StudentGui> studentenOpener;
+    private InternalFrameHilfsklasseZumOeffnen<DHStudentGui> dhStudentenOpener;
+    private InternalFrameHilfsklasseZumOeffnen<AngestellterGui> angestelltenOpener;
+
+    /**
+	 * Konstruktor.
+	 * 
+     * @param angestelltenFeld
+     * @param mitarbeiterFeld
+     * @param lehrbeauftragtenFeld
+     * @param prueflinge
+     * @param studentenFeld
+     * @param dhStudentenFeld
+     */
+	public Gui(
+			Angestellter angestelltenFeld[],
+			IMitarbeiter mitarbeiterFeld[],
+			Lehrbeauftragter lehrbeauftragtenFeld[],
+			IKlausurSchreiber prueflinge[],
+			Student studentenFeld[],
+			DHStudent dhStudentenFeld[]) {
+		// Konstruktor von JFrame mit Fenstertitel
+		super("TINF24CS1");
+
+		this.mitarbeiterFeld = mitarbeiterFeld;
+		this.lehrbeauftragtenFeld = lehrbeauftragtenFeld;
+		this.prueflinge = prueflinge;
+		this.studentenFeld = studentenFeld;
+		this.dhStudentenFeld = dhStudentenFeld;
+		
+		// Erstellen des Fensters
+		this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
+		this.setSize(800, 600);
+
+		// Erstellen der Menüleiste
+		this.menuBar = new JMenuBar();
+
+		// Erstellen des "Datei"-Menüs
+		JMenu fileMenu = new JMenu("Datei");
+		JMenuItem newMenuItem = new JMenuItem("Neu");
+		JMenuItem openMenuItem = new JMenuItem("Öffnen");
+		JMenuItem saveMenuItem = new JMenuItem("Speichern");
+		JMenuItem exitMenuItem = new JMenuItem("Beenden");
+
+		// Hinzufügen der Menüelemente zum "Datei"-Menü
+		fileMenu.add(newMenuItem);
+		fileMenu.add(openMenuItem);
+		fileMenu.add(saveMenuItem);
+		fileMenu.addSeparator();
+		fileMenu.add(exitMenuItem);
+
+		// Erstellen des "Bearbeiten"-Menüs
+		JMenu editMenu = new JMenu("Bearbeiten");
+		JMenuItem cutMenuItem = new JMenuItem("Ausschneiden");
+		JMenuItem copyMenuItem = new JMenuItem("Kopieren");
+		JMenuItem pasteMenuItem = new JMenuItem("Einfügen");
+
+		// Hinzufügen der Menüelemente zum "Bearbeiten"-Menü
+		editMenu.add(cutMenuItem);
+		editMenu.add(copyMenuItem);
+		editMenu.add(pasteMenuItem);
+		
+		// Erstellen des "Anzeigen"-Menüs
+		JMenu anzeigeMenu = new JMenu("Anzeigen");
+		JMenuItem angestelltenMenuItem = new JMenuItem("Angestellte");
+		JMenuItem mitarbeiterMenuItem = new JMenuItem("Mitarbeiter");
+		JMenuItem lehrbeauftragterMenuItem = new JMenuItem("Lehrbeauftragte");
+		JMenuItem prueflingeMenuItem = new JMenuItem("Prüflinge");
+		JMenuItem studentenMenuItem = new JMenuItem("Studenten");
+		JMenuItem dhStudentenMenuItem = new JMenuItem("DH-Studenten");
+
+		// Hinzufügen der Menüelemente zum "Anzeigen"-Menü
+		anzeigeMenu.add(angestelltenMenuItem);
+		anzeigeMenu.add(mitarbeiterMenuItem);
+		anzeigeMenu.add(lehrbeauftragterMenuItem);
+		anzeigeMenu.add(prueflingeMenuItem);
+		anzeigeMenu.add(studentenMenuItem);
+		anzeigeMenu.add(dhStudentenMenuItem);
+		
+		// Hinzufügen der Menüs zur Menüleiste
+		menuBar.add(fileMenu);
+		menuBar.add(editMenu);
+		menuBar.add(anzeigeMenu);
+
+		// Hinzufügen der Menüleiste zum JFrame
+		this.setJMenuBar(menuBar);
+
+        // Desktop-Fläche für die "JInternalFrame"-Fenster erstellen
+        this.desktop = new JDesktopPane();
+        setContentPane(desktop);
+
+        // Erzeuge die 3 Instanzen der InternalFrameHilfsklasseZumOeffnen 
+        
+        studentenOpener = new InternalFrameHilfsklasseZumOeffnen<>(desktop, this, () -> {
+            String title = "Studenten (KEINE DH!)";
+            boolean resizable = true;
+            boolean closable = true;
+            boolean maximizable = true;
+            boolean iconifiable = true;
+            StudentGui newStudentGui = new StudentGui(
+                    title, resizable, closable, maximizable,
+                    iconifiable, studentenFeld, desktop, this);
+            // Referenz in Gui.java aktualisieren
+            this.studentGui = newStudentGui;
+            return newStudentGui;
+        });
+
+        dhStudentenOpener = new InternalFrameHilfsklasseZumOeffnen<>(desktop, this, () -> {
+            String title = "DHBW-Studenten";
+            boolean resizable = true;
+            boolean closable = true;
+            boolean maximizable = true;
+            boolean iconifiable = true;
+            DHStudentGui newDhStudentGui = new DHStudentGui(
+                    title, resizable, closable, maximizable,
+                    iconifiable, dhStudentenFeld, desktop, this);
+            // Referenz in Gui.java aktualisieren
+            this.dhStudentGui = newDhStudentGui; 
+            return newDhStudentGui;
+        });
+
+        angestelltenOpener = new InternalFrameHilfsklasseZumOeffnen<>(desktop, this, () -> {
+            String title = "Angestellte";
+            boolean resizable = true;
+            boolean closable = true;
+            boolean maximizable = true;
+            boolean iconifiable = true;
+            AngestellterGui newAngestellterGui = new AngestellterGui(
+                    title, resizable, closable, maximizable,
+                    iconifiable, angestelltenFeld, desktop, this);
+            // Referenz in Gui.java aktualisieren
+            this.angestellterGui = newAngestellterGui;
+            return newAngestellterGui;
+        });
+
+		// Hinzufügen der ActionListener zu den Menüelementen
+		exitMenuItem.addActionListener(new ActionListener() {
+			public void actionPerformed(ActionEvent e) {
+				System.exit(0);
+			}
+		});
+
+		newMenuItem.addActionListener(new ActionListener() {
+			public void actionPerformed(ActionEvent e) {
+				JOptionPane.showMessageDialog(Gui.this, "Neu ausgewählt");
+			}
+		});
+
+		openMenuItem.addActionListener(new ActionListener() {
+			public void actionPerformed(ActionEvent e) {
+				JOptionPane.showMessageDialog(Gui.this, "Öffnen ausgewählt");
+			}
+		});
+
+		saveMenuItem.addActionListener(new ActionListener() {
+			public void actionPerformed(ActionEvent e) {
+				JOptionPane.showMessageDialog(Gui.this, "Speichern ausgewählt");
+			}
+		});
+
+		cutMenuItem.addActionListener(new ActionListener() {
+			public void actionPerformed(ActionEvent e) {
+				JOptionPane.showMessageDialog(Gui.this, "Ausschneiden ausgewählt");
+			}
+		});
+
+		copyMenuItem.addActionListener(new ActionListener() {
+			public void actionPerformed(ActionEvent e) {
+				JOptionPane.showMessageDialog(Gui.this, "Kopieren ausgewählt");
+			}
+		});
+
+		pasteMenuItem.addActionListener(new ActionListener() {
+			public void actionPerformed(ActionEvent e) {
+				JOptionPane.showMessageDialog(Gui.this, "Einfügen ausgewählt");
+			}
+		});
+
+		// Hier ganz kurzer Quelltext dank der Hilfsklassenobjekte!
+		angestelltenMenuItem.addActionListener(angestelltenOpener);
+
+		// Hier ganz kurzer Quelltext dank der Hilfsklassenobjekte!
+		studentenMenuItem.addActionListener(studentenOpener);
+		
+		// Hier ganz kurzer Quelltext dank der Hilfsklassenobjekte!
+		dhStudentenMenuItem.addActionListener(dhStudentenOpener);
+
+		// Anzeigen des Fensters
+		this.setVisible(true);
+	}
+
+	
+    /**
+     * Dient zum Informieren des Openers.
+     */
+    public void setStudentGuiToNull() {
+        this.studentGui = null;
+        // Sicherstellen, dass der Opener schon initialisiert ist
+        if (studentenOpener != null) { 
+            studentenOpener.clearManagedFrame();
+        }
+    }
+
+    /**
+     * Dient zum Informieren des Openers.
+     */
+    public void setDhStudentGuiToNull() {
+        this.dhStudentGui = null;
+        if (dhStudentenOpener != null) {
+            dhStudentenOpener.clearManagedFrame();
+        }
+    }
+
+    /**
+     * Dient zum Informieren des Openers.
+     */
+    public void setAngestelltenGuiToNull() {
+        this.angestellterGui = null;
+        if (angestelltenOpener != null) {
+            angestelltenOpener.clearManagedFrame();
+        }
+    }
+	
+}
+
+

gui/InternalFrameElternklasse.java

@@ -0,0 +1,85 @@
+/**
+ * Elternklasse für die einzelnen Fenster auf dem Desktop
+ * der Anwendung.
+ */
+package gui;
+
+/**
+ * 
+ */
+import javax.swing.JDesktopPane;
+import javax.swing.JInternalFrame;
+import javax.swing.SwingUtilities;
+import java.awt.event.ComponentAdapter;
+import java.awt.event.ComponentEvent;
+import javax.swing.event.InternalFrameAdapter;
+import javax.swing.event.InternalFrameEvent;
+
+/**
+ * Elternklasse für die einzelnen Fenster auf dem Desktop
+ * der Anwendung.
+ */
+public abstract class InternalFrameElternklasse extends JInternalFrame {
+
+	/** Referenz auf den Desktop. */
+	protected JDesktopPane desktopRef;
+	/** Referenz zur Haupt-GUI-Klasse */
+	protected Gui mainGuiRef; 
+
+	/**
+	 * Konstruktor.
+	 * 
+	 * @param title
+	 * @param resizable
+	 * @param closable
+	 * @param maximizable
+	 * @param iconifiable
+	 * @param desktop
+	 * @param mainGui
+	 */
+	public InternalFrameElternklasse(String title, boolean resizable, boolean closable,
+			boolean maximizable, boolean iconifiable,
+			JDesktopPane desktop, Gui mainGui) {
+		super(title, resizable, closable, maximizable, iconifiable);
+		this.desktopRef = desktop;
+		this.mainGuiRef = mainGui;
+
+		// Füge den Listener für das Schließen des Fensters hinzu
+		this.addInternalFrameListener(new InternalFrameAdapter() {
+			@Override
+			public void internalFrameClosed(InternalFrameEvent e) {
+				// Diese Methode muss in der abgeleiteten Klasse implementiert 
+				// oder überschrieben werden, oder man verlässt sich darauf, dass
+				// mainGuiRef die entsprechende setXxxGuiToNull aufruft.
+				handleFrameClosed();
+
+				// Allgemeine Desktop-Aktualisierung nach dem Schließen
+				if (desktopRef != null) {
+					SwingUtilities.invokeLater(() -> {
+						desktopRef.revalidate();
+						desktopRef.repaint();
+					});
+				}
+			}
+		});
+
+		// Füge den ComponentListener für das Beseitigen von möglichem
+		// "Pixel-Schmutz" beim Verschieben hinzu
+		this.addComponentListener(new ComponentAdapter() {
+			@Override
+			public void componentMoved(ComponentEvent e) {
+				if (desktopRef != null) {
+					SwingUtilities.invokeLater(() -> desktopRef.repaint());
+				}
+			}
+		});
+	}
+
+	/**
+	 *  Abstrakte Methode, die von den Unterklassen implementiert werden muss,
+	 * um die spezifische Referenz in der Gui-Klasse auf null zu setzen.
+	 */
+	protected abstract void handleFrameClosed();
+	
+}
+

gui/InternalFrameHilfsklasseZumOeffnen.java

@@ -0,0 +1,139 @@
+/**
+ * Hilfsklasse zum Öffnen der einzelnen Fenster.
+ */
+package gui;
+
+import javax.swing.JDesktopPane;
+import javax.swing.JInternalFrame;
+import javax.swing.SwingUtilities;
+import java.awt.event.ActionEvent;
+import java.awt.event.ActionListener;
+import java.beans.PropertyVetoException;
+
+/**
+ * Hilfsklasse zum Öffnen der einzelnen Fenster.
+ * 
+ * Die Handhabung der Fenster ist besonders dadurch kompliziert,
+ * weil sie in diesem Programm alle Optionen haben:
+ * - Erstmals ganz neu nach Programmstart öffnen.
+ * - Erneut öffnen nach vorherigem Schließen.
+ * - Öffnen nach voherigem Umwandeln in Icon und Klicken auf das Icon.
+ * - Öffnen über das Menü nach voherigem Umwandeln in Icon.
+ */
+public class InternalFrameHilfsklasseZumOeffnen<T extends JInternalFrame> implements ActionListener {
+
+	private boolean DEBUG = false; 
+	
+	private JDesktopPane desktop;
+	/** Die Referenz zum spezifischen JInternalFrame (z.B. studentGui) */
+	private T frameToManage;
+	/** Referenz zur Haupt-GUI-Klasse */
+	private Gui mainGui; 
+
+	/** Funktionales Interface zum Erzeugen der JInternalFrame-Instanzen */
+	@FunctionalInterface
+	public interface InternalFrameFactory<F extends JInternalFrame> {
+		F create();
+	}
+
+	private InternalFrameFactory<T> frameFactory;
+
+	/**
+	 * Konstruktor.
+	 * 
+	 * @param desktop
+	 * @param mainGui
+	 * @param factory
+	 */
+	public InternalFrameHilfsklasseZumOeffnen(JDesktopPane desktop, Gui mainGui, InternalFrameFactory<T> factory) {
+		this.desktop = desktop;
+		this.mainGui = mainGui;
+		this.frameFactory = factory;
+	}
+
+	
+	/**
+	 * Diese Methode MUSS von der Gui-Klasse aufgerufen werden,
+	 * nachdem der Opener ein neues Fenster erzeugt hat.
+	 * Das ist nicht mehr direkt notwendig, da der Lambda-Ausdruck
+	 * in Gui.java die Referenz direkt aktualisiert.
+	 * Diese Methode dient hauptsächlich dazu, die 
+	 * frameToManage-Referenz in diesem Opener zu setzen.
+	 * @param frame
+	 */
+	public void setManagedFrame(T frame) {
+		this.frameToManage = frame;
+	}
+
+	
+	/**
+	 * Methode, um die Instanz auf null zu setzen, wenn das Fenster geschlossen
+	 * wird. Wird von den setXXXGuiToNull() Methoden in Gui.java aufgerufen.
+	 */
+	public void clearManagedFrame() {
+		this.frameToManage = null;
+	}
+
+	
+	@Override
+	public void actionPerformed(ActionEvent e) {
+		SwingUtilities.invokeLater(new Runnable() {
+			@Override
+			public void run() {
+				// Prüfen, ob das Fenster bereits im Desktop ist (inkl. minimierter Zustand)
+				boolean frameFound = false;
+				if (frameToManage != null) {
+					JInternalFrame[] allFrames = desktop.getAllFrames();
+					for (JInternalFrame frame : allFrames) {
+						if (frame == frameToManage) {
+							frameFound = true;
+							break;
+						}
+					}
+				}
+
+				if (!frameFound) { 
+					// Wenn das Fenster NICHT gefunden wurde
+					if(DEBUG) System.out.println("DEBUG (Opener): Neues Fenster wird erzeugt.");
+					// Fenster über die Factory-Methode erstellen
+					T newFrame = frameFactory.create();
+					// Referenz im Opener aktualisieren
+					//  (optional, aber zur Klarstellung)
+					setManagedFrame(newFrame); 
+
+					desktop.add(newFrame);
+					// Optional: Feste Startposition für neue Fenster.
+					if(false) newFrame.setLocation(50, 50);
+					try {
+						// Direkt in den Vordergrund bringen
+						newFrame.setSelected(true); 
+					} catch (PropertyVetoException pve) {
+						System.err.println(
+								"Fehler beim Setzen des neuen Fensters in den Vordergrund: "+
+								pve.getMessage());
+					}
+				} else { 
+					// Fenster existiert bereits im Desktop
+					if(DEBUG) System.out.println(
+							"DEBUG (Opener): Bestehendes Fenster wird behandelt.");
+					try {
+						if (frameToManage.isIcon()) {
+							if(DEBUG) System.out.println(
+									"DEBUG (Opener): Fenster war minimiert, wird wiederhergestellt.");
+							frameToManage.setIcon(false);
+						}
+						frameToManage.setVisible(true);
+						frameToManage.setSelected(true);
+					} catch (PropertyVetoException pve) {
+						System.err.println(
+								"Fehler beim Setzen des bestehenden Fensters in den Vordergrund: " + 
+										pve.getMessage());
+					}
+				}
+
+				desktop.revalidate();
+				desktop.repaint();
+			}
+		});
+	}
+}

gui/StudentGui.java

@@ -0,0 +1,218 @@
+/**
+ * Klasse für die Darstellung von Studenten.
+ */
+package gui;
+
+import java.awt.BorderLayout;
+import java.awt.event.ActionEvent;
+import java.awt.event.ActionListener;
+
+import javax.swing.JButton;
+import javax.swing.JDesktopPane;
+import javax.swing.JInternalFrame;
+import javax.swing.JPanel;
+import javax.swing.JScrollPane;
+import javax.swing.JTable;
+import javax.swing.table.DefaultTableModel;
+
+import personen.Person;
+import personen.studenten.Student;
+
+/**
+ * Diese Klasse ist für die Darstellung der Studenten
+ * zuständig.
+ * 
+ * @author konrad
+ */
+public class StudentGui extends InternalFrameElternklasse {
+
+	/** Referenz auf das Feld der Studenten. */
+	private Student studentenFeld[];
+
+	// Graphische Elemente der Oberfläche
+	private JTable table;
+	private DefaultTableModel model;
+	private JPanel panel;
+	private JScrollPane scrollPane;
+	
+	/**
+	 * @param title Titel im Kopf des Fensters.
+	 * @param angestelltenFeld Referenz auf das Feld der Studenten.
+	 * @param desktop Referenz auf die Arbeitsfläche.
+	 * @param gui Referenz auf die zentrale GUI-Klasse.
+	 */
+	public StudentGui(String title, Student studentenFeld[],
+			JDesktopPane desktop, Gui gui) {
+		this(title, true, studentenFeld, desktop, gui);
+	}
+
+	
+	/**
+	 * @param title Titel im Kopf des Fensters.
+	 * @param resizable Flag, ob die Größe des Fensters änderbar ist.
+	 * @param angestelltenFeld Referenz auf das Feld der Studenten.
+	 * @param desktop Referenz auf die Arbeitsfläche.
+	 * @param gui Referenz auf die zentrale GUI-Klasse.
+	 */
+	public StudentGui(String title, boolean resizable,
+			Student studentenFeld[], JDesktopPane desktop, Gui gui) {
+		this(title, resizable, true, studentenFeld, desktop, gui);
+	}
+
+
+	/**
+	 * @param title Titel im Kopf des Fensters.
+	 * @param resizable Flag, ob die Größe des Fensters änderbar ist.
+	 * @param closable Flag, ob das Fenster ganz geschlossen werden kann.
+	 * @param angestelltenFeld Referenz auf das Feld der Studenten.
+	 * @param desktop Referenz auf die Arbeitsfläche.
+	 * @param gui Referenz auf die zentrale GUI-Klasse.
+	 */
+	public StudentGui(String title, boolean resizable, boolean closable,
+			Student studentenFeld[], 
+			JDesktopPane desktop, Gui gui) {
+		this(title, resizable, closable, true, studentenFeld, desktop, gui);
+	}
+
+
+	/**
+	 * @param title Titel im Kopf des Fensters.
+	 * @param resizable Flag, ob die Größe des Fensters änderbar ist.
+	 * @param closable Flag, ob das Fenster ganz geschlossen werden kann.
+	 * @param maximizable Flag, ob das Fenster maximiert werden kann.
+	 * @param angestelltenFeld Referenz auf das Feld der Studenten.
+	 * @param desktop Referenz auf die Arbeitsfläche.
+	 * @param gui Referenz auf die zentrale GUI-Klasse.
+	 */
+	public StudentGui(String title, boolean resizable, boolean closable, boolean maximizable,
+			Student studentenFeld[], 
+			JDesktopPane desktop, Gui gui) {
+		this(title, resizable, closable, maximizable, true, 
+				studentenFeld, desktop, gui);
+	}
+
+
+	/**
+	 * Umfangreichster Konstruktor zum Erzeugen eines Fensters
+	 * für Studenten, das als JInternalFrame einem JDesktop
+	 * hinzugefügt werden kann.
+	 * @param title Titel im Kopf des Fensters.
+	 * @param resizable Flag, ob die Größe des Fensters änderbar ist.
+	 * @param closable Flag, ob das Fenster ganz geschlossen werden kann.
+	 * @param maximizable Flag, ob das Fenster maximiert werden kann.
+	 * @param iconifiable Flag, ob das Fenster zum Icon minimiert werden kann.
+	 * @param angestelltenFeld Referenz auf das Feld der Angestellten.
+	 * @param desktop Referenz auf die Arbeitsfläche.
+	 * @param gui Referenz auf die zentrale GUI-Klasse.
+	 */
+	public StudentGui(String title, boolean resizable, boolean closable, boolean maximizable,
+			boolean iconifiable,
+			Student studentenFeld[], 
+			JDesktopPane desktop, Gui gui) {
+		super(title, resizable, closable, maximizable, iconifiable,
+				desktop, gui);
+		
+		this.studentenFeld = studentenFeld;
+		
+		this.model = new DefaultTableModel();
+		this.table = new JTable(this.model);
+		
+		// Erstellen eines Panels für den Inhalt des internen Frames
+        this.panel = new JPanel(new BorderLayout());
+		
+		this.scrollPane = new JScrollPane(this.table);
+		panel.add(scrollPane, BorderLayout.CENTER);
+
+		// Knopf zum Speichern von Änderungen erstellen
+		JButton speichernButton = new JButton("Änderungen speichern");
+		speichernButton.addActionListener(new ActionListener() {
+			public void actionPerformed(ActionEvent e) {
+				aenderungenSpeichern();
+			}
+		});		
+		panel.add(speichernButton, BorderLayout.SOUTH);
+
+		this.add(panel);
+
+		// x, y, breite, hoehe
+		this.setBounds(250, 20, 300, 200);
+		this.setVisible(true);
+		String spaltenNamen[] = { "Name", "Semester", "BAföG-Schulden [€]" };
+		erzeugeTabelle(studentenFeld, spaltenNamen);
+	}
+
+	
+    /**
+     * Implementierung der abstrakten Methode aus InternalFrameElternklasse.
+     * Diese Methode wird aufgerufen, wenn das Fenster geschlossen wird.
+     * Sie ist dafür zuständig, die spezifische Referenz in der Gui-Klasse
+     * auf null zu setzen.
+     */
+    @Override
+    protected void handleFrameClosed() {
+        if (mainGuiRef != null) { // mainGuiRef kommt von InternalFrameElternklasse
+            mainGuiRef.setStudentGuiToNull();
+        }
+    }
+	
+	
+	/**
+	 * Das Datenmodell der Tabelle mit Daten befüllen.
+	 * @param datenQuelle 1D-Feld mit Studenten-Objekten.
+	 * @param spaltenNamen 1D-Feld mit den Namen bzw. 
+	 * 		Überschriften der Spalten.
+	 */
+	private void erzeugeTabelle(Object datenQuelle[], String spaltenNamen[]) {
+		// Erstellen der Daten für die Tabelle
+		Object[][] daten = new Object[datenQuelle.length][spaltenNamen.length];
+		for(int zeile = 0; zeile < datenQuelle.length; zeile++) {
+			int spalte = 0;
+			daten[zeile][spalte++] = ((Person)datenQuelle[zeile]).getName();
+			daten[zeile][spalte++] = ((Student)datenQuelle[zeile]).getSemester();
+			daten[zeile][spalte] = ((Student)datenQuelle[zeile]).getBafoegSchulden();
+		}
+		this.model.setRowCount(datenQuelle.length);
+		this.model.setDataVector(daten, spaltenNamen);
+		this.setVisible(true);
+	}
+
+
+	/**
+	 * Die interaktiven Änderungen in der Tabelle
+	 * im Feld der Studenten speichern. 
+	 */
+	private void aenderungenSpeichern() {
+		int zeilenN = this.model.getRowCount();
+		int spaltenN = this.model.getColumnCount();
+		String name; 
+		int semester;
+		double bafoegSchulden;
+		for(int zeile = 0; zeile < zeilenN; zeile++) {
+			name = (String)(this.model.getValueAt(zeile, 0));
+			Object o = this.model.getValueAt(zeile, 1);
+			semester = 0;
+			// Greift, sobald einmal eine Zelle geändert worden ist
+			if(o instanceof String) {
+				String text = (String)o;
+				semester = Integer.parseInt(text);
+			}
+			// Greift, solange eine Zelle noch nicht geändert worden ist
+			if(o instanceof Integer) {
+				semester = (Integer)(this.model.getValueAt(zeile, 1));
+			}
+			o = this.model.getValueAt(zeile, 2);
+			bafoegSchulden = 0.0;
+			if(o instanceof String) {
+				String text = (String)o;
+				bafoegSchulden = Double.parseDouble(text);
+			}
+			if(o instanceof Double) {
+				bafoegSchulden = (double)(this.model.getValueAt(zeile, 2));
+			}
+			studentenFeld[zeile].setName(name);
+			studentenFeld[zeile].setSemester(semester);
+			studentenFeld[zeile].setBafoegSchulden(bafoegSchulden);
+		}
+	}
+	
+}

gui/package-info.java

@@ -0,0 +1,9 @@
+/**
+ * 
+ */
+/**
+ * @author konrad
+ *
+ */
+package gui;
+

src/Main.java

@@ -1,15 +0,0 @@
-//TIP To <b>Run</b> code, press <shortcut actionId="Run"/> or
-// click the <icon src="AllIcons.Actions.Execute"/> icon in the gutter.
-public class Main {
-    public static void main(String[] args) {
-        //TIP Press <shortcut actionId="ShowIntentionActions"/> with your caret at the highlighted text
-        // to see how IntelliJ IDEA suggests fixing it.
-        System.out.printf("Hello and welcome!");
-
-        for (int i = 1; i <= 5; i++) {
-            //TIP Press <shortcut actionId="Debug"/> to start debugging your code. We have set one <icon src="AllIcons.Debugger.Db_set_breakpoint"/> breakpoint
-            // for you, but you can always add more by pressing <shortcut actionId="ToggleLineBreakpoint"/>.
-            System.out.println("i = " + i);
-        }
-    }
-}

src/module-info.java

@@ -0,0 +1,2 @@
+module tinf24cs1.fix {
+}

src/personen/Angestellter.java

@@ -0,0 +1,63 @@
+package personen;
+
+/**
+ * Die Klasse Angestellter repräsentiert einen Angestellten einer Firma.
+ * Sie erbt von der abstrakten Klasse Person und implementiert das Interface IMitarbeiter.
+ */
+public class Angestellter extends Person implements IMitarbeiter {
+
+    /**
+     * Die Personalnummer des Angestellten
+     */
+    private Integer personalNr;
+
+    /**
+     * Konstruktor für einen Angestellten
+     * @param name Der Name des Angestellten
+     * @param personalNr Die Personalnummer des Angestellten
+     */
+    public Angestellter(String name, Integer personalNr) {
+        super(name);
+        this.personalNr = personalNr;
+    }
+
+    /**
+     * Überschreibt die ererbte Methode druckeObjekt
+     */
+    @Override
+    public void druckeObjekt() {
+        System.out.println("Der Angestellte heisst " + this.name + ", hat die Personalnr. " +
+                this.personalNr + " und ist einer von " + Person.anzahl);
+    }
+
+    /**
+     * Implementiert die Methode aus dem Interface IMitarbeiter
+     */
+    @Override
+    public void arbeitenOhneMurren() {
+        System.out.println("Ich bin Angestellter " + this.name + " und arbeite ohne Murren und Knurren!");
+    }
+
+    /**
+     * Gibt die Personalnummer des Angestellten aus
+     */
+    public void druckePersonalNr() {
+        System.out.println("Personalnr. " + this.personalNr);
+    }
+
+    /**
+     * Getter-Methode für die Personalnummer
+     * @return Die Personalnummer des Angestellten
+     */
+    public Integer getPersonalNr() {
+        return personalNr;
+    }
+
+    /**
+     * Setter-Methode für die Personalnummer
+     * @param personalNr Die neue Personalnummer
+     */
+    public void setPersonalNr(Integer personalNr) {
+        this.personalNr = personalNr;
+    }
+}

src/personen/DHStudent.java

@@ -0,0 +1,120 @@
+package personen;
+
+import java.util.Comparator;
+
+/**
+ * DHStudent-Klasse repräsentiert einen DH-Studenten (Dualer Hochschule Student)
+ * Erbt von Student und implementiert IMitarbeiter
+ *
+ * @author Ihr Name
+ * @version 1.0
+ */
+public class DHStudent extends Student implements IMitarbeiter {
+
+    /**
+     * Der Kurs des DH-Studenten
+     */
+    private String kurs;
+
+    /**
+     * Konstruktor für DHStudent
+     *
+     * @param name Der Name des DH-Studenten
+     * @param kurs Der Kurs des DH-Studenten
+     */
+    public DHStudent(String name, String kurs) {
+        super(name);
+        this.kurs = kurs;
+    }
+
+    /**
+     * Implementierung der Methode arbeitenOhneMurren aus dem Interface IMitarbeiter
+     */
+    @Override
+    public void arbeitenOhneMurren() {
+        System.out.println("Ich bin der DHStudent " + this.name + " und gehe daher immer freudig meine Arbeit an!");
+    }
+
+    /**
+     * Gibt den Namen des Kurses ohne Zeilenumbruch aus und ruft die ererbte Methode druckeObjekt mit Parameter true auf
+     */
+    public void druckeKurs() {
+        System.out.print(this.kurs);
+        this.druckeObjekt(true);
+    }
+
+    /**
+     * Getter-Methode für den Kurs
+     *
+     * @return Der Kurs des DH-Studenten
+     */
+    public String getKurs() {
+        return kurs;
+    }
+
+    /**
+     * Setter-Methode für den Kurs
+     *
+     * @param kurs Der neue Kurs des DH-Studenten
+     */
+    public void setKurs(String kurs) {
+        this.kurs = kurs;
+    }
+
+    /**
+     * Überschreibt die toString-Methode für bessere Ausgabe
+     *
+     * @return String-Repräsentation mit Kurs, Name und Semester
+     */
+    @Override
+    public String toString() {
+        return this.kurs + " " + this.name + " " + this.semester + ".Sem.";
+    }
+
+    /**
+     * Implementierung der default-Methode inKantineEssen aus IMitarbeiter
+     */
+    @Override
+    public void inKantineEssen() {
+        System.out.println("Wie lecker doch das Essen bei meiner Ausbildungsfirma schmeckt!");
+    }
+
+    /**
+     * Innere Klasse für Sortierung nach Kurs und Name
+     */
+    public class ComparatorKursName implements Comparator<DHStudent> {
+        @Override
+        public int compare(DHStudent dhs1, DHStudent dhs2) {
+            int kursVergleich = dhs1.kurs.compareTo(dhs2.kurs);
+            if (kursVergleich != 0) {
+                return kursVergleich;
+            }
+            return dhs1.name.compareTo(dhs2.name);
+        }
+    }
+
+    /**
+     * Innere Klasse für Sortierung nach Semester, Name und Kurs
+     */
+    public class ComparatorSemesterNameKurs implements Comparator<DHStudent> {
+        @Override
+        public int compare(DHStudent dhs1, DHStudent dhs2) {
+            int semesterVergleich = Integer.compare(dhs1.semester, dhs2.semester);
+            if (semesterVergleich != 0) {
+                return semesterVergleich;
+            }
+            int nameVergleich = dhs1.name.compareTo(dhs2.name);
+            if (nameVergleich != 0) {
+                return nameVergleich;
+            }
+            return dhs1.kurs.compareTo(dhs2.kurs);
+        }
+    }
+
+    /**
+     * Statische Methode druckeAnzahl (für spätere Aufgabenteile)
+     */
+    public static void druckeAnzahl() {
+        System.out.println("DHStudent.anzahl = " + Person.anzahl);
+    }
+}

src/personen/Firma.java

@@ -0,0 +1,32 @@
+package personen;
+
+/**
+ * Die Klasse Firma repräsentiert eine Firma mit einem Namen.
+ * Sie stellt Methoden zur Ausgabe des Firmennamens zur Verfügung.
+ *
+ * @author [Ihr Name]
+ * @version 1.0
+ */
+public class Firma {
+
+    /**
+     * Der Name der Firma
+     */
+    private String name;
+
+    /**
+     * Konstruktor zur Erstellung einer neuen Firma
+     *
+     * @param name Der Name der Firma
+     */
+    public Firma(String name) {
+        this.name = name;
+    }
+
+    /**
+     * Gibt den Text "Der Firmenname lautet" sowie den Firmennamen aus
+     */
+    public void druckeName() {
+        System.out.println("Der Firmenname lautet " + this.name);
+    }
+}

src/personen/IKlausurSchreiber.java

@@ -0,0 +1,13 @@
+package personen;
+
+/**
+ * Interface für Klausurschreiber
+ * Definiert die Fähigkeit, eine Klausur zu schreiben
+ */
+public interface IKlausurSchreiber {
+
+    /**
+     * Methode zum Schreiben einer Klausur
+     */
+    void klausurSchreiben();
+}

src/personen/IMitarbeiter.java

@@ -0,0 +1,13 @@
+package personen;
+
+/**
+ * Interface für die Mitarbeiter
+ * Definiert die Fähigkeit, ohne Murren zu arbeiten
+ */
+public interface IMitarbeiter {
+
+    /**
+     * Methode für die Arbeit ohne Murren
+     */
+    void arbeitenOhneMurren();
+}

src/personen/Lehrbeauftragter.java

@@ -0,0 +1,59 @@
+package personen;
+
+/**
+ * Klasse für Lehrbeauftragte, die Klausuren durchführen können
+ */
+public class Lehrbeauftragter {
+
+    /**
+     * Name des Lehrbeauftragten
+     */
+    private String name;
+
+    /**
+     * Array der Prüflinge für die nächste Klausur
+     */
+    private IKlausurSchreiber[] prueflinge;
+
+    /**
+     * Konstruktor für Lehrbeauftragter
+     * @param name Name des Lehrbeauftragten
+     */
+    public Lehrbeauftragter(String name) {
+        this.name = name;
+    }
+
+    /**
+     * Gibt den Namen des Lehrbeauftragten zurück
+     * @return Name des Lehrbeauftragten
+     */
+    public String getName() {
+        return name;
+    }
+
+    public void setName(String name) {
+        this.name = name;
+    }
+
+    public IKlausurSchreiber[] getPrueflinge() {
+        return prueflinge;
+    }
+
+    /**
+     * Setzt das Array der Prüflinge für die nächste Klausur
+     * @param prueflinge Array mit den zu prüfenden Studenten
+     */
+    public void setPrueflinge(IKlausurSchreiber[] prueflinge) {
+        this.prueflinge = prueflinge;
+    }
+
+    /**
+     * Lässt alle im Array prueflinge aufgeführten Studenten eine Klausur schreiben
+     */
+    public void lasseKlausurSchreiben() {
+        // Enhanced for-loop (for-each) ab Java 5
+        for (IKlausurSchreiber pruefling : prueflinge) {
+            pruefling.klausurSchreiben();
+        }
+    }
+}

src/personen/Person.java

@@ -0,0 +1,47 @@
+package personen;
+
+/**
+ * Abstrakte Klasse Person als Basisklasse für verschiedene Personentypen.
+ * Verwaltet eine Klassenvariable zur Zählung aller erstellten Personen.
+ */
+public abstract class Person {
+
+    /**
+     * Klassenvariable zur Zählung aller erstellten Personen
+     */
+    private static int anzahl = 0;
+
+    /**
+     * Name der Person
+     */
+    protected String name;
+
+    /**
+     * Konstruktor der abstrakten Klasse Person
+     * @param name Der Name der Person
+     */
+    public Person(String name) {
+        this.name = name;
+        Person.anzahl++;
+    }
+
+    /**
+     * Abstrakte Methode druckeObjekt - muss in abgeleiteten Klassen implementiert werden
+     */
+    public abstract void druckeObjekt();
+
+    /**
+     * Klassenmethode zur Ausgabe der aktuellen Personenanzahl
+     */
+    public static void druckeAnzahl() {
+        System.out.println("Person.anzahl: " + Person.anzahl);
+    }
+
+    /**
+     * Getter-Methode für den Namen
+     * @return Der Name der Person
+     */
+    public String getName() {
+        return this.name;
+    }
+}

src/personen/Student.java

@@ -0,0 +1,129 @@
+package personen;
+
+import java.util.Random;
+
+/**
+ * Die Student-Klasse erbt von Person und implementiert IKlausurSchreiber.
+ * Studenten haben eine zufällige Semesterzahl und BAfG-Schulden.
+ */
+public class Student extends Person implements IKlausurSchreiber, Cloneable {
+
+    /** Die Semesterzahl des Studenten */
+    protected int semester;
+
+    /** Die BAfG-Schulden des Studenten */
+    protected double bafoegSchulden;
+
+    /**
+     * Konstruktor für Student
+     * @param name Der Name des Studenten
+     */
+    public Student(String name) {
+        super(name);
+
+        // Zufallsgenerator mit verzögertem Startwert
+        try {
+            Thread.sleep(10);
+        } catch (InterruptedException e) {
+            // Exception wird abgefangen
+        }
+
+        Random random = new Random(System.currentTimeMillis());
+
+        // Semesterzahl zuweisen: normale Studenten 1-12, DH-Studenten 1-6
+        if (this instanceof DHStudent) {
+            this.semester = random.nextInt(6) + 1;
+            this.bafoegSchulden = 0.00;
+        } else {
+            this.semester = random.nextInt(12) + 1;
+            this.bafoegSchulden = this.semester * 3000.00;
+        }
+    }
+
+    /**
+     * Überschreibt die abstrakte Methode aus Person
+     */
+    @Override
+    public void druckeObjekt() {
+        System.out.println("Der Student heisst " + this.name + ", ist im " +
+                this.semester + ". Sem. und hat " + this.bafoegSchulden +
+                " EUR Schulden wegen Bafoeg.");
+    }
+
+    /**
+     * Überladene Version von druckeObjekt
+     * @param kurz Bei true wird nur Name und Semester ausgegeben
+     */
+    public void druckeObjekt(boolean kurz) {
+        if (kurz) {
+            System.out.println("Der Student heisst " + this.name + " " +
+                    this.semester + ". Sem.");
+        } else {
+            druckeObjekt();
+        }
+    }
+
+    /**
+     * Implementierung der Methode aus IKlausurSchreiber
+     */
+    @Override
+    public void klausurSchreiben() {
+        String dh = (this instanceof DHStudent) ? "DH-" : "";
+        System.out.println("Ich bin ein " + dh + "Student namens " + this.name +
+                " und schreibe meine Klausuren perfekt!");
+    }
+
+    /**
+     * Getter-Methode für das Semester
+     * @return Die Semesterzahl
+     */
+    public int getSemester() {
+        return this.semester;
+    }
+
+    /**
+     * Gibt die Semesterzahl aus
+     */
+    public void druckeSemester() {
+        System.out.println("Semesterzahl: " + this.semester);
+    }
+
+    /**
+     * Clone-Methode für das Klonen von Studenten
+     * @return Ein geklonter Student
+     */
+    @Override
+    public Object clone() {
+        try {
+            Student geklonterStudent = (Student) super.clone();
+            Person.anzahl++; // Nur bei erfolgreichem Klonen erhöhen
+            return geklonterStudent;
+        } catch (CloneNotSupportedException e) {
+            return null;
+        }
+    }
+
+    /**
+     * Getter für BAfG-Schulden (wird später für GUI benötigt)
+     * @return Die BAfG-Schulden
+     */
+    public double getBafoegSchulden() {
+        return this.bafoegSchulden;
+    }
+
+    /**
+     * Setter für BAfG-Schulden (wird später für GUI benötigt)
+     * @param bafoegSchulden Die neuen BAfG-Schulden
+     */
+    public void setBafoegSchulden(double bafoegSchulden) {
+        this.bafoegSchulden = bafoegSchulden;
+    }
+
+    /**
+     * Setter für Semester (wird später für GUI benötigt)
+     * @param semester Das neue Semester
+     */
+    public void setSemester(int semester) {
+        this.semester = semester;
+    }
+}

src/personen/package-info.java

@@ -0,0 +1 @@
+package personen;