commit 6c9e6f2823b12209aa543bb6c6559bbfcd1467fe Author: FUH22860 Date: Thu Jun 9 13:38:42 2022 +0200 Initial Commit diff --git a/src/application/Main.java b/src/application/Main.java new file mode 100644 index 0000000..e27207c --- /dev/null +++ b/src/application/Main.java @@ -0,0 +1,33 @@ +package application; + +import javafx.application.Application; +import javafx.stage.Stage; +import javafx.scene.Scene; +import javafx.scene.control.Alert; +import javafx.scene.control.Alert.AlertType; +import javafx.scene.control.ButtonType; + +public class Main extends Application { + public void start(Stage primaryStage) { + try { + RootBorderPane root = new RootBorderPane(); + Scene scene = new Scene(root, 1000, 250); + primaryStage.setTitle("Mitarbeiter-Verwaltung"); + primaryStage.setScene(scene); + primaryStage.show(); + } catch (Exception e) { + showAlert(AlertType.ERROR, e.getMessage()); + } + } + + public static void showAlert(AlertType alertType, String message) { + Alert alert = new Alert(alertType, message, ButtonType.OK); + alert.setTitle("Hinweis"); + alert.setHeaderText(null); // nice to have + alert.showAndWait(); // ...andWait ... modality + } + + public static void main(String[] args) { + launch(args); + } +} diff --git a/src/application/RootBorderPane.java b/src/application/RootBorderPane.java new file mode 100644 index 0000000..e358923 --- /dev/null +++ b/src/application/RootBorderPane.java @@ -0,0 +1,86 @@ +package application; + +import javafx.application.Platform; +import javafx.scene.control.Alert.AlertType; +import javafx.scene.control.Button; +import javafx.scene.control.Menu; +import javafx.scene.control.MenuBar; +import javafx.scene.control.MenuItem; +import javafx.scene.control.RadioButton; +import javafx.scene.layout.BorderPane; +import javafx.scene.layout.HBox; +import javafx.scene.layout.VBox; +import model.Personalbuero; + +public class RootBorderPane extends BorderPane { + private MenuItem miLaden, miSpeichern, miExportieren, miBeenden, miLoeschen, miSortAlter, miSortName, miSortGehalt, + miUeber; + private Menu mDatei, mMitarbeiter, mSortierenNach, mHilfe; + private MenuBar menuBar; + + private Personalbuero personalbuero; + + private VBox buttonBoxRechts; + private HBox buttonBoxUnten; + private RadioButton rbAlter, rbGehalt, rbNamen; + private Button btSortieren, btExportieren; + + public RootBorderPane() { + initComponents(); + addComponents(); + addHandlers(); + } + + private void initComponents() { + miLaden = new MenuItem("Laden"); + miSpeichern = new MenuItem("Speichern"); +// miSpeichern.setDisable(true); + miExportieren = new MenuItem("Exportieren"); + miBeenden = new MenuItem("Beenden"); + + miSortAlter = new MenuItem("Alter"); + miSortName = new MenuItem("Namen"); + miSortGehalt = new MenuItem("Gehalt"); + miLoeschen = new MenuItem("L\u00f6schen"); + + miUeber = new MenuItem("\u00dcber"); + + mDatei = new Menu("Datei"); + mMitarbeiter = new Menu("Mitarbeiter"); + mSortierenNach = new Menu("Sortieren nach"); + mHilfe = new Menu("Hilfe"); + + menuBar = new MenuBar(); + + personalbuero = new Personalbuero(); + + rbAlter = new RadioButton("nach Alter"); +// rbAlter.setSelected(true); + rbNamen = new RadioButton("nach Namen"); + rbGehalt = new RadioButton("nach Gehalt"); + btSortieren = new Button("Sortieren"); + btExportieren = new Button("Alle Mitarbeiter-Informationen exportieren..."); + + // TODO Container-Klassen zum Sortieren (rechts) und fuer die Buttons (unten) + + } + + private void addComponents() { + // TODO + } + + private void addHandlers() { + // TODO + } + + // ------------------------------------- + // Handler-Methoden------------------------- + private void ueber() { + Main.showAlert(AlertType.INFORMATION, "Applikation Personalb\u00fcro"); + } + + private void beenden() { + // System.exit(0); never ever!!!!! + Platform.exit(); + } +} diff --git a/src/model/AlterComparator.java b/src/model/AlterComparator.java new file mode 100644 index 0000000..9f7823d --- /dev/null +++ b/src/model/AlterComparator.java @@ -0,0 +1,21 @@ +package model; + +import java.util.Comparator; + +// 2022-03-03 + +public class AlterComparator implements Comparator { + + @Override + public int compare(Mitarbeiter m1, Mitarbeiter m2) { + // TODO null-Pruefung -> wird durch ExceptionHandling "aendert sich" + if (m1.berechneAlter() > m2.berechneAlter()) + return 1; // m1 ist aelter als m2 + else + if (m1.berechneAlter() < m2.berechneAlter()) + return -1; // m1 ist juenger als m2 + else // gleiches Alter + return 0; + } + +} diff --git a/src/model/Angestellter.java b/src/model/Angestellter.java new file mode 100644 index 0000000..fb0ec83 --- /dev/null +++ b/src/model/Angestellter.java @@ -0,0 +1,56 @@ +package model; + +import java.time.Year; +/** + * Klasse Angestellter + * + * @author (WES) + * @version (2022-04-01) + * + * umgestellt auf Exception-Handling + * mit Angestellter(String[]); + */ + +// mit auskommentierter toStringCsv() +public class Angestellter extends Mitarbeiter implements GehaltBerechenbar +{ + + private static final long serialVersionUID = 2022_03_22__13_15L; + + public Angestellter() throws PersonalException + { + super(); + } + + public Angestellter(String name, char gesch, Year gebJahr, Year eintrJahr) throws PersonalException + { + super(name, gesch, gebJahr, eintrJahr); + } + + public Angestellter(String[] zeilenTeile) throws PersonalException + { + super(zeilenTeile); + } + + @Override // auf Deutsch "ueberschreiben" der Methode toString() aus der Superklasse Mitarbeiter + public String toString() + { + return new StringBuffer().append("Angestellter "). + append(super.toString()).toString(); // toString() von Mitarbeiter wird aufgerufen + + } + + public float berechneGehalt() + { + return 1500f + 50f*berechneDienstalter(); + } + + // -------------------------- toString ------------------------ + +// public String toStringCsv() +// { +// return super.toStringCsv(); +// // es gibt keine weiteren Attribute +// } + +} diff --git a/src/model/Arzt.java b/src/model/Arzt.java new file mode 100644 index 0000000..f727e75 --- /dev/null +++ b/src/model/Arzt.java @@ -0,0 +1,145 @@ +package model; + +import java.time.Year; +/** + * Klasse Arzt + * + * @author (WES) + * @version (2022-04-07) + * + * umgestellt auf Exception-Handling + * mit freiwilliger Uebung toStringCsv() + * mit freiwilliger Uebung public Arzt (String[] zeilenTeile) + * mit public Arzt(String[] zeilenTeile) + * mit setAllFields(String[] zeilenTeile) + * mit equals() und hashCode() + */ + +public class Arzt extends Mitarbeiter implements GehaltBerechenbar +{ + private static final long serialVersionUID = 2022_04_05__12_40L; + private int wochenStunden; + private float fixum; + + // FUE 2002-04-01 + // public Arzt (String[] zeilenTeile) + + public Arzt (String[] zeilenTeile) throws PersonalException + { + super(zeilenTeile); + setAllFields(zeilenTeile); + } + + public Arzt(String name, char gesch, Year gebJahr, Year eintrJahr, int wochenStunden, float fixum) throws PersonalException + { + super(name, gesch, gebJahr, eintrJahr); + setWochenStunden(wochenStunden); + setFixum(fixum); + } + + public void setWochenStunden(int wochenStunden) throws PersonalException + { + if (wochenStunden > 0) + this.wochenStunden = wochenStunden; + else + throw new PersonalException("Fehler bei setWochenStunden(): Wert von wochenStunden muss groesser 0 sein (" + wochenStunden + ")"); + } + + public void setFixum(float fixum) throws PersonalException + { + if (fixum > 0f) + this.fixum = fixum; + else + throw new PersonalException("Fehler bei setFixum(): Wert von fixum muss groesser 0.0 sein (" + fixum + ")"); + } + + private void setAllFields(String[] zeilenTeile) throws PersonalException + { + try { + // 10; 1000.0 + // [5] [6] im Array zeilenTeile + setWochenStunden(Integer.parseInt(zeilenTeile[5].trim())); // "10" + // throws NumberFormatException bei Integer.parseInt + setFixum(Float.parseFloat(zeilenTeile[6].trim())); // "1000.0" + } + catch(ArrayIndexOutOfBoundsException e) + { + throw new PersonalException("Array-Fehler bei setAllFields(): " + + e.getMessage()); + } + catch(NumberFormatException e) + { + throw new PersonalException("Zahlenumwandlungs-Fehler (wochenStunden oder fixum) bei setAllFields(): " + + e.getMessage()); + } + } + + public float berechneStundensatz() throws PersonalException + { + if (wochenStunden > 0) + { + return fixum/wochenStunden; + } + else + { + throw new PersonalException("Fehlen bei berechneStundensatz(): wert von wochenStunden ist ungueltig (" + wochenStunden + ")"); + // return -99f; // nach throw der Block verlassen, wie bei einem return + } + } + + public float berechneGehalt() + { + return fixum; + } + // ------------------------- equals / hashCode --------------- + + @Override + public boolean equals(Object obj) { + if (this == obj) + return true; + if (!super.equals(obj)) + return false; + if (getClass() != obj.getClass()) + return false; + Arzt other = (Arzt) obj; + if (Float.floatToIntBits(fixum) != Float.floatToIntBits(other.fixum)) + return false; + if (wochenStunden != other.wochenStunden) + return false; + return true; + } + + @Override + public int hashCode() { + final int prime = 31; + int result = super.hashCode(); + result = prime * result + Float.floatToIntBits(fixum); + result = prime * result + wochenStunden; + return result; + } + + + // -------------------------- print / toString / toStringCsv ------------ + + // public void printInfo() // zum Testen + // { + // System.out.println(this); + // } + + public String toString() + { + return "Arzt: " + + super.toString() + + ", Wochenstunden: " + wochenStunden + + ", Fixum: " + fixum; + } + + public String toStringCsv() + { + String sep = ";"; + // Arzt;Wolfgang;m;1964;2022 ; 40 ; 1200.0 + return super.toStringCsv() +sep+wochenStunden+sep+fixum; + + } + +} diff --git a/src/model/DienstalterComparator.java b/src/model/DienstalterComparator.java new file mode 100644 index 0000000..3c0ea51 --- /dev/null +++ b/src/model/DienstalterComparator.java @@ -0,0 +1,28 @@ +package model; + +import java.util.Comparator; + +// 2022-03-03 + +public class DienstalterComparator implements Comparator { + + @Override + public int compare(Mitarbeiter m1, Mitarbeiter m2) { + + return m1.berechneDienstalter() - m2.berechneDienstalter(); + + // (m1 Dienstalter) 1 - (m2 Dienstalter) 2 = -1 + // return -1; + // 6 - 2 = 4 + // return 1 -> ok return 4 + // 1 - 1 = 0 + // return 0 + + // Weitere Varianten: + // return Integer.compare(m1.berechneDienstalter(), m2.berechneDienstalter()); + + // return m2.getEintrJahr().compareTo(m1.getEintrJahr()); // Year.compareTo + + } + +} diff --git a/src/model/Freelancer.java b/src/model/Freelancer.java new file mode 100644 index 0000000..c570435 --- /dev/null +++ b/src/model/Freelancer.java @@ -0,0 +1,182 @@ +package model; + +import java.time.Year; + +// 2022-04-07 4BAIF +// umgestellt auf Exception-Handling +// mit serialVersionUID fuer Serialisierung +// mit toStringCsv() +// mit Freelancer (String[] zeilenTeile) +// mit equals() und hashCode() + +public class Freelancer extends Mitarbeiter implements PraemieBerechenbar, GehaltBerechenbar +{ + private static final long serialVersionUID = 2022_03_22__13_15L; + private int stunden; + private float stundenSatz; + //private Year eintrJahr; // SO NICHT!!! + + public Freelancer(float stundenSatz, int stunden) throws PersonalException + { + super(); // ruft den parameterlosen/Default-Konstruktor der Superklasse Mitarbeiter auf + setStundenSatz(stundenSatz); + setStunden(stunden); + } + + public Freelancer(String name, char gesch, Year gebJahr, Year eintrJahr, float stundenSatz, int stunden) throws PersonalException + { + // setName(name); // so nicht! + // setGesch(gesch); // so nicht! + // .... + super(name, gesch, gebJahr, eintrJahr); // Aufruf des. K. der Superklasse + setStundenSatz(stundenSatz); + setStunden(stunden); + } + + public Freelancer (String[] zeilenTeile) throws PersonalException + { + super(zeilenTeile); + // Freelancer;Anna;w;1976;2002;"10";"100.0" + // [5] [6] im String-Array zeilenTeile + // Achtung: ArrayIndexOutOfBoundsException + // beim Parsen: NumberFormatException + try + { + setStunden( Integer.parseInt(zeilenTeile[5].trim()) ); // int + setStundenSatz( Float.parseFloat(zeilenTeile[6].trim()) ); // float + } + catch(ArrayIndexOutOfBoundsException e) + { + throw new PersonalException("Array-Fehler bei Freelancer(zeilenTeile): " + + e.getMessage()); + } + catch(NumberFormatException e) + { + throw new PersonalException("Zahlenumwandlungs-Fehler (gebJahr oder eintrJahr) bei Freelancer(zeilenTeile): " + + e.getMessage()); + } + } + + public int getStunden() + { + return stunden; + } + + public float getStundenSatz() + { + return stundenSatz; + } + + public void setStunden(int stunden) throws PersonalException + { + if (stunden > 0) + this.stunden = stunden; + else + throw new PersonalException("Fehler bei setStunden(): stunden sind 0 oder kleiner (" + stunden + ")"); + } + + public void setStundenSatz(float stundenSatz) throws PersonalException + { + if (stundenSatz > 0f) + this.stundenSatz = stundenSatz; + else + throw new PersonalException("Fehler bei setStundenSatz(): stundenSatz ist 0.0 oder kleiner (" + stundenSatz + ")"); + } + + // so NICHT!!! + // public void setEintrJahr(Year eintrJahr) + // { + // if (eintrJahr != null) + // if (gebJahr != null) + // { + // int aktJahr = Year.now().getValue(); + // if (eintrJahr.getValue() >= gebJahr.getValue()+15) + // if (eintrJahr.getValue() <= aktJahr ) + // this.eintrJahr = eintrJahr; + // else + // System.out.println("Falscher Parameterwert fuer setEintrJahr("+eintrJahr+") !!!"); + // else + // System.out.println("Fehler bei setEintrJahr("+eintrJahr+") -> Person ist zu jung ("+berechneAlter()+")!!!"); + // } + // else + // System.out.println("null-Referenz bei gebJahr -> eintrJahr kann nicht geprueft werden !!!"); + // else + // System.out.println("null-Referenz fuer setEintrJahr(Year eintrJahr) !!!"); + // } + + public float berechneGehalt() + { + return stundenSatz*stunden; + } + + public float berechnePraemie() // FUE Refactoring mit Verwendung von switch-case + { + float praemie = 0f; + + if (berechneDienstalter() == 15) + praemie = berechneGehalt(); // 1x Gehalt als Praemie + else + if (berechneDienstalter() == 20) + praemie = berechneGehalt()*2; // 2x Gehalt als Praemie + + return praemie; + } + + public String infoBerechnungPraemie() + { + return "Fuer 15 Jahre Mitarbeit bei einem Personalbuero erhaelt der Freelancer ein \"Gehalt\", fuer 20 Jahre zwei \"Gehaelter\"\" als Praemie."; + } + // ------------------------- equals / hashCode --------------- + + @Override + public boolean equals(Object obj) { + if (this == obj) + return true; + if (!super.equals(obj)) + return false; + if (getClass() != obj.getClass()) + return false; + Freelancer other = (Freelancer) obj; + if (stunden != other.stunden) + return false; + if (Float.floatToIntBits(stundenSatz) != Float.floatToIntBits(other.stundenSatz)) + return false; + return true; + } + + @Override + public int hashCode() { + final int prime = 31; + int result = super.hashCode(); + result = prime * result + stunden; + result = prime * result + Float.floatToIntBits(stundenSatz); + return result; + } + + + // ---------------------------- toString / print ---------------------------- + + public String toStringCsv() + { + char sep = ';'; + + return super.toStringCsv()+sep+stunden+sep+stundenSatz; + } + + + + public String toString() + { + return new StringBuffer().append("Freelancer "). + append(super.toString()). // ohne super. -> StackOverflowError -> rekursiver Methodenaufruf + append(" Stunden: "). + append(stunden).append(" Stundensatz: "). + append(stundenSatz). + append(" Praemie: ").append(berechnePraemie()).toString(); + } + + public void print() + { + System.out.println(this); + } +} diff --git a/src/model/GehaltBerechenbar.java b/src/model/GehaltBerechenbar.java new file mode 100644 index 0000000..fd835d4 --- /dev/null +++ b/src/model/GehaltBerechenbar.java @@ -0,0 +1,14 @@ +package model; + + +/** + * Interface GehaltBerechenbar + * + * @author (WES) + * @version (2022-01-27) + */ + +public interface GehaltBerechenbar +{ + public float berechneGehalt(); +} diff --git a/src/model/Mitarbeiter.java b/src/model/Mitarbeiter.java new file mode 100644 index 0000000..f1b8c82 --- /dev/null +++ b/src/model/Mitarbeiter.java @@ -0,0 +1,314 @@ +package model; + +import java.io.Serializable; +import java.time.DateTimeException; +import java.time.Year; +import java.util.Comparator; +import java.util.Objects; + +//2022-04-07 4BAIF + +//Klasse abstract +//Methode berechneGehalt() abstract +//2022-01-26: Debugging toString() - mit ?-Operator gefixt +//Interface Comparable + +//Umstellung auf EH + +// neuer Konstruktor Mitarbeiter(String[] zeilenTeile) fuer importMitarbeiter +// setAllFields(String [] zeilenTeile) + +// mit equals() und hashCode() + +public abstract class Mitarbeiter implements Comparable , Serializable +//public class Mitarbeiter implements Comparable // zum Testen +{ + + private static final long serialVersionUID = 2022_03_22__13_15L; + private String name; + private Year gebJahr, eintrJahr; + private char gesch; + + public Mitarbeiter() throws PersonalException // zum Testen + { + setName("Anna"); + setGesch('w'); + setGebJahr(Year.of(2001)); + setEintrJahr(Year.now()); + } + + public Mitarbeiter(String name, char gesch, Year gebJahr, Year eintrJahr) throws PersonalException + { + setName(name); + setGesch(gesch); + setGebJahr(gebJahr); + setEintrJahr(eintrJahr); + } + + public Mitarbeiter(String[] zeilenTeile) throws PersonalException + { + if (zeilenTeile != null) + { +// setName(); +// setGesch(); +// setEintrJahr(); +// setGebJahr(); + + setAllFields(zeilenTeile); + } + else + throw new PersonalException("Fehler bei Mitarbeiter(String[]): null-Referenz erhalten"); + } + + //------------------------------------ getter ------------------------ + public String getName() + { + return name; + } + + public char getGesch() + { + return gesch; + } + + public Year getGebJahr() + { + return gebJahr; + } + + public Year getEintrJahr() + { + return eintrJahr; + } + //------------------------------------ setter ------------------------ + + public void setName(String name) throws PersonalException + { + if (name != null) + if (name.length() >= 2) + this.name = name; + else + throw new PersonalException("Falscher Parameterwert fuer setName("+name+") !!!"); + else + throw new PersonalException("null-Referenz fuer setName(String name) !!!"); + } + + public void setGesch(char gesch) throws PersonalException + { + if (gesch == 'm' || gesch == 'M' || gesch == 'w' || gesch == 'W' || gesch == 'x' || gesch == 'X' ) + this.gesch = Character.toLowerCase(gesch); // Character ist "Wrapper"-Klasse von char + else + throw new PersonalException("Falscher Parameterwert fuer setGesch(" + gesch + ") !!!"); + } + + public void setGebJahr(Year gebJahr) throws PersonalException + { + //int aktJahr = Year.now().getValue(); + Year aktYear = Year.now(); + if (gebJahr != null) + // if (gebJahr.getValue() >= aktJahr-100 && gebJahr.getValue() <= aktJahr ) + if ( !gebJahr.isBefore(aktYear.minusYears(100)) && !gebJahr.isAfter(aktYear) ) + this.gebJahr = gebJahr; + else + throw new PersonalException("Falscher Parameterwert fuer setGebJahr("+gebJahr+") !!!"); + else + throw new PersonalException("null-Referenz fuer setGebJahr(Year gebJahr) !!!"); + } + + public void setEintrJahr(Year eintrJahr) throws PersonalException + { + if (eintrJahr != null) + if (gebJahr != null) + { + int aktJahr = Year.now().getValue(); + if (eintrJahr.getValue() >= gebJahr.getValue()+15) + if (eintrJahr.getValue() <= aktJahr ) + this.eintrJahr = eintrJahr; + else + throw new PersonalException("Falscher Parameterwert fuer setEintrJahr("+eintrJahr+") !!!"); + else + throw new PersonalException("Fehler bei setEintrJahr("+eintrJahr+") -> Person ist zu jung ("+berechneAlter()+")!!!"); + } + else + throw new PersonalException("null-Referenz bei gebJahr -> eintrJahr kann nicht geprueft werden !!!"); + else + throw new PersonalException("null-Referenz fuer setEintrJahr(Year eintrJahr) !!!"); + } + + private void setAllFields(String[] zeilenTeile) throws PersonalException { + + // beim Arbeiten mit Array kann es eine + // ArrayIndexOutOfBoundsException geben + try { + //Angestellter;Alfred; m; 1977; 2022 + // [0] [1] [2] [3] [4] im Array zeilenTeile + setName(zeilenTeile[1].trim()); // trim(): whitespaces "vorne und hinten" entfernen + setGesch(zeilenTeile[2].trim().charAt(0)); // z.B. "m" -> 'm' + // Integer.parseInt(String) + // throws NumberFormatException bei Integer.parseInt + setGebJahr( Year.of(Integer.parseInt(zeilenTeile[3].trim())) ); // "1977" + // throws NumberFormatException bei Integer.parseInt + setEintrJahr(Year.of(Integer.parseInt(zeilenTeile[4].trim()))); // "2022" + } + catch(ArrayIndexOutOfBoundsException e) + { + throw new PersonalException("Array-Fehler bei setAllFields(): " + + e.getMessage()); + } + catch (StringIndexOutOfBoundsException e) + { + throw new PersonalException("Zeichenumwandlungsfehler-Fehler (gesch) bei setAllFields(): " + + e.getMessage()); + } + catch(NumberFormatException e) + { + throw new PersonalException("Zahlenumwandlungs-Fehler (gebJahr oder eintrJahr) bei setAllFields(): " + + e.getMessage()); + } + catch (DateTimeException e) // wird von Year.of() moeglicherweise "geworfen" + { + throw new PersonalException("Jahreszahlumwandlungs-Fehler (gebJahr oder eintrJahr) bei setAllFields(): " + + e.getMessage()); + } + } + //-------------------------------------- weitere ----------------------- + public int berechneAlter() + { + // return 2021 - gebJahr; // ganz schlecht... + + // Bessere Loesung in Einzelschritten: + // Year datum = Year.now(); + // int aktJahr = datum.getValue(); + // int alter = aktJahr - gebJahr; + // return alter; + + // Bessere Loesung in einem Schritt: + return (gebJahr != null?Year.now().getValue() - gebJahr.getValue():-99); // Fehlercode + } + + public int berechneDienstalter() + { + return (eintrJahr != null?Year.now().getValue() - eintrJahr.getValue():-99); // Fehlercode + } + + // public float berechneGehalt() + // { + // return 1500f + 50f*berechneDienstalter(); + // } + +// public float berechneGehalt() // zum UMSTELLEN und TESTEN +// { +// return 0f; +// } + + public abstract float berechneGehalt(); // alle Subklassen + // MUESSEN diese Methode implementieren + // Ausnahme: diese Subklasse ist auch abstrakt + + // public abstract int berechneUrlaubsanspruch() // Beispiel fuer einen + // Anwendungsfall einer abstrakten Methode + // ; + + // --------------------------------- compareTo ----------------------------- + + @Override + public int compareTo(Mitarbeiter o) { // "natuerliche" Reihenfolge von Gehalt + if (o != null) + { + if (berechneGehalt() > o.berechneGehalt()) + return 1; + else + if (berechneGehalt() < o.berechneGehalt()) + return -1; + else + return 0; + } + else // Annahme bis zum ExceptionHandling, dann NullPointerException + return 1; + } + + // ----------------------------------- innere Klasse -------------------------------- + + public static class AlterComparator implements Comparator { + + @Override + public int compare(Mitarbeiter o1, Mitarbeiter o2) { + + if (o1 != null && o2 != null) + if (o1.berechneAlter() > o2.berechneAlter()) + return 1; + else if (o1.berechneAlter() < o2.berechneAlter()) + return -1; + else // o1.berechneAlter() == o2.berechneAlter() + return 0; + else // o1 == null || o2 == null + return 1; + } + } + + // ------------------------- equals / hashCode --------------- + @Override + public boolean equals(Object obj) { + if (this == obj) + return true; + if (obj == null) + return false; + if (getClass() != obj.getClass()) + return false; + Mitarbeiter other = (Mitarbeiter) obj; + return Objects.equals(eintrJahr, other.eintrJahr) && Objects.equals(gebJahr, other.gebJahr) + && gesch == other.gesch && Objects.equals(name, other.name); + } + + @Override + public int hashCode() { + return Objects.hash(eintrJahr, gebJahr, gesch, name); + } + // ------------------------------------ toString() / print -------------------------------------- + public String toString() + { + String geschlecht; + switch(gesch) + { + case 'm': + case 'M': geschlecht = "maennlich"; break; + case 'w': + case 'W': geschlecht = "weiblich"; break; + case 'x': + case 'X': geschlecht = "divers"; break; + default : geschlecht = "unbekannt"; + + } + return "Name: " + name+ + ", Gesch.: " + geschlecht+ + ", Geb.Jahr: " + (gebJahr != null?gebJahr.getValue():"keines vorhanden")+ + ", Alter: " + berechneAlter()+ + ", Eintr.Jahr: " + (eintrJahr != null?eintrJahr.getValue():"keines vorhanden")+ + ", Dienstalter: "+ berechneDienstalter() + + ", Gehalt: " + berechneGehalt(); + } + + public void print() + { + System.out.println(this); //System.out.println(toString()) + } + + public String toStringCsv() + { + char sep = ';'; // "Trennzeichen" zwischen den Attribut-Werten + + StringBuilder sb = new StringBuilder(); + + sb.append(getClass().getSimpleName()).append(sep); // Typ bzw. Klassenbezeichnung + sb.append(name).append(sep); // name + sb.append(gesch).append(sep); // gesch + sb.append(gebJahr).append(sep); // gebJahr + sb.append(eintrJahr); // .append(sep); // eintrJahr + + return (sb.toString()); + } +} + + + + diff --git a/src/model/NameComparator.java b/src/model/NameComparator.java new file mode 100644 index 0000000..c065430 --- /dev/null +++ b/src/model/NameComparator.java @@ -0,0 +1,45 @@ +package model; + +import java.util.Comparator; + +public class NameComparator implements Comparator { // Vergleich nach Name (alphabetischer Vergleich) + + @Override + public int compare(Mitarbeiter o1, Mitarbeiter o2) { + + if (o1 != null && o2 != null) // notwendig, weil wir ExceptionHandling nicht verwenden koennen + { + return o1.getName().compareTo(o2.getName()); // positiv, negativ oder 0 + +// so geht es vermutlich nicht so schnell... +// if (o1.getName().charAt(0) > o2.getName().charAt(0)) +// return 1; +// else +// if (o1.getName().charAt(0) < o2.getName().charAt(0)) +// return -1; +// else +// if (o1.getName().charAt(1) > o2.getName().charAt(1)) +// +// ... und so weiter bis zum Ende der beiden String, viel zu kompliziert + + // ein weiterer Versuch zum Testen, kompliziert ... und auch falsch +// if (o1.getName().compareTo(o2.getName()) > 0) +// return 1; +// else +// if (o1.getName().compareTo(o2.getName()) < 0) +// return -1; +// else +// return 0; + + } + else // null-PointerException muss vermieden werden + if (o1 == null && o2 != null) + return -1; + else + if (o1 != null && o2 == null) + return 1; + else // beide null + return 0; + } + +} diff --git a/src/model/PersonalException.java b/src/model/PersonalException.java new file mode 100644 index 0000000..36ac8cb --- /dev/null +++ b/src/model/PersonalException.java @@ -0,0 +1,16 @@ +package model; + +public class PersonalException extends Exception { + + /* + * serialVersionUID ist eine Art "Versionsnummer" dieser Klasse + * static: dieses Attribut "gehoert" der Klasse, nicht der Instanz + * final: nach der ersten Wertzuweisung nicht veraenderbar ("Konstante") + */ + private static final long serialVersionUID = 2022_03_18__08_28L; + + public PersonalException(String message) { + super(message); + } + +} diff --git a/src/model/Personalbuero.java b/src/model/Personalbuero.java new file mode 100644 index 0000000..a629c92 --- /dev/null +++ b/src/model/Personalbuero.java @@ -0,0 +1,607 @@ +package model; + +import java.io.BufferedReader; +import java.io.BufferedWriter; +import java.io.FileInputStream; +import java.io.FileNotFoundException; +import java.io.FileOutputStream; +import java.io.FileReader; +import java.io.FileWriter; +import java.io.IOException; +import java.io.ObjectInputStream; +import java.io.ObjectOutputStream; +import java.util.ArrayList; +import java.util.Collections; +import java.util.Iterator; +import java.util.List; + +// 2022-04-05 4BAIF + +// Umgestellt auf ArrayList +// mit public float berechneDurchnittsalter() +// mit berechneGehaltsumme() +// mit kuendigen(int) +// mit zaehleAlter(int) +// ohne getAnzahl() -> auskommentiert +// mit kuendigen(Mitarbeiter) +// mit gehaltsliste() + +// mit folgenden ArrayList-Methoden: +// size(): Anzahl der Elemente in der ArrayList +// get(int): liefert die Referenz beim Index pos in der ArrayList +// add(Mitarbeiter): nimmt die Mitarbeiter-Referenz an der naechsten freien Stelle in die ArrayList auf +// remove(int): entfernt die Referenz beim Index pos aus der ArrayList + +// sortiereMitarbeiter() +// sortiereNamen() + +// sortiereAlter() mit Comparator-Klasse +// sortiereDienstalter() mit Comparator-Klasse + +// kuendigen(name: String) +// kuendigen(gehalt: float) + +// umgestellt auf Exception-Handling + +// serialsiertes Speichern und Laden der Collection mitarbeiter: +// saveMitarbeiter() und loadMitarbeiter() Variante1 und Variante2 (empfohlen) + +// Textfile Speichern: +// exportMitarbeiter + +// 2022-03-29 exportMitarbeiterCsv + +// 2022-04-01 importMitarbeiterCsc() fuer Angestellte +// 2022-04-05 importMitarbeiterCsc fuer Freelancer und Arzt + +// 2022-04-07 aufnehmen erweitert um !contains() -> keine doppelstes Aufnehmen + +//2022-06-07: getMitarbeiter() NEU +// remove(List) NEU +// loadMitarbeiter(String) NEU +// loadMitarbeiter() angepasst +// saveMitarbeiter(String) NEU +// saveMitarbeiter() angepasst +// exportMitarbeiter(String) NEU +// exportMitarbeiter() angepasst + +public class Personalbuero { + private ArrayList mitarbeiter; // eine ArrayList ist "getypt" + // private Mitarbeiter [] mitarbeiter; + // private int anzahl; + + public Personalbuero() { + // mitarbeiter = new Mitarbeiter [6]; + mitarbeiter = new ArrayList(); + // anzahl = 0; + } + + // public int getAnzahl() // Ersatz durch zaehleMitarbeiter() + // { + // //return anzahl; + // return mitarbeiter.size(); + // } + + public List getMitarbeiter() { + return mitarbeiter; // Achtung: Vollzugriff auf Collection + } + // -------------------------------- weitere ------------------------------------ + + public boolean aufnehmen(Mitarbeiter ma) throws PersonalException { + if (ma != null) { + if (ma.berechneAlter() >= 15 && ma.berechneAlter() < 60) { + // if (anzahl < mitarbeiter.length) + // { + // mitarbeiter[anzahl] = ma; + if (!mitarbeiter.contains(ma)) + return mitarbeiter.add(ma); // liefert immer true + else + throw new PersonalException("Fehler bei aufnehmen(): Mitarbeiter/in schon vorhanden\n" + ma); + // anzahl ++; + // return true; + // } + // else + // System.out.println("Fehler bei aufnehmen(): kein Platz zum Aufnehmen"); + } else + throw new PersonalException("Fehler bei aufnehmen(): Alter passt nicht"); + } else + throw new PersonalException("Fehler bei aufnehmen(): null-Referenz erhalten"); + // return false; + } + + public float berechneGehaltsumme() { + float summe = 0f; + Mitarbeiter mit; + // for (int i = 0; i < anzahl; i++) + for (int i = 0; i < mitarbeiter.size(); i++) { + // mit = mitarbeiter[i]; + mit = mitarbeiter.get(i); + summe += mit.berechneGehalt(); + } + return summe; + } + + public float berechneDurchschnittsalter() throws PersonalException { + Mitarbeiter tempMitarbeiter; + float summeJahre = 0.0f; + // float avgJahre; + // if (anzahl > 0) + if (mitarbeiter.size() > 0) { + // for (int i = 0; i < anzahl; i++) + for (int i = 0; i < mitarbeiter.size(); i++) { + // tempMitarbeiter = mitarbeiter[i]; + tempMitarbeiter = mitarbeiter.get(i); + summeJahre += tempMitarbeiter.berechneAlter(); + } + // avgJahre = summeJahre/anzahl; // Achtung: anzahl darf NICHT 0 sein + // return avgJahre; + // return summeJahre/anzahl; + return summeJahre / mitarbeiter.size(); + } else + throw new PersonalException("Fehler bei berechneDurchschnittsalter(): keine Mitarbeiter vorhanden"); + // return -99f; // keine Mitarbeiter, kein Durchschnittsalter + } + + public boolean kuendigen(int pos) throws PersonalException { + if (pos >= 0 && pos < mitarbeiter.size()) { + // return mitarbeiter.remove(pos); // Fehler, weil Referenz "returned" wird + mitarbeiter.remove(pos); + return true; + } else // pos (index) ist ungueltig + throw new PersonalException("Fehler bei kuendigen(): Wert von pos ungueltig (" + pos + ")"); + // return false; + } + + public boolean kuendigen(Mitarbeiter ma) throws PersonalException { + if (ma != null) { + return mitarbeiter.remove(ma); + } else // ungueltige Mitarbeiter-Referenz null + throw new PersonalException("Fehler bei kuendigen(): null-Referenz erhalten"); + // return false; + } + + public int zaehleMitarbeiter() { + return mitarbeiter.size(); + } + + public int zaehleAlter(int alter) throws PersonalException { + int count = 0; + Mitarbeiter mit; + if (alter >= 15 && alter < 60) { + for (int i = 0; i < mitarbeiter.size(); i++) { + mit = mitarbeiter.get(i); + if (mit.berechneAlter() > alter) + count++; + } + return count; + } else { + throw new PersonalException("Fehler bei aufnehmen(): Wert von alter passt nicht (" + alter + ")"); + // return -99; + } + } + + public void gehaltsliste() throws PersonalException { + // float summe = 0; // es gibt berechneGehaltsumme() +// Mitarbeiter mit; + System.out.println("Gehaltsliste:"); + if (mitarbeiter.size() > 0) { + for (int i = 0; i < mitarbeiter.size(); i++) { + // mit = mitarbeiter.get(i); // lokale Variable nicht erforderlich + // System.out.print(mit.getName() + "\t"); + // System.out.println(mit.berechneGehalt()); + + System.out.print(mitarbeiter.get(i).getName() + "\t"); + System.out.println(mitarbeiter.get(i).berechneGehalt()); + + // summe += mit.berechneGehalt(); // es gibt berechneGehaltsumme() + } + // System.out.println("Summe: " + summe); // es gibt berechneGehaltsumme() + System.out.println("Summe: " + berechneGehaltsumme()); + } else + throw new PersonalException("Fehler bei gehaltsliste(): keine Mitarbeiter vorhanden"); + } + + public int zaehleAngestellte() throws PersonalException { + int count = 0; + // Mitarbeiter mit; + if (mitarbeiter.size() > 0) { + for (int i = 0; i < mitarbeiter.size(); i++) { + // if (mit instanceof Angestellter) + if (mitarbeiter.get(i) instanceof Angestellter) + count++; + } + return count; + } else + throw new PersonalException("Fehler bei zaehleAngestellte(): keine Mitarbeiter im Personalbuero vorhanden"); + // return 0; + } + + public float berechneAvgGehaltAngestellte() throws PersonalException // Optimierung moeglich + { + float summe = 0f; + int count = 0; // FUE Refactoring mit Einsatz von zaehleAngestellte() + Mitarbeiter mit; + if (mitarbeiter.size() > 0) { + for (int i = 0; i < mitarbeiter.size(); i++) { + mit = mitarbeiter.get(i); + if (mit instanceof Angestellter) { + summe += mit.berechneGehalt(); + count++; + } + } + return summe / count; + } else + throw new PersonalException( + "Fehler bei berechneAvgGehaltAngestellte(): keine Mitarbeiter/Angestellte/Freelancer im Personalbuero vorhanden"); + // return -99f; + } + // ---------------------------------- sorts --------------------------------- + + public void sortiereMitarbeiter() // aufsteigend nach Gehalt + { + Collections.sort(mitarbeiter); + } + + public void sortiereNamen() // aufsteigend nach Name + { + NameComparator nameComparator = new NameComparator(); + Collections.sort(mitarbeiter, nameComparator); + } + + public void sortiereAlter() // mit anonymer innerer Klasse in Mitarbeiter + { + if (!mitarbeiter.isEmpty()) { + Collections.sort(mitarbeiter, new Mitarbeiter.AlterComparator()); + } else { + System.out.println("Es sind keine Mitarbeiterinnen/Mitarbeiter zum Sortieren vorhanden"); + } + } + +// public void sortiereAlter() +// { +// AlterComparator alterComparator = new AlterComparator(); +// Collections.sort(mitarbeiter, alterComparator); +// +// // anonymens Objekt AlterComparator() direkt an die sort() uebergeben +// +// //Collections.sort(mitarbeiter, new AlterComparator()); +// + // "anonyme" innere Klasse +// Collections.sort(mitarbeiter, new Comparator() { +// +// @Override +// public int compare(Mitarbeiter m1, Mitarbeiter m2) { +// if (m1.berechneAlter() > m2.berechneAlter()) +// return 1; // m1 ist aelter als m2 +// else +// if (m1.berechneAlter() < m2.berechneAlter()) +// return -1; // m1 ist juenger als m2 +// else // gleiches Alter +// return 0; +// } +// }); +// +// } + + public void sortiereDienstalter() { + Collections.sort(mitarbeiter, new DienstalterComparator()); + } + + // -------------------------------- kuendigen mehrere (Erweiterung) --- + + public int kuendigen(String name) throws PersonalException { + int anz = 0; + Mitarbeiter mit; + + if (name != null) { + if (mitarbeiter.size() > 0) { + Iterator iter = mitarbeiter.iterator(); + while (iter.hasNext()) { + mit = iter.next(); + if (mit.getName().equals(name)) { + iter.remove(); + anz++; + } + } + return anz; + } else + throw new PersonalException("Fehler bei kuendigen(name): keine Mitarbeiter vorhanden"); + // return -1; + } else + throw new PersonalException("Fehler bei kuendigen(name): null-Referenz fuer name erhalten"); + // return -1; + } + + public float kuendigen(float gehalt) throws PersonalException { + float summe = 0f; + Mitarbeiter mit; + if (gehalt >= 0f) { + Iterator iter = mitarbeiter.iterator(); + while (iter.hasNext()) { + mit = iter.next(); + if (mit.berechneGehalt() > gehalt) { + summe += mit.berechneGehalt(); + iter.remove(); + } + } + return summe; + } else { + throw new PersonalException("Fehler bei kuendigen(gehalt): negatives gehalt erhalten (" + gehalt + ")"); + // return -1f; + } + } + + public void remove(List auswahl) throws PersonalException + { + if (auswahl != null) + mitarbeiter.removeAll(auswahl); + else + throw new PersonalException("Fehler bei remove(auswahl): null-Referenz fuer auswahl erhalten"); + } + + // --------------------------------- files ---------------------------------- + public void saveMitarbeiter(String strPfadName) throws PersonalException { + if(strPfadName != null) + { + try ( // try with ressources -> close() erfolgt "automatisch" + ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream(strPfadName));) { + // hier erfolgt das "Speichern" + oos.writeObject(mitarbeiter); + + } catch (FileNotFoundException e) { + throw new PersonalException("Datei-Fehler bei saveMitarbeiter(): " + e.getMessage()); + } catch (IOException e) { + throw new PersonalException("Eingabe/Ausgabe-Fehler bei saveMitarbeiter(): " + e.getMessage()); + } + } + else + throw new PersonalException("Fehler bei saveMitarbeiter(): null-Referenz fuer strPfadName erhalten"); + } + public void saveMitarbeiter() throws PersonalException { + + String fSep = System.getProperty("file.separator"); + //String strPfadName = "c:\\scratch\\mitarbeiter.ser"; + String strPfadName = "c:"+ fSep + "scratch" + fSep + "mitarbeiter.ser"; + saveMitarbeiter(strPfadName); +// try ( // try with ressources -> close() erfolgt "automatisch" +// ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream(strPfadName));) { +// // hier erfolgt das "Speichern" +// oos.writeObject(mitarbeiter); +// +// } catch (FileNotFoundException e) { +// throw new PersonalException("Datei-Fehler bei saveMitarbeiter(): " + e.getMessage()); +// } catch (IOException e) { +// throw new PersonalException("Eingabe/Ausgabe-Fehler bei saveMitarbeiter(): " + e.getMessage()); +// } + } + +// loadMitarbeiter Variante 2 OHNE suppressWarning -> empfohlen + public void loadMitarbeiter(String strPfadName) throws PersonalException { + if (strPfadName != null) + { + + try ( ObjectInputStream ois = + new ObjectInputStream(new FileInputStream(strPfadName))) + { + + List tempMitarbeiter = (List ) ois.readObject(); + + mitarbeiter.clear(); // ersetzen und NICHT hinzufuegen + + for (Object o : tempMitarbeiter) + { + if (o instanceof Mitarbeiter) + { + aufnehmen((Mitarbeiter)o); + } + } + + } catch (FileNotFoundException e) { + throw new PersonalException("Datei-Fehler bei loadMitarbeiter(): " + e.getMessage()); + } catch (IOException e) { + throw new PersonalException("Eingabe/Ausgabe-Fehler bei loadMitarbeiter(): " + e.getMessage()); + } catch (ClassNotFoundException e) { + throw new PersonalException("Klassen-Fehler bei loadMitarbeiter(): " + e.getMessage()); + } + } + else + throw new PersonalException("Fehler bei loadMitarbeiter(): null-Referenz fuer strPfadName erhalten"); + } + public void loadMitarbeiter() throws PersonalException + { + + String fSep = System.getProperty("file.separator"); + //String strPfadName = "c:\\scratch\\mitarbeiter.ser"; + String strPfadName = "c:"+ fSep + "scratch" + fSep + "mitarbeiter.ser"; + loadMitarbeiter(strPfadName); + +// try ( ObjectInputStream ois = +// new ObjectInputStream(new FileInputStream(strPfadName))) +// { +// +// List tempMitarbeiter = (List ) ois.readObject(); +// +// mitarbeiter.clear(); // ersetzen und NICHT hinzufuegen +// +// for (Object o : tempMitarbeiter) +// { +// if (o instanceof Mitarbeiter) +// { +// aufnehmen((Mitarbeiter)o); +// } +// } +// +// } catch (FileNotFoundException e) { +// throw new PersonalException("Datei-Fehler bei loadMitarbeiter(): " + e.getMessage()); +// } catch (IOException e) { +// throw new PersonalException("Eingabe/Ausgabe-Fehler bei loadMitarbeiter(): " + e.getMessage()); +// } catch (ClassNotFoundException e) { +// throw new PersonalException("Klassen-Fehler bei loadMitarbeiter(): " + e.getMessage()); +// } + } + + // Variante1: es geht "typsicherer" -> Variante2 +// @SuppressWarnings("unchecked") // funktionsfaehige allerdings nicht empfohlene Variante1 +// public void loadMitarbeiter() throws PersonalException +// { +// String strPfadName = "c:\\scratch\\mitarbeiter.ser"; +// +// try ( ObjectInputStream ois = +// new ObjectInputStream(new FileInputStream(strPfadName))) +// { +// // nicht empfohlene Variante1 +// mitarbeiter = (ArrayList) ois.readObject(); +// +// } catch (FileNotFoundException e) { +// throw new PersonalException("Datei-Fehler bei loadMitarbeiter(): " + e.getMessage()); +// } catch (IOException e) { +// throw new PersonalException("Eingabe/Ausgabe-Fehler bei loadMitarbeiter(): " + e.getMessage()); +// } catch (ClassNotFoundException e) { +// throw new PersonalException("Klassen-Fehler bei loadMitarbeiter(): " + e.getMessage()); +// } +// } + + public void exportMitarbeiter(String strPfadName) throws PersonalException { + String nLn = System.getProperty("line.separator"); + if (strPfadName != null) + { + try ( BufferedWriter bw = new BufferedWriter(new FileWriter(strPfadName))) + { + for (Mitarbeiter mit : mitarbeiter) + { + //bw.write(mit.toString() + "\n"); + bw.write(mit.toString() + nLn); // mit Line-Separator + } + + } catch (IOException e) { + throw new PersonalException("Eingabe/Ausgabe-Fehler bei exportMitarbeiter()" + + e.getMessage()); + } + } + else + throw new PersonalException("Fehler bei exportMitarbeiter(): null-Referenz fuer strPfadName erhalten"); + } + + public void exportMitarbeiter() throws PersonalException + { + + String fSep = System.getProperty("file.separator"); + String strPfadName = "c:"+ fSep + "scratch" + fSep + "mitarbeiter.txt"; + exportMitarbeiter(strPfadName); +// String nLn = System.getProperty("line.separator"); +// try ( BufferedWriter bw = new BufferedWriter(new FileWriter(strPfadName))) +// { +// for (Mitarbeiter mit : mitarbeiter) +// { +// //bw.write(mit.toString() + "\n"); +// bw.write(mit.toString() + nLn); // mit Line-Separator +// } +// +// } catch (IOException e) { +// throw new PersonalException("Eingabe/Ausgabe-Fehler bei exportMitarbeiter()" +// + e.getMessage()); +// } + } + + public void exportMitarbeiterCsv() throws PersonalException + { + String fSep = System.getProperty("file.separator"); + String strPfadName = "c:"+ fSep + "scratch" + fSep + "mitarbeiter.csv"; + String nLn = System.getProperty("line.separator"); + + try (BufferedWriter bw = new BufferedWriter(new FileWriter(strPfadName))) + { + StringBuilder sb = new StringBuilder(100000); + for (Mitarbeiter mit : mitarbeiter) + sb.append(mit.toStringCsv()).append(nLn); // .append("\n"); + bw.write(sb.toString()); + } catch (IOException e) { + throw new PersonalException("Eingabe/Ausgabe-Fehler bei exportMitarbeiterCsv()" + + e.getMessage()); + } + } + + // NEU 2022-04-06 mit Freelancer und Arzt + public void importMitarbeiterCsv() throws PersonalException + { + String fSep = System.getProperty("file.separator"); + String strPfadName = "c:"+fSep+"scratch"+fSep+"mitarbeiter.csv"; + + try(BufferedReader br = new BufferedReader(new FileReader(strPfadName))) + { + String zeile; + String[] zeilenTeile; + String sep = ";"; // erwartetes Trennzeichen in der csv-Datei + + // Muster: "Vorauslesen" + zeile = br.readLine(); // wenn keine Zeile gefunden, dann return null + + while(zeile != null) + { + zeilenTeile = zeile.trim().split(sep); + + // Welcher Konstruktor wird aufgerufen? + // Wie ermitteln wir den Mitarbeiter-Typ? + + if (zeile.contains("Angestellter")) + { + aufnehmen(new Angestellter(zeilenTeile)); + } + else + if (zeile.contains("Freelancer")) + { + aufnehmen(new Freelancer(zeilenTeile)); + } + else + if (zeile.contains("Arzt")) + { + aufnehmen(new Arzt(zeilenTeile)); + } + else + ; // hier Mitarbeiter-Typ(en) + // zukuenftiger Erweiterungen ergaenzen + zeile = br.readLine(); + } + + } catch (FileNotFoundException e) { + throw new PersonalException("Datei-Fehler bei importMitarbeiterCsv(): " + + e.getMessage()); + } catch (IOException e) { + throw new PersonalException("Eingabe/Ausgabe-Fehler bei importMitarbeiterCsv(): " + + e.getMessage()); + } + } + + // -------------------------- print / toString --------------------------------- + public String toString() { + Mitarbeiter mit; + // String str = ""; + // if (anzahl > 0) + // { + // for (int i = 0; i < anzahl; i++) + // { + // mit = mitarbeiter[i]; + // str += mit.toString() + "\n"; + // } + // } + // else + // str += "keine Mitarbeiter im Personalbuero"; + // return str; + StringBuffer sb = new StringBuffer(10000); + // if (anzahl > 0) + if (mitarbeiter.size() > 0) { + // for (int i = 0; i < anzahl; i++) + for (int i = 0; i < mitarbeiter.size(); i++) { + // mit = mitarbeiter[i]; + mit = mitarbeiter.get(i); + sb.append(mit).append('\n'); + } + } else + sb.append("keine Mitarbeiter im Personalbuero"); + return sb.toString(); + } + + public void print() { + System.out.println(this); + } +} diff --git a/src/model/PraemieBerechenbar.java b/src/model/PraemieBerechenbar.java new file mode 100644 index 0000000..445e941 --- /dev/null +++ b/src/model/PraemieBerechenbar.java @@ -0,0 +1,18 @@ +package model; + + +/** + * Interface PraemieBerechenbar + * + * @author (WES) + * @version (2022-01-27) + */ + +public interface PraemieBerechenbar +{ + public float berechnePraemie(); + + public String infoBerechnungPraemie(); + + +} diff --git a/src/test/TestAngestellter.java b/src/test/TestAngestellter.java new file mode 100644 index 0000000..d1a2986 --- /dev/null +++ b/src/test/TestAngestellter.java @@ -0,0 +1,40 @@ +package test; + +import java.time.Year; +import model.Angestellter; +import model.PersonalException; + +/** + * Klasse TestAngestellter. + * + * @author (WES) + * @version (2022-03-18) + * + * umgestellt auf Exception-Handling und main() + */ +public class TestAngestellter +{ + public static void main(String[] args) + { + testAngestellter(); + } + + public static void testAngestellter() + { + try { + Angestellter a1 = new Angestellter(); + Angestellter a2 = new Angestellter("Alfred", 'm', Year.of(1963), Year.of(2007)); + a1.print(); // Anna + a2.print(); // Alfred + System.out.println(); + + // Fehler + a2.setGesch('i'); + System.out.println("Diese Zeile wird nicht mehr ausgegeben"); + + } catch (PersonalException e) { + System.out.println("Fehler bearbeitet bei testAngestellter(): " + e.getMessage()); + } + System.out.println("Diese Zeile wird schon ausgegeben"); + } +} diff --git a/src/test/TestArzt.java b/src/test/TestArzt.java new file mode 100644 index 0000000..47f7196 --- /dev/null +++ b/src/test/TestArzt.java @@ -0,0 +1,66 @@ +package test; + +import java.time.Year; + +import model.Arzt; +import model.PersonalException; +/** + * Klasse TestArzt + * + * @author (WES) + * @version (2022-03-18) + * + * umgestellt auf EH und main() + */ +public class TestArzt +{ + public static void main(String[] args) + { + testArzt(); + } + + public static void testArzt() + { + try { + Arzt ar1 = new Arzt("Wolfgang", 'm', Year.of(1964), Year.now(), 40, 1200f); + System.out.println(ar1); + System.out.println(); + + System.out.println(ar1.berechneStundensatz()); // 30.0 + System.out.println(); + + // "ungesundes" Testobjekt - wird nicht mehr erzeugt + Arzt ar0 = new Arzt(null, '\t', Year.of(-2000), null, -15, -99f); // Fehler null + System.out.println(ar0); // "ungesunde" Attributwerte werden nicht mehr angezeigt + System.out.println(); // auch dieser Code wird nicht mehr ausgefuehrt + + } catch (PersonalException e) { + System.out.println("Fehler bearbeitet bei testArzt(): " + e.getMessage()); + } + + + + + + + + + + + + } + + + + + + + + + + + + + + +} diff --git a/src/test/TestExport.java b/src/test/TestExport.java new file mode 100644 index 0000000..6899e4c --- /dev/null +++ b/src/test/TestExport.java @@ -0,0 +1,43 @@ +package test; + +import java.time.Year; +import model.Angestellter; +import model.Arzt; +import model.Freelancer; +import model.PersonalException; +import model.Personalbuero; + +// 2022-03-31 um Arzt erweitert + +public class TestExport +{ + public static void main(String[] args) + { + String nLn = System.getProperty("line.separator"); + + System.out.println("+++++++++++++++++++++++ testExportCsvMitarbeiter +++++++++++++++++++++++++\n"); + try { + Personalbuero pb = new Personalbuero(); + + Angestellter a1 = new Angestellter("Alfred", 'm', Year.of(1977), Year.now()); + pb.aufnehmen(a1); + + Freelancer f2 = new Freelancer("Anna", 'w', Year.of(1976), Year.of(2002), 100f, 10); + pb.aufnehmen(f2); + + Arzt ar1 = new Arzt("Wolfgang", 'm', Year.of(1964), Year.now(), 40, 1200f); + pb.aufnehmen(ar1); + + System.out.println(pb); // Alfred, Anna, Wolfgang + System.out.println(); + + pb.exportMitarbeiterCsv(); + System.out.println("exportMitarbeiterCsv() wurde ausgefuehrt"); + } + catch (PersonalException e) + { + System.out.println("!!! Fehler bei TestExport !!!" +nLn+ e.getMessage()); + } + + } +} diff --git a/src/test/TestFreelancer.java b/src/test/TestFreelancer.java new file mode 100644 index 0000000..ab278a4 --- /dev/null +++ b/src/test/TestFreelancer.java @@ -0,0 +1,69 @@ +package test; + + +// 2022-03-18 3BAIF +// umgestellt auf EH und main() +import java.time.Year; + +import model.Freelancer; +import model.PersonalException; + +public class TestFreelancer +{ + + public static void main(String[] args) + { + testBerechnePraemie(); + testFreelancer(); + } + + public static void testBerechnePraemie() + { + try { + Freelancer f1 = new Freelancer("Eva",'w',Year.of(1980),Year.of(2001),100f,10); + System.out.println(f1); + Freelancer f2 = new Freelancer("Heinz", 'm',Year.of(2002),Year.of(2022),10f,100); + System.out.println(f2); + Freelancer f3 = new Freelancer("Anna",'w',Year.of(1990),Year.of(2007),100f,10); + System.out.println(f3); + Freelancer f4 = new Freelancer("Walter", 'm',Year.of(1980),Year.of(2002),10f,100); + System.out.println(f4); + System.out.println(); + + System.out.println(f1.berechnePraemie()); // 0.0 // 21 Jahre + System.out.println(f1.infoBerechnungPraemie()); + System.out.println(); + + System.out.println(f2.berechnePraemie()); // 0.0 // 0 Jahre + System.out.println(f3.berechnePraemie()); // 1000.0 // 15 Jahre + System.out.println(f4.berechnePraemie()); // 2000.0 // 20 Jahre + System.out.println(); + + } catch (PersonalException e) { + System.out.println("Fehler bearbeitet bei testFreelancer(): " + e.getMessage()); + } + } + + public static void testFreelancer() + { + try { +// Freelancer f01 = new Freelancer(0f,0); // Fehler 1x: Stundensatz +// System.out.println(); +// Freelancer f02 = new Freelancer(1f,0); // Fehler 1x: Stunden +// System.out.println(); + + Freelancer f1 = new Freelancer(100f,10); + System.out.println(f1); + System.out.println(f1.berechneGehalt()); // 1000 + System.out.println(); + + Freelancer f2 = new Freelancer(10f,100); + System.out.println(f2); + System.out.println(f2.berechneGehalt()); // 1000 + System.out.println(); + + } catch (PersonalException e) { + System.out.println("Fehler bearbeitet bei testFreelancer(): " + e.getMessage()); + } + } +} diff --git a/src/test/TestImport.java b/src/test/TestImport.java new file mode 100644 index 0000000..5212455 --- /dev/null +++ b/src/test/TestImport.java @@ -0,0 +1,66 @@ +package test; + +import java.time.Year; +import model.Angestellter; +import model.Freelancer; +import model.PersonalException; +import model.Personalbuero; + +// 2022-04-05 + +public class TestImport +{ + public static void main(String[] args) + { + String nLn = System.getProperty("line.separator"); + + try + { + Personalbuero pb = new Personalbuero(); + pb.aufnehmen(new Angestellter("Hans", 'x', Year.of(1965), Year.of(1985))); + System.out.println(pb); + System.out.println(); + + // zeilenTeile-Konstruktoren testen + // TODO FUE Freelancer + // TODO FUE Arzt + +// pb.aufnehmen(new Angestellter(new String[] {})); // Array-Fehler: Index 1 out of bounds for length 0 +// pb.aufnehmen(new Angestellter(new String[] {"", "", "", "",""})); // Fehler: falscher Parameterwert name +// pb.aufnehmen(new Angestellter(new String[] {"", "Hannes", "", "",""})); // Fehler: falscher Parameterwert gesch +// pb.aufnehmen(new Angestellter(new String[] {"", "Hannes", "m", "neunzehnhundertfuenfundsechzig",""})); // Fehler: falscher Paramterwert gebJahr +// pb.aufnehmen(new Angestellter(new String[] {"", "Hannes", "m", "1965","neunzehnhundertfuenfundachzig"})); // Fehler: falscher Paramterwert eintrJahr + pb.aufnehmen(new Angestellter(new String[] {"Angestellter", "Hannes", "m", "1965","1985"})); + + System.out.println(pb); // Hans, Hannes + System.out.println(); + + pb.importMitarbeiterCsv(); + System.out.println(pb); // Hans, Hannes, Alfred, Anna, Wolfgang + System.out.println(); + + try { + Freelancer f2 = new Freelancer("Anna", 'w', Year.of(1976), Year.of(2002), 100f, 10); + pb.aufnehmen(f2); // Fehler schon vorhanden // TODO kein Fehler + } + catch (PersonalException e) { + System.out.println("!!! Fehler bei TestImport !!!" +nLn+ e.getMessage()); + System.out.println(); + } + + System.out.println(pb); // Hans, Hannes, Alfred, Anna, Wolfgang + System.out.println(); + + Angestellter a1 = new Angestellter("Alfred", 'm', Year.of(1977), Year.now()); + pb.aufnehmen(a1); // Fehler schon vorhanden // TODO kein Fehler + + System.out.println(pb); // Hans, Hannes, Alfred, Anna, Wolfgang + System.out.println(); + + } + catch (PersonalException e) + { + System.out.println("!!! Fehler bei TestImport !!!" +nLn+ e.getMessage()); + } + } +} diff --git a/src/test/TestMitarbeiter.java b/src/test/TestMitarbeiter.java new file mode 100644 index 0000000..ba10c2b --- /dev/null +++ b/src/test/TestMitarbeiter.java @@ -0,0 +1,51 @@ +package test; + +// 2022-01-18 auskommentiert (wegen abstract Mitarbeiter) +//import java.time.Year; + +public class TestMitarbeiter +{ + public static void mitarbeiterTest() + { + // "ungesunde" Testobjekte + //Mitarbeiter m01 = new Mitarbeiter(null, '?', null, null ); // 4 Meldung(en) + // System.out.println(); + // Mitarbeiter m02 = new Mitarbeiter("a", 'w', Year.now().minusYears(101), null); // 3 Meldung(en) + // System.out.println(); + // Mitarbeiter m03 = new Mitarbeiter("ab", 'w', null, Year.now().minusYears(16)); // 2 Meldung(en) + // System.out.println(); + // Mitarbeiter m04 = new Mitarbeiter("ab", 'w', Year.now().plusYears(1), Year.now().plusYears(1)); // 2 Meldung(en) + // System.out.println(); + // Mitarbeiter m05 = new Mitarbeiter("xyz", 'w', Year.now().minusYears(14), Year.now()); // 1 Meldung(en) + // System.out.println(); + // Mitarbeiter m05 = new Mitarbeiter("xyz", 'w', Year.now().plusYears(9), Year.now()); // 1 Meldung(en) + // System.out.println(); + // System.out.println(m01); // java.lang.NullPointerException + // System.out.println(m02); // java.lang.NullPointerException + // System.out.println(m03); // java.lang.NullPointerException + // System.out.println(m04); // java.lang.NullPointerException + // System.out.println(m05); // java.lang.NullPointerException + + // "gesunde" Testobjekte + // Mitarbeiter ma1 = new Mitarbeiter("Alfred",'m',Year.of(1976),Year.of(2001)); + // Mitarbeiter ma2 = new Mitarbeiter("Berti",'x',Year.of(1986),Year.of(2011)); + // Mitarbeiter ma3 = new Mitarbeiter("Claudia",'w',Year.of(1996),Year.of(2020)); + + // System.out.println(ma1); + // System.out.println(ma2); + // System.out.println(ma3); + // System.out.println(); + + // System.out.println("Aktuelles Jahr: " + Year.now()); + // System.out.println(); + + // System.out.println(ma1.berechneDienstalter()); // 20 + // System.out.println(); + + // System.out.println(ma2.berechneDienstalter()); // 10 + // System.out.println(); + + // System.out.println(ma3.berechneDienstalter()); // 1 + // System.out.println(); + } +} diff --git a/src/test/TestMitarbeiter_EH.java b/src/test/TestMitarbeiter_EH.java new file mode 100644 index 0000000..21284e4 --- /dev/null +++ b/src/test/TestMitarbeiter_EH.java @@ -0,0 +1,116 @@ +package test; + +//import java.time.Year; +// +//import model.Mitarbeiter; +//import model.PersonalException; + +// 2022-03-18 EH und main() (wegen abstract Mitarbeiter) + +public class TestMitarbeiter_EH { + +// public static void main(String[] args) { +// +// mitarbeiterTest(); +// +// } +// +// public static void mitarbeiterTest() { +// +// // "ungesunde" Testobjekte +// +// Mitarbeiter m01 = null; +// Mitarbeiter m02 = null; +// Mitarbeiter m03 = null; +// Mitarbeiter m04 = null; +// Mitarbeiter m05 = null; +// +// try { +// m01 = new Mitarbeiter(null, '?', null, null); +// } catch (PersonalException e) { +// System.out.println("mitarbeiterTest() hat Ausnahme-Objekt bearbeitet\n" + "Erhaltene Fehlermeldung: " +// + e.getMessage()); +// // e.printStackTrace(); +// } +// System.out.println(); +// +// try { +// m02 = new Mitarbeiter("a", 'w', Year.now().minusYears(101), null); +// } catch (PersonalException e) { +// System.out.println("mitarbeiterTest() hat Ausnahme-Objekt bearbeitet\n" + "Erhaltene Fehlermeldung: " +// + e.getMessage()); +// } +// System.out.println(); +// +// try { +// m03 = new Mitarbeiter("ab", 'w', null, Year.now().minusYears(16)); +// } catch (PersonalException e) { +// System.out.println("mitarbeiterTest() hat Ausnahme-Objekt bearbeitet\n" + "Erhaltene Fehlermeldung: " +// + e.getMessage()); +// } +// System.out.println(); +// +// try { +// m04 = new Mitarbeiter("ab", 'w', Year.now().plusYears(1), Year.now().plusYears(1)); +// } catch (PersonalException e) { +// System.out.println("mitarbeiterTest() hat Ausnahme-Objekt bearbeitet\n" + "Erhaltene Fehlermeldung: " +// + e.getMessage()); +// } +// System.out.println(); +// +// try { +// m05 = new Mitarbeiter("xyz", 'w', Year.now().minusYears(14), Year.now()); +// } catch (PersonalException e) { +// System.out.println("mitarbeiterTest() hat Ausnahme-Objekt bearbeitet\n" + "Erhaltene Fehlermeldung: " +// + e.getMessage()); +// } +// System.out.println(); +// +// // die "ungesunden" Objekte wurden nicht erzeugt +// // alle Objektreferenz-Variablen sind weiterhin null +// +// System.out.println(m01); // null +// System.out.println(m02); // null +// System.out.println(m03); // null +// System.out.println(m04); // null +// System.out.println(m05); // null +// System.out.println(); +// +// // "gesunde" Testobjekte +// +// try { +// Mitarbeiter ma1 = new Mitarbeiter("Alfred", 'm', Year.of(1976), Year.of(2001)); +// Mitarbeiter ma2 = new Mitarbeiter("Berti", 'x', Year.of(1986), Year.of(2011)); +// Mitarbeiter ma3 = new Mitarbeiter("Claudia", 'w', Year.of(1996), Year.of(2020)); +// +// System.out.println(ma1); +// System.out.println(ma2); +// System.out.println(ma3); +// System.out.println(); +// +// System.out.println("Aktuelles Jahr: " + Year.now()); +// System.out.println(); +// +// System.out.println(ma1.berechneDienstalter()); // 20 +// System.out.println(); +// +// System.out.println(ma2.berechneDienstalter()); // 10 +// System.out.println(); +// +// System.out.println(ma3.berechneDienstalter()); // 1 +// System.out.println(); +// +// // zum Testen von catch(Exception e) +// throw new Exception("Erzeugtes Fehlerobjekt zum Testen von catch(Exception e)"); +// +// } catch (PersonalException e) { +// System.out.println("mitarbeiterTest() hat Ausnahme-Objekt bearbeitet\n" + "Erhaltene Fehlermeldung: " +// + e.getMessage()); +// +// } catch (Exception e) { +// System.out.println("mitarbeiterTest(): ein unerwarteter Ausnahme-Fehler ist aufgetreten"); +// System.out.println("Erhaltene Fehlermeldung und StackTrace:"); +// e.printStackTrace(); +// } +// } +} diff --git a/src/test/TestPersonalbuero.java b/src/test/TestPersonalbuero.java new file mode 100644 index 0000000..6e95628 --- /dev/null +++ b/src/test/TestPersonalbuero.java @@ -0,0 +1,363 @@ +package test; + +//import java.time.Year; +// +//import model.Angestellter; +//import model.Arzt; +//import model.Freelancer; +//import model.Mitarbeiter; +//import model.Personalbuero; + +// 2022-01-11 3BAIF +// mit testBerechneDurchschnittsalter() +// 2022-01-18 alle Testmethoden mit new Mitarbeiter(...) auskommentiert (wegen abstract Mitarbeiter) +// 2022-01-19 Uebung: Testmethoden anpassen auf Freelancer und Angestellter + +// 2022-01-20 mit folgenden Testmethoden: +// testBerechneDurchschnittsalter() +// testZaehleAlter() +// testZaehleMitarbeiter() +// testKuendigenMitarbeiter() +// testKuendigenMitarbeiterPos() + +// 2022-01-25 mit folgenden Testmethoden: +// testZaehleAngestellte() +// testBerechneAvgGehaltAngestellte() + +// 2022-01-26 mit Erweiterung von personalbueroTest() +// zum Aufnehmen von Arzt-Objekten in das Personalbuero + +// 2022-03-18 Freiwillige Uebung: Umstellen auf Exception-Handling + +public class TestPersonalbuero +{ +// public static void testBerechneAvgGehaltAngestellte() +// { +// Personalbuero pb = new Personalbuero(); +// System.out.println(pb); // keine MA +// System.out.println(); +// +// System.out.println(pb.berechneAvgGehaltAngestellte()); // -99.0 +// System.out.println(); +// +// // ein Angestellter +// Mitarbeiter ma1 = new Angestellter("Alfred", 'm',Year.of(1976),Year.of(2001)); // 2550.0 +// pb.aufnehmen(ma1); +// System.out.println(pb); // 1 MA +// System.out.println(); +// +// System.out.println(pb.berechneAvgGehaltAngestellte()); // 2550.0 +// System.out.println(); +// +// // zwei Angestellte +// Mitarbeiter ma2 = new Angestellter("Anna", 'w',Year.of(1975),Year.of(2001)); // 2550.0 +// pb.aufnehmen(ma2); +// System.out.println(pb); // 2 MA +// System.out.println(); +// +// System.out.println(pb.berechneAvgGehaltAngestellte()); // 2550.0 +// System.out.println(); +// +// // drei Angestellte +// Mitarbeiter ma3 = new Angestellter("Claudia",'w',Year.of(1996),Year.of(2020)); // 1600.0 +// pb.aufnehmen(ma3); +// System.out.println(pb); // 3 MA +// System.out.println(); +// +// System.out.println(pb.berechneAvgGehaltAngestellte()); // 2233.3333 +// System.out.println(); +// +// // drei Angestellte, ein Freelancer +// Freelancer f1 = new Freelancer("Frederike", 'w',Year.of(1975),Year.of(2001), 100f, 10); +// pb.aufnehmen(f1); +// System.out.println(pb); // 3 Angestellte, 1 Freelancer +// System.out.println(); +// +// System.out.println(pb.berechneAvgGehaltAngestellte()); // 2233.3333 +// System.out.println(); +// } +// +// public static void testZaehleAngestellte() +// { +// Personalbuero pb = new Personalbuero(); +// System.out.println(pb); // keine MA +// System.out.println(); +// +// System.out.println(pb.zaehleAngestellte()); // 0 Hinweismeldung keine MA +// System.out.println(); +// +// // ein Mitarbeiter +// Angestellter a1 = new Angestellter("Alfred", 'm',Year.of(1977),Year.of(2002)); // 45 +// pb.aufnehmen(a1); +// System.out.println(pb); // 1 MA: Angestellter Alfred +// System.out.println(); +// +// System.out.println(pb.zaehleAngestellte()); // 1 +// System.out.println(); +// +// // zwei Mitarbeiter +// Freelancer f2 = new Freelancer("Anna", 'w',Year.of(1976),Year.of(2002), 100f, 10); // 46 +// pb.aufnehmen(f2); +// System.out.println(pb); // 2 MA: Angestellter Alfred, Freelancer Anna +// System.out.println(); +// +// System.out.println(pb.zaehleAngestellte()); // 1 +// System.out.println(); +// } +// +// public static void testBerechneDurchschnittsalter() +// { +// Personalbuero pb = new Personalbuero(); +// System.out.println(pb); // keine MA +// System.out.println(); +// +// System.out.println(pb.berechneDurchschnittsalter()); // -99.0 +// System.out.println(); +// +// // ein Mitarbeiter +// Angestellter a1 = new Angestellter("Alfred", 'm',Year.of(1977),Year.of(2002)); // 45 +// pb.aufnehmen(a1); +// System.out.println(pb); // 1 MA: Angestellter Alfred +// System.out.println(); +// +// System.out.println(pb.berechneDurchschnittsalter()); // 45.0 +// System.out.println(); +// +// // zwei Mitarbeiter +// Freelancer f2 = new Freelancer("Anna", 'w',Year.of(1976),Year.of(2002), 100f, 10); // 46 +// pb.aufnehmen(f2); +// System.out.println(pb); // 2 MA: Angestellter Alfred, Freelancer Anna +// System.out.println(); +// +// System.out.println(pb.berechneDurchschnittsalter()); // 45.5 +// System.out.println(); +// } +// +// public static void testZaehleAlter() +// { +// Personalbuero pb = new Personalbuero(); +// System.out.println(pb); +// System.out.println(); +// +// System.out.println(pb.zaehleAlter(0)); // Fehler und -99 +// System.out.println(); +// +// System.out.println(pb.zaehleAlter(1)); // Hinweis und 0 +// System.out.println(); +// +// // ein Mitarbeiter +// Angestellter a1 = new Angestellter("Alfred", 'm',Year.of(1977),Year.of(2002)); // 45 +// pb.aufnehmen(a1); +// System.out.println(pb); // 1 MA: Angestellter Alfred +// System.out.println(); +// +// System.out.println(pb.zaehleAlter(45)); // 0 +// System.out.println(); +// +// System.out.println(pb.zaehleAlter(44)); // 1 +// System.out.println(); +// +// // zwei Mitarbeiter +// Freelancer f2 = new Freelancer("Anna", 'w',Year.of(1976),Year.of(2002), 100f, 10); // 46 +// pb.aufnehmen(f2); +// System.out.println(pb); // 2 MA: Angestellter Alfred, Freelancer Anna +// System.out.println(); +// +// System.out.println(pb.zaehleAlter(46)); // 0 +// System.out.println(); +// +// System.out.println(pb.zaehleAlter(45)); // 1 +// System.out.println(); +// +// System.out.println(pb.zaehleAlter(44)); // 2 +// System.out.println(); +// } +// +// public static void testZaehleMitarbeiter() +// { +// Personalbuero pb = new Personalbuero(); +// System.out.println(pb); +// System.out.println(); +// +// System.out.println(pb.zaehleMitarbeiter()); // 0 +// System.out.println(); +// +// // ein Mitarbeiter +// Angestellter a1 = new Angestellter("Alfred", 'm',Year.of(1977),Year.of(2002)); +// pb.aufnehmen(a1); +// System.out.println(pb); // 1 MA: Angestellter Alfred +// System.out.println(); +// +// System.out.println(pb.zaehleMitarbeiter()); // 1 +// System.out.println(); +// +// // zwei Mitarbeiter +// Freelancer f2 = new Freelancer("Anna", 'w',Year.of(1976),Year.of(2002), 100f, 10); +// pb.aufnehmen(f2); +// System.out.println(pb); // 2 MA: Angestellter Alfred, Freelancer Anna +// System.out.println(); +// +// System.out.println(pb.zaehleMitarbeiter()); // 2 +// System.out.println(); +// } +// +// public static void testKuendigenMitarbeiterPos() +// { +// Personalbuero pb = new Personalbuero(); +// System.out.println(pb); // keine MA +// System.out.println(); +// +// Angestellter a1 = new Angestellter("Alfred", 'm',Year.of(1976),Year.of(2002)); // 2500.0 +// Angestellter a2 = new Angestellter("Berti", 'x',Year.of(1986),Year.of(2012)); // 2000.0 +// Angestellter a3 = new Angestellter("Claudia",'w',Year.of(1996),Year.of(2021)); // 1550.0 +// Angestellter a4 = new Angestellter("Alfred", 'm',Year.of(1976),Year.of(2021)); // 1550.0 +//// Angestellter a5 = new Angestellter("Dominik",'x',Year.of(1986),Year.of(2022)); // 1500.0 +//// Angestellter a6 = new Angestellter("Erhard", 'w',Year.of(1996),Year.of(2022)); // 1500.0 +// +// System.out.println(pb.kuendigen(-1)); // Fehler false +// System.out.println(); +// +// System.out.println(pb.kuendigen(0)); // Fehler false +// System.out.println(); +// +// pb.aufnehmen(a1); // Alfred +// System.out.println(pb); // 1 MA +// System.out.println(); +// +// System.out.println(pb.kuendigen(1)); // Fehler false +// System.out.println(); +// +// System.out.println(pb.kuendigen(0)); // true +// System.out.println(); +// +// System.out.println(pb); // keine MA +// System.out.println(); +// +// pb.aufnehmen(a2); // Berti +// pb.aufnehmen(a3); // Claudia +// pb.aufnehmen(a4); // Alfred +// System.out.println(pb); // 3 MA Berti, Claudia, Alfred +// System.out.println(); +// +// System.out.println(pb.kuendigen(2)); // true Alfred +// System.out.println(); +// System.out.println(pb); // 2 MA Berti, Claudia +// System.out.println(); +// +// System.out.println(pb.kuendigen(0)); // true Berti +// System.out.println(); +// +// System.out.println(pb); // 1 MA Claudia +// System.out.println(); +// +// System.out.println(pb.kuendigen(0)); // true Claudia +// System.out.println(); +// +// System.out.println(pb); // keine MA +// System.out.println(); +// } +// +// public static void testKuendigenMitarbeiter() +// { +// Personalbuero pb = new Personalbuero(); +// System.out.println(pb); // keine MA +// System.out.println(); +// +// Angestellter a1 = new Angestellter("Alfred", 'm',Year.of(1976),Year.of(2002)); // 2500.0 +// Angestellter a2 = new Angestellter("Berti", 'x',Year.of(1986),Year.of(2012)); // 2000.0 +// Angestellter a3 = new Angestellter("Claudia",'w',Year.of(1996),Year.of(2021)); // 1550.0 +// Angestellter a4 = new Angestellter("Alfred", 'm',Year.of(1976),Year.of(2021)); // 1550.0 +//// Angestellter a5 = new Angestellter("Dominik",'x',Year.of(1986),Year.of(2022)); // 1500.0 +//// Angestellter a6 = new Angestellter("Erhard", 'w',Year.of(1996),Year.of(2022)); // 1500.0 +// +// System.out.println(pb.kuendigen((Mitarbeiter) null)); // Fehler false +// System.out.println(); +// +// pb.aufnehmen(a1); // Alfred +// System.out.println(pb); // 1 MA +// System.out.println(); +// +// System.out.println(pb.kuendigen(a2)); // Fehler false +// System.out.println(); +// +// System.out.println(pb.kuendigen(a1)); // true +// System.out.println(); +// +// System.out.println(pb); // keine MA +// System.out.println(); +// +// pb.aufnehmen(a2); // Berti +// pb.aufnehmen(a3); // Claudia +// pb.aufnehmen(a4); // Alfred +// System.out.println(pb); // 3 MA Berti, Claudia, Alfred +// System.out.println(); +// +// System.out.println(pb.kuendigen(a4)); // true Alfred +// System.out.println(); +// System.out.println(pb); // 2 MA Berti, Claudia +// System.out.println(); +// +// System.out.println(pb.kuendigen(a2)); // true Berti +// System.out.println(); +// +// System.out.println(pb); // 1 MA Claudia +// System.out.println(); +// +// System.out.println(pb.kuendigen(a3)); // true Claudia +// System.out.println(); +// +// System.out.println(pb); // keine MA +// System.out.println(); +// } +// +// public static void personalbueroTest() +// { +// Personalbuero pb = new Personalbuero(); +// System.out.println(pb); +// System.out.println(); +// +// // Mitarbeiter ma1 = new Mitarbeiter("Alfred", 'm',Year.of(1976),Year.of(2001)); // 2500.0 +// // Mitarbeiter ma2 = new Mitarbeiter("Berti", 'x',Year.of(1986),Year.of(2011)); // 2000.0 +// // Mitarbeiter ma3 = new Mitarbeiter("Claudia",'w',Year.of(1996),Year.of(2020)); // 1550.0 +// // Mitarbeiter ma4 = new Mitarbeiter("Alfred", 'm',Year.of(1976),Year.of(2020)); // 1550.0 +// // Mitarbeiter ma5 = new Mitarbeiter("Dominik",'x',Year.of(1986),Year.of(2021)); // 1500.0 +// // Mitarbeiter ma6 = new Mitarbeiter("Erhard", 'w',Year.of(1996),Year.of(2021)); // 1500.0 +// +// Freelancer f1 = new Freelancer("Alfred", 'm',Year.of(1976),Year.of(2002), 100f, 10); +// Angestellter a1 = new Angestellter(); // Anna +// +// System.out.println(pb.berechneGehaltsumme()); // 0.0 +// System.out.println(); +// +// System.out.println(pb.aufnehmen(f1)); // true +// System.out.println(pb.aufnehmen(a1)); // true +// // System.out.println(pb.aufnehmen(ma3)); // true +// // System.out.println(pb.aufnehmen(ma4)); // true +// // System.out.println(pb.aufnehmen(ma5)); // true +// // System.out.println(pb.aufnehmen(ma6)); // true +// System.out.println(pb); // 2 MA: 1 Freelander, 1 Angestellter +// System.out.println(); +// +// System.out.println(pb.berechneGehaltsumme()); // 2500.0 +// System.out.println(); +// +// Arzt ar1 = new Arzt("Wolfgang", 'm', Year.of(1964), Year.now(), 40, 1200f); // 1200.0 +// System.out.println(ar1); +// System.out.println(); +// +// System.out.println(pb.aufnehmen(ar1)); // true +// System.out.println(); +// +// System.out.println(pb); // Freelancer Alfred, Angestellte Anna, Arzt Wolfgang +// System.out.println(); +// +// System.out.println(pb.berechneGehaltsumme()); // 3700.0 +// System.out.println(); +// +// +// +// +// +// +// } +} diff --git a/src/test/TestPersonalbueroMain.java b/src/test/TestPersonalbueroMain.java new file mode 100644 index 0000000..0aa449d --- /dev/null +++ b/src/test/TestPersonalbueroMain.java @@ -0,0 +1,429 @@ +package test; + +// 2022-03-25 4BAIF +// 2022-03-21 umgestellt auf EH +// 2022-03-22 mit testSaveMitarbeiter und testLoadMitarbeiter +// 2022-03-25 mit testExportMitarbeiter(); + +import java.time.Year; + +import model.Angestellter; +import model.Freelancer; +import model.PersonalException; +import model.Personalbuero; + +public class TestPersonalbueroMain { + + public static void main(String[] args) { + + try { +// System.out.println("------------- Testmethoden fuer TestAngestellter ---------------\n"); +// test.TestAngestellter.testAngestellter(); +// System.out.println(); +// System.out.println("-------------- Testmethoden fuer TestArzt ---------------\\n\""); +// test.TestArzt.testArzt(); +// System.out.println(); + +// testSortiereMitarbeiter(); +// testSortiereName(); +// testSortiereAlter(); +// testSortiereDienstalter(); + +// testKuendigeName(); +// testKuendigeGehalt(); + + testSaveMitarbeiter(); + testLoadMitarbeiter(); + + testExportMitarbeiter(); + + } catch (Exception e) { + System.out.println("TestPersonalbueroMain: ein unerwarteter Ausnahme-Fehler ist aufgetreten"); + System.out.println("Erhaltene Fehlermeldung und StackTrace:"); + e.printStackTrace(); + } + } + + private static void testExportMitarbeiter() { + + System.out.println("+++++++++++++++++++++++ testExportMitarbeiter +++++++++++++++++++++++++\n"); + + try { + Personalbuero pb = new Personalbuero(); + + Angestellter a1 = new Angestellter("Alfred", 'm', Year.of(1977), Year.now()); + pb.aufnehmen(a1); + Freelancer f2 = new Freelancer("Anna", 'w', Year.of(1976), Year.of(2002), 100f, 10); // 1000 + pb.aufnehmen(f2); + + System.out.println(pb); // Alfred / Anna + System.out.println(); + + pb.exportMitarbeiter(); + System.out.println("Die Mitarbeiter wurden exportiert"); + + } catch (PersonalException e) { + System.out.println(e.getMessage()); + } + + } + + public static void testSaveMitarbeiter() { + System.out.println("+++++++++++++++++++++++ testSaveMitarbeiter +++++++++++++++++++++++++\n"); + + Personalbuero pb = new Personalbuero(); + System.out.println(pb); + System.out.println(); + + try { + pb.saveMitarbeiter(); + System.out.println("saveMitarbeiter() wurde ausgefuehrt"); + } catch (PersonalException e) { + System.out.println(e.getMessage()); + // e.printStackTrace(); + } + System.out.println(); + + try { + Angestellter a1 = new Angestellter("Alfred", 'm', Year.of(1977), Year.now()); + pb.aufnehmen(a1); + Freelancer f2 = new Freelancer("Anna", 'w', Year.of(1976), Year.of(2002), 100f, 10); // 1000 + pb.aufnehmen(f2); + + System.out.println(pb); // 2 MA: Angestellter Alfred, Freelancerin Anna + System.out.println(); + + pb.saveMitarbeiter(); + System.out.println("saveMitarbeiter() wurde ausgefuehrt"); + System.out.println(); + + System.out.println(pb); // 2 MA: Angestellter Alfred,, Freelancerin Anna + System.out.println(); + + } catch (PersonalException e) { + System.out.println(e.getMessage()); + } + + } + + public static void testLoadMitarbeiter() { + System.out.println("+++++++++++++++++++++++ testLoadMitarbeiter +++++++++++++++++++++++++\n"); + + try { + Personalbuero pb = new Personalbuero(); + + Freelancer f2 = new Freelancer("Adele", 'w', Year.of(1976), Year.of(2002), 100f, 10); // 1000 + pb.aufnehmen(f2); + System.out.println(pb); // // Adele + System.out.println(); + + pb.loadMitarbeiter(); + System.out.println("loadMitarbeiter() wurde ausgefuehrt"); + System.out.println(); + + System.out.println(pb); // 2 MA: Angestellter Alfred, Freelancerin Anna + System.out.println(); + + } catch (PersonalException e) { + System.out.println(e.getMessage()); + } + } + + public static void testKuendigeGehalt() { + try { + System.out.println("+++++++++++++++++++++++ testKuendigeGehalt +++++++++++++++++++++++++\n"); + + Personalbuero pb = new Personalbuero(); + System.out.println(pb); + System.out.println(); + + try { + System.out.println(pb.kuendigen(-1f)); + System.out.println(); + + } catch (PersonalException e) { + System.out.println(e.getMessage()); // Fehlermeldung + } + + // ein Mitarbeiter + Angestellter a1 = new Angestellter("Alfred", 'm', Year.of(1977), Year.now()); // 1500 + pb.aufnehmen(a1); + System.out.println(pb); // 1 MA: Angestellter Alfred + System.out.println(); + + System.out.println(pb.kuendigen(1500f)); // 0.0 + System.out.println(); + + // zwei Mitarbeiter + Freelancer f2 = new Freelancer("Anna", 'w', Year.of(1976), Year.of(2002), 100f, 10); // 1000 + pb.aufnehmen(f2); + System.out.println(pb); // 2 MA: Angestellter Alfred, Freelancer Anna + System.out.println(); + + System.out.println(pb.kuendigen(1500f)); // 0.0 + System.out.println(); + + System.out.println(pb); // 2 MA: Angestellter Alfred, Freelancer Anna + System.out.println(); + + // drei Mitarbeiter + Freelancer f3 = new Freelancer("Adi", 'w', Year.of(1996), Year.of(2022), 100f, 20); // 2000 + pb.aufnehmen(f3); + System.out.println(pb); // 3 MA: Angestellter Alfred, Freelancer Anna, Freelancer Adi + System.out.println(); + + System.out.println(pb.kuendigen(1999.9f)); // 2000.0 + System.out.println(); + + System.out.println(pb); // 2 MA: Angestellter Alfred, Freelancer Anna + System.out.println(); + + System.out.println(pb.kuendigen(999.9f)); // 2500.0 + System.out.println(); + + System.out.println(pb); // keine MA + System.out.println(); + + System.out.println(pb.kuendigen(-1f)); // Fehler negatives Gehalt + + } catch (PersonalException e) { + System.out.println("Fehler in testKuendigenGehalt(): " + e.getMessage()); + } + } + + public static void testKuendigeName() { + try { + System.out.println("+++++++++++++++++++++++ testkuendigeName +++++++++++++++++++++++++\n"); + + Personalbuero pb = new Personalbuero(); + System.out.println(pb); // keine MA + System.out.println(); + + try { + System.out.println(pb.kuendigen("")); // Fehler keine MA -1 + System.out.println(); + + } catch (PersonalException e) { + System.out.println(e.getMessage()); + } + + Angestellter a1 = new Angestellter("Elisa", 'w', Year.of(2000), Year.of(2020)); // Elisa 1600 + Freelancer f1 = new Freelancer("Alfred", 'm', Year.of(1980), Year.now(), 100f, 10); // Alfred 1000 + + System.out.println(pb.aufnehmen(a1)); // true Elisa + System.out.println(pb.aufnehmen(f1)); // true Alfred + System.out.println(pb); // zwei "Mitarbeiter": Elisa, Alfred + System.out.println(); + + System.out.println(pb.kuendigen("Anna")); // 0 + System.out.println(); + + System.out.println(pb); // zwei "Mitarbeiter": Elisa, Alfred + System.out.println(); + + Freelancer f2 = new Freelancer(100f, 10); // Berta 1000 + f2.setName("Berta"); + + System.out.println(pb.aufnehmen(f2)); // true Berta + System.out.println(pb); // drei "Mitarbeiter": Elisa, Alfred, Berta + System.out.println(); + + System.out.println(pb.kuendigen("Alfred")); // 1 + System.out.println(); + + System.out.println(pb); // zwei "Mitarbeiter": Elisa, Berta + System.out.println(); + + Angestellter a2 = new Angestellter("Berta", 'w', Year.of(1971), Year.now()); + System.out.println(pb.aufnehmen(a2)); // true Berta + + System.out.println(pb); // drei "Mitarbeiter": Elisa, Berta, Berta + System.out.println(); + + System.out.println(pb.kuendigen("Berta")); // 2 + System.out.println(); + + System.out.println(pb); // ein "Mitarbeiter": Elisa + System.out.println(); + + System.out.println(pb.kuendigen("Elisa")); // 1 + System.out.println(); + + System.out.println(pb); // keine MA + System.out.println(); + + } catch (PersonalException e) { + System.out.println(e.getMessage()); + } + } + + public static void testSortiereMitarbeiter() { + try { + System.out.println("+++++++++++++++++++++++ testSortiereMitarbeiter +++++++++++++++++++++++++\n"); + Personalbuero pb = new Personalbuero(); + System.out.println(pb); // keine MA + System.out.println(); + + pb.sortiereMitarbeiter(); // nichts sollte passieren + + System.out.println(pb); // keine MA + System.out.println(); + + Angestellter a2 = new Angestellter("Alfred", 'm', Year.of(1963), Year.of(2007)); + System.out.println(a2); + Freelancer f1 = new Freelancer("Eva", 'w', Year.of(1980), Year.of(2001), 100f, 15); + System.out.println(f1); + Freelancer f2 = new Freelancer("Heinz", 'm', Year.of(2002), Year.of(2022), 10f, 125); + System.out.println(f2); + Freelancer f3 = new Freelancer("Anna", 'w', Year.of(1990), Year.of(2007), 100f, 30); + System.out.println(f3); + Freelancer f4 = new Freelancer("Walter", 'm', Year.of(1980), Year.of(2002), 25f, 100); + System.out.println(f4); + System.out.println(); + + pb.aufnehmen(a2); + pb.aufnehmen(f1); + pb.aufnehmen(f2); + pb.aufnehmen(f3); + pb.aufnehmen(f4); + System.out.println(pb); // a2 2250, f1 1500, f2 1250 , f3 3000, f4 2500 + System.out.println(); + + pb.sortiereMitarbeiter(); + + System.out.println(pb); // f2 1250, f1 1500, a2 2250, f4 2500, f3 3000 + System.out.println(); + + } catch (PersonalException e) { + System.out.println(e.getMessage()); + } + } + + public static void testSortiereName() { + try { + System.out.println("+++++++++++++++++++++++ testSortiereName +++++++++++++++++++++++++\n"); + Personalbuero pb = new Personalbuero(); + System.out.println(pb); // keine MA + System.out.println(); + + pb.sortiereNamen(); // nichts sollte passieren + + System.out.println(pb); // keine MA + System.out.println(); + + Angestellter a2 = new Angestellter("Alfred", 'm', Year.of(1963), Year.of(2007)); + System.out.println(a2); + Freelancer f1 = new Freelancer("Eva", 'w', Year.of(1980), Year.of(2001), 100f, 15); + System.out.println(f1); + Freelancer f2 = new Freelancer("Heinz", 'm', Year.of(2002), Year.of(2022), 10f, 125); + System.out.println(f2); + Freelancer f3 = new Freelancer("Anna", 'w', Year.of(1990), Year.of(2007), 100f, 30); + System.out.println(f3); + Freelancer f4 = new Freelancer("Walter", 'm', Year.of(1980), Year.of(2002), 25f, 100); + System.out.println(f4); + System.out.println(); + + pb.aufnehmen(a2); + pb.aufnehmen(f1); + pb.aufnehmen(f2); + pb.aufnehmen(f3); + pb.aufnehmen(f4); + System.out.println(pb); // a2 Alfred, f1 Eva, f2 Heinz , f3 Anna, f4 Walter + System.out.println(); + + pb.sortiereNamen(); + + System.out.println(pb); // a2 Alfred, f3 Anna, f1 Eva, f2 Heinz, f4 Walter + System.out.println(); + + } catch (PersonalException e) { + System.out.println(e.getMessage()); + } + } + + public static void testSortiereAlter() // + { + try { + System.out.println("+++++++++++++++++++++++ testSortiereAlter +++++++++++++++++++++++++\n"); + Personalbuero pb = new Personalbuero(); + System.out.println(pb); // keine MA + System.out.println(); + + pb.sortiereAlter(); // nichts sollte passieren + + System.out.println(pb); // keine MA + System.out.println(); + + Angestellter a2 = new Angestellter("Alfred", 'm', Year.of(1963), Year.of(2007)); // 59 + System.out.println(a2); + Freelancer f1 = new Freelancer("Eva", 'w', Year.of(1980), Year.of(2001), 100f, 15); // 42 + System.out.println(f1); + Freelancer f2 = new Freelancer("Heinz", 'm', Year.of(2002), Year.of(2022), 10f, 125); // 20 + System.out.println(f2); + Freelancer f3 = new Freelancer("Anna", 'w', Year.of(1990), Year.of(2007), 100f, 30); // 32 + System.out.println(f3); + Freelancer f4 = new Freelancer("Walter", 'm', Year.of(1980), Year.of(2002), 25f, 100); // 42 + System.out.println(f4); + System.out.println(); + + pb.aufnehmen(a2); + pb.aufnehmen(f1); + pb.aufnehmen(f2); + pb.aufnehmen(f3); + pb.aufnehmen(f4); + System.out.println(pb); // a2 Alfred 59, f1 Eva 42, f2 Heinz 20 , f3 Anna 32 , f4 Walter 42 + System.out.println(); + + pb.sortiereAlter(); + + System.out.println(pb); // f2 Heinz 20, f3 Anna 32, f1 Eva 42, f4 Walter 42, a2 Alfred 59 + System.out.println(); + + } catch (PersonalException e) { + System.out.println(e.getMessage()); + } + } + + public static void testSortiereDienstalter() // + { + try { + System.out.println("+++++++++++++++++++++++ testSortiereDienstalter +++++++++++++++++++++++++\n"); + Personalbuero pb = new Personalbuero(); + System.out.println(pb); // keine MA + System.out.println(); + + pb.sortiereDienstalter(); // nichts sollte passieren + + System.out.println(pb); // keine MA + System.out.println(); + + Angestellter a2 = new Angestellter("Alfred", 'm', Year.of(1963), Year.of(2007)); // 15 + System.out.println(a2); + Freelancer f1 = new Freelancer("Eva", 'w', Year.of(1980), Year.of(2001), 100f, 15); // 21 + System.out.println(f1); + Freelancer f2 = new Freelancer("Heinz", 'm', Year.of(2002), Year.of(2022), 10f, 125); // 0 + System.out.println(f2); + Freelancer f3 = new Freelancer("Anna", 'w', Year.of(1990), Year.of(2007), 100f, 30); // 15 + System.out.println(f3); + Freelancer f4 = new Freelancer("Walter", 'm', Year.of(1980), Year.of(2002), 25f, 100); // 20 + System.out.println(f4); + System.out.println(); + + pb.aufnehmen(a2); + pb.aufnehmen(f1); + pb.aufnehmen(f2); + pb.aufnehmen(f3); + pb.aufnehmen(f4); + System.out.println(pb); // a2 Alfred 15, f1 Eva 21, f2 Heinz 0 , f3 Anna 15 , f4 Walter 20 + System.out.println(); + + pb.sortiereDienstalter(); + + System.out.println(pb); // f2 Heinz 0, a2 Alfred 15, f3 Anna 15, f4 Walter 20, f1 Eva 21 + System.out.println(); + + } catch (PersonalException e) { + System.out.println(e.getMessage()); + } + } +}