From 9c98b720fecb70f5bb3e94b6de5626193acf1705 Mon Sep 17 00:00:00 2001 From: mofixx Date: Fri, 25 Jul 2025 11:32:24 +0200 Subject: [PATCH] Aufgabe 3 --- gui/AngestellterGui.java | 207 +++++++++++++++ gui/DHStudentGui.java | 212 +++++++++++++++ gui/Gui.java | 274 ++++++++++++++++++++ gui/InternalFrameElternklasse.java | 85 ++++++ gui/InternalFrameHilfsklasseZumOeffnen.java | 139 ++++++++++ gui/StudentGui.java | 218 ++++++++++++++++ gui/package-info.java | 9 + src/Main.java | 15 -- src/module-info.java | 2 + src/personen/Angestellter.java | 63 +++++ src/personen/DHStudent.java | 120 +++++++++ src/personen/Firma.java | 32 +++ src/personen/IKlausurSchreiber.java | 13 + src/personen/IMitarbeiter.java | 13 + src/personen/Lehrbeauftragter.java | 59 +++++ src/personen/Person.java | 47 ++++ src/personen/Student.java | 129 +++++++++ src/personen/package-info.java | 1 + 18 files changed, 1623 insertions(+), 15 deletions(-) create mode 100644 gui/AngestellterGui.java create mode 100644 gui/DHStudentGui.java create mode 100644 gui/Gui.java create mode 100644 gui/InternalFrameElternklasse.java create mode 100644 gui/InternalFrameHilfsklasseZumOeffnen.java create mode 100644 gui/StudentGui.java create mode 100644 gui/package-info.java delete mode 100644 src/Main.java create mode 100644 src/module-info.java create mode 100644 src/personen/Angestellter.java create mode 100644 src/personen/DHStudent.java create mode 100644 src/personen/Firma.java create mode 100644 src/personen/IKlausurSchreiber.java create mode 100644 src/personen/IMitarbeiter.java create mode 100644 src/personen/Lehrbeauftragter.java create mode 100644 src/personen/Person.java create mode 100644 src/personen/Student.java create mode 100644 src/personen/package-info.java diff --git a/gui/AngestellterGui.java b/gui/AngestellterGui.java new file mode 100644 index 0000000..e6b6aa9 --- /dev/null +++ b/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); + } + } + +} diff --git a/gui/DHStudentGui.java b/gui/DHStudentGui.java new file mode 100644 index 0000000..691c8ee --- /dev/null +++ b/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); + } + } + +} diff --git a/gui/Gui.java b/gui/Gui.java new file mode 100644 index 0000000..82f5c16 --- /dev/null +++ b/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 studentenOpener; + private InternalFrameHilfsklasseZumOeffnen dhStudentenOpener; + private InternalFrameHilfsklasseZumOeffnen 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(); + } + } + +} + + diff --git a/gui/InternalFrameElternklasse.java b/gui/InternalFrameElternklasse.java new file mode 100644 index 0000000..60ae81f --- /dev/null +++ b/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(); + +} + diff --git a/gui/InternalFrameHilfsklasseZumOeffnen.java b/gui/InternalFrameHilfsklasseZumOeffnen.java new file mode 100644 index 0000000..61ed8e4 --- /dev/null +++ b/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 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 create(); + } + + private InternalFrameFactory frameFactory; + + /** + * Konstruktor. + * + * @param desktop + * @param mainGui + * @param factory + */ + public InternalFrameHilfsklasseZumOeffnen(JDesktopPane desktop, Gui mainGui, InternalFrameFactory 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(); + } + }); + } +} diff --git a/gui/StudentGui.java b/gui/StudentGui.java new file mode 100644 index 0000000..4448dd3 --- /dev/null +++ b/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); + } + } + +} diff --git a/gui/package-info.java b/gui/package-info.java new file mode 100644 index 0000000..72910ac --- /dev/null +++ b/gui/package-info.java @@ -0,0 +1,9 @@ +/** + * + */ +/** + * @author konrad + * + */ +package gui; + diff --git a/src/Main.java b/src/Main.java deleted file mode 100644 index 930198c..0000000 --- a/src/Main.java +++ /dev/null @@ -1,15 +0,0 @@ -//TIP To Run code, press or -// click the icon in the gutter. -public class Main { - public static void main(String[] args) { - //TIP Press 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 to start debugging your code. We have set one breakpoint - // for you, but you can always add more by pressing . - System.out.println("i = " + i); - } - } -} \ No newline at end of file diff --git a/src/module-info.java b/src/module-info.java new file mode 100644 index 0000000..baa48cf --- /dev/null +++ b/src/module-info.java @@ -0,0 +1,2 @@ +module tinf24cs1.fix { +} \ No newline at end of file diff --git a/src/personen/Angestellter.java b/src/personen/Angestellter.java new file mode 100644 index 0000000..f2e2e02 --- /dev/null +++ b/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; + } +} diff --git a/src/personen/DHStudent.java b/src/personen/DHStudent.java new file mode 100644 index 0000000..9bac06c --- /dev/null +++ b/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 { + @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 { + @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); + } +} diff --git a/src/personen/Firma.java b/src/personen/Firma.java new file mode 100644 index 0000000..bb5fc02 --- /dev/null +++ b/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); + } +} diff --git a/src/personen/IKlausurSchreiber.java b/src/personen/IKlausurSchreiber.java new file mode 100644 index 0000000..804ef55 --- /dev/null +++ b/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(); +} diff --git a/src/personen/IMitarbeiter.java b/src/personen/IMitarbeiter.java new file mode 100644 index 0000000..f33c2dc --- /dev/null +++ b/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(); +} diff --git a/src/personen/Lehrbeauftragter.java b/src/personen/Lehrbeauftragter.java new file mode 100644 index 0000000..6bbef52 --- /dev/null +++ b/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(); + } + } +} diff --git a/src/personen/Person.java b/src/personen/Person.java new file mode 100644 index 0000000..f851c6e --- /dev/null +++ b/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; + } +} diff --git a/src/personen/Student.java b/src/personen/Student.java new file mode 100644 index 0000000..ce81437 --- /dev/null +++ b/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; + } +} diff --git a/src/personen/package-info.java b/src/personen/package-info.java new file mode 100644 index 0000000..426839a --- /dev/null +++ b/src/personen/package-info.java @@ -0,0 +1 @@ +package personen; \ No newline at end of file