From da54018cad4aa58db7bef22e019edefaffce21b8 Mon Sep 17 00:00:00 2001 From: unknown Date: Tue, 29 Mar 2022 13:24:14 +0200 Subject: [PATCH] initial commit --- src/model/AlterComparator.java | 21 ++ src/model/Angestellter.java | 40 +++ src/model/Arzt.java | 72 ++++ src/model/DienstalterComparator.java | 28 ++ src/model/Freelancer.java | 116 +++++++ src/model/GehaltBerechenbar.java | 14 + src/model/Mitarbeiter.java | 194 +++++++++++ src/model/NameComparator.java | 45 +++ src/model/PersonalException.java | 16 + src/model/Personalbuero.java | 444 +++++++++++++++++++++++++ src/model/PersonalbueroException.java | 34 ++ src/model/PraemieBerechenbar.java | 18 + src/module-info.java | 2 + src/test/TestAngestellter.java | 40 +++ src/test/TestArzt.java | 66 ++++ src/test/TestFreelancer.java | 69 ++++ src/test/TestMitarbeiter.java | 51 +++ src/test/TestMitarbeiter_EH.java | 116 +++++++ src/test/TestPersonalbuero.java | 363 ++++++++++++++++++++ src/test/TestPersonalbueroMain.java | 455 ++++++++++++++++++++++++++ 20 files changed, 2204 insertions(+) create mode 100644 src/model/AlterComparator.java create mode 100644 src/model/Angestellter.java create mode 100644 src/model/Arzt.java create mode 100644 src/model/DienstalterComparator.java create mode 100644 src/model/Freelancer.java create mode 100644 src/model/GehaltBerechenbar.java create mode 100644 src/model/Mitarbeiter.java create mode 100644 src/model/NameComparator.java create mode 100644 src/model/PersonalException.java create mode 100644 src/model/Personalbuero.java create mode 100644 src/model/PersonalbueroException.java create mode 100644 src/model/PraemieBerechenbar.java create mode 100644 src/module-info.java create mode 100644 src/test/TestAngestellter.java create mode 100644 src/test/TestArzt.java create mode 100644 src/test/TestFreelancer.java create mode 100644 src/test/TestMitarbeiter.java create mode 100644 src/test/TestMitarbeiter_EH.java create mode 100644 src/test/TestPersonalbuero.java create mode 100644 src/test/TestPersonalbueroMain.java diff --git a/src/model/AlterComparator.java b/src/model/AlterComparator.java new file mode 100644 index 0000000..519f335 --- /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..7f0fef0 --- /dev/null +++ b/src/model/Angestellter.java @@ -0,0 +1,40 @@ +package model; + +import java.time.Year; +/** + * Klasse Angestellter + * + * @author (WES) + * @version (2022-03-18) + * + * umgestellt auf Exception-Handling + */ +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); + } + + @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(); + } + +} diff --git a/src/model/Arzt.java b/src/model/Arzt.java new file mode 100644 index 0000000..1f123ff --- /dev/null +++ b/src/model/Arzt.java @@ -0,0 +1,72 @@ +package model; + +import java.time.Year; +/** + * Klasse Arzt + * + * @author (WES) + * @version (2022-03-18) + * + * umgestellt auf Exception-Handling + */ +public class Arzt extends Mitarbeiter implements GehaltBerechenbar +{ + private static final long serialVersionUID = 2022_03_22__13_15L; + private int wochenStunden; + private float fixum; + + 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 + ")"); + } + + 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; + } + + // public void printInfo() // zum Testen + // { + // System.out.println(this); + // } + + public String toString() + { + return "Arzt: " + + super.toString() + + ", Wochenstunden: " + wochenStunden + + ", Fixum: " + fixum; + } + +} diff --git a/src/model/DienstalterComparator.java b/src/model/DienstalterComparator.java new file mode 100644 index 0000000..410ff6b --- /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..3b9ee71 --- /dev/null +++ b/src/model/Freelancer.java @@ -0,0 +1,116 @@ +package model; + +// 2022-03-22 4BAIF +// umgestellt auf Exception-Handling +// mit serialVersionUID fuer Serialisierung + +import java.time.Year; +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 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."; + } + + 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..2925ca6 --- /dev/null +++ b/src/model/Mitarbeiter.java @@ -0,0 +1,194 @@ +package model; + +import java.io.Serializable; + +// 2022-03-21 4BAIF +// Klasse abstract +// Methode berechneGehalt() abstract +// 2022-01-26: Debugging toString() - mit ?-Operator gefixt +// Interface Comparable + +// Umstellung auf EH + +import java.time.Year; +import java.util.Comparator; + +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); + } + + // ------------------------------------ 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) !!!"); + } + + // -------------------------------------- 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; + } + } + + public void print() { + System.out.println(this); // System.out.println(toString()) + } + + public String toStringCsv() { + char sep = ';'; // Delimiter + + StringBuilder sb = new StringBuilder(); + + sb.append(getClass().getSimpleName()).append(sep); + sb.append(name).append(sep); + sb.append(gesch).append(sep); + sb.append(gebJahr).append(sep); + sb.append(eintrJahr).append(sep); + + return sb.toString(); + } +} diff --git a/src/model/NameComparator.java b/src/model/NameComparator.java new file mode 100644 index 0000000..69d9dee --- /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..97ec46d --- /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..9b6b444 --- /dev/null +++ b/src/model/Personalbuero.java @@ -0,0 +1,444 @@ +package model; + +import java.io.BufferedWriter; +import java.io.FileInputStream; +import java.io.FileNotFoundException; +import java.io.FileOutputStream; +import java.io.FileWriter; +import java.io.IOException; +import java.io.ObjectInputStream; +import java.io.ObjectOutputStream; + +// 2022-03-25 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 + +import java.util.ArrayList; +import java.util.Collections; +import java.util.Iterator; +import java.util.List; + +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(); + // } + // -------------------------------- 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; + return mitarbeiter.add(ma); // liefert immer true + // 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; + } + } + + // --------------------------------- files ---------------------------------- + + 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"; + + 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() throws PersonalException { + + String fSep = System.getProperty("file.separator"); + // String strPfadName = "c:\\scratch\\mitarbeiter.ser"; + String strPfadName = "c:" + fSep + "scratch" + fSep + "mitarbeiter.ser"; + + 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() throws PersonalException { + + String fSep = System.getProperty("file.separator"); + String strPfadName = "c:" + fSep + "scratch" + fSep + "mitarbeiter.txt"; + 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); + } + bw.write(sb.toString()); + } catch (IOException e) { + throw new PersonalException("Eingabe/Ausgabe-Fehler bei exportMitarbeiter()" + 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/PersonalbueroException.java b/src/model/PersonalbueroException.java new file mode 100644 index 0000000..5c6a4f0 --- /dev/null +++ b/src/model/PersonalbueroException.java @@ -0,0 +1,34 @@ +package model; + +public class PersonalbueroException extends Exception { + +// public PersonalbueroException() { +// // TODO Auto-generated constructor stub +// } + + /** + * "Versionnumber" of class + */ + private static final long serialVersionUID = 2022_03_18_12_50L; + + public PersonalbueroException(String message) { + super(message); + } + +// public PersonalbueroException(Throwable cause) { +// super(cause); +// // TODO Auto-generated constructor stub +// } +// +// public PersonalbueroException(String message, Throwable cause) { +// super(message, cause); +// // TODO Auto-generated constructor stub +// } +// +// public PersonalbueroException(String message, Throwable cause, boolean enableSuppression, +// boolean writableStackTrace) { +// super(message, cause, enableSuppression, writableStackTrace); +// // TODO Auto-generated constructor stub +// } + +} 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/module-info.java b/src/module-info.java new file mode 100644 index 0000000..0473c04 --- /dev/null +++ b/src/module-info.java @@ -0,0 +1,2 @@ +module Personalbuero { +} \ No newline at end of file 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/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/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..734a883 --- /dev/null +++ b/src/test/TestPersonalbueroMain.java @@ -0,0 +1,455 @@ +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(); + + testExport(); + + } 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 testExport() { + 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); + + System.out.println(pb); // Alfred, Anna + System.out.println(); + + pb.exportMitarbeiterCsv(); + System.out.println("exportMitarbeiterCsv() wurde ausgefuehrt"); + } + catch (PersonalException e) + { + System.out.println("!!! Fehler bei TestExport !!!" +nLn+ e.getMessage()); + } + } + + 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(); + + // ein Mitarbeiter + Angestellter a1; + try { + a1 = new Angestellter("Alfred", 'm', Year.of(1977), Year.now()); + pb.aufnehmen(a1); + System.out.println(pb); // 1 MA: Angestellter Alfred + System.out.println(); + + pb.saveMitarbeiter(); + System.out.println("saveMitarbeiter() wurde ausgefuehrt"); + System.out.println(); + + System.out.println(pb); // 1 MA: Angestellter Alfred + 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("Anna", 'w', Year.of(1976), Year.of(2002), 100f, 10); // 1000 + pb.aufnehmen(f2); + System.out.println(pb); // // Anna + System.out.println(); + + pb.loadMitarbeiter(); + System.out.println("loadMitarbeiter() wurde ausgefuehrt"); + System.out.println(); + + System.out.println(pb); // 1 MA: Angestellter Alfred + 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()); + } + } +}