# Abrechnung für Mitarbeiter



## JavaBeginner77 (1. Mai 2006)

Wer von euch kann mir bei der Aufgabe weiterhelfen? Wie fange ich am besten an? ???:L 


Aufgabe : Implementieren Sie folgende Klassen. Beachten Sie dabei Ihre Beziehungen untereinander. Definieren
Sie für jede Klasse mindestens zwei zusätzliche Attribute.
Schreiben Sie für jede Klasse einen Konstruktor, der die Attributwerte initialisiert.


Mitarbeiter:
grundgehalt = Grundgehalt eines Mitarbeiters
dauerInJahren = Zeit in Jahren, die ein Mitarbeiter bereits in einer Firma tätig ist.
urlaubstage = Die Urlaubstage eines Mitarbeiters in einem Jahr.
berechneGehalt():

Diese Methode berechnet das Gehalt eines Mitarbeiters. Das Gehalt entspricht dabei dem Grundgehalt.
berechneResturlaub():
Die Methode berechnet den Resturlaub eines Mitarbeiters. Übergeben werden die bereits verwendeten
Urlaubstage.

Facharbeiter:
berechneGehalt():
Diese Methode berechnet das Gehalt eines Facharbeiters. Die Formel zur Berechnung lautet:
Grundgehalt + (Alter+Zugehörigkeit zu der Firma in Jahren)*10
Achtung: Ist der Mitarbeiter über 40 Jahre, bleibt der Faktor Alter bei der Berechnung konstant auf 40.


Abteilungsleiter:
berechneProvision():
Diese Methode berechnet die Provision eines Abteilungsleiters. Es wird die Anzahl der abgeschlossenen
Verträge übergeben.
Die Formel lautet:
Grundgehalt * Provisionsfaktor
Seite 1
Anzahl der abgeschlossenen Verträge Provisionsfaktor
1 2
0.2
3 5
0.3
ab 5 0.4
berechneGehalt():
Diese Methode berechnet das Gehalt eines Abteilungsleiters. Die Formel zur Berechnung lautet:
Grundgehalt + (Alter+Zugehörigkeit zu der Firma in Jahren)*10 + Provision
Achtung: Ist der Mitarbeiter über 40 Jahre, bleibt der Faktor Alter bei der Berechnung konstant auf 40.


----------



## dR.LoL (1. Mai 2006)

Hi,
mhm Schulaufgabe? ;-)



			
				JavaBeginner77 hat gesagt.:
			
		

> Wer von euch kann mir bei der Aufgabe weiterhelfen? Wie fange ich am besten an? ???:L



Was ist den das Problem, anhand der 'Aufgabenstellung' steht ja schon alles +/- strukturiert da... Wo hast du probleme beim Umsetzen?

Vieleicht hilft es dir ein UML zu erstellen, damit du alles schöner/übersichtlicher dargestellt hast...

Oder wie genau ist deine Frage 'Wie ich am besten anfange' gemeint?
-> Klassen erstellen
-> Methoden
-> Variablen

Methoden/Variablen sind ja die wichtigsten schon beschrieben...


----------



## JavaBeginner77 (1. Mai 2006)

Mich verwirren die Klassen leider immer weiß auch nicht, als ich die Aufgabe gelesen habe, setzte wieder mal alles auf Parnik bei mir... :autsch:


----------



## dR.LoL (1. Mai 2006)

WAS verwirrt dich daran?
WO liegt das problem?
Unterrichten von A-Z würde Geld kosten und ich wäre bestimmt NICHT der geeignete Lehrer mit meinen bisherigen auch nicht grossen Java Kentnissen!


----------



## JavaBeginner77 (5. Mai 2006)

In der Aufgabe muß ich ja mit verscheidenen Klassen arbeiten, muß ich dann auf die Vererbung zurück greifen?? Oder benötige ich das bei der Aufgabe gar nicht? :?


----------



## Gast (7. Mai 2006)

hm, Mitarbeiter als Oberklasse und dann, Facharbeiter und Abteilungsleiter davon ableiten.

Wäre ne sinnvolle Möglichkeit, denk ich.

MfG, Ash


----------



## JavaBeginner77 (8. Mai 2006)

Gibt es nicht eventuell irgendwo ein Beispiel, wo ich sehen kann wie die Verknüpfungen unter den Klassen sind?Und wie ich die Methoden am besten hineinbastel, die in der Aufgabenstellung enthalten sind??!! Ich habe bisher nur die einzelnen Klassen erstmal erstellt...

Mitarbeiter: 
grundgehalt = Grundgehalt eines Mitarbeiters 
dauerInJahren = Zeit in Jahren, die ein Mitarbeiter bereits in einer Firma tätig ist. 
urlaubstage = Die Urlaubstage eines Mitarbeiters in einem Jahr. 
berechneGehalt(): 

Diese Methode berechnet das Gehalt eines Mitarbeiters. Das Gehalt entspricht dabei dem Grundgehalt. 
berechneResturlaub(): 
Die Methode berechnet den Resturlaub eines Mitarbeiters. Übergeben werden die bereits verwendeten 
Urlaubstage. 

Facharbeiter: 
berechneGehalt(): 
Diese Methode berechnet das Gehalt eines Facharbeiters. Die Formel zur Berechnung lautet: 
Grundgehalt + (Alter+Zugehörigkeit zu der Firma in Jahren)*10 
Achtung: Ist der Mitarbeiter über 40 Jahre, bleibt der Faktor Alter bei der Berechnung konstant auf 40. 


Abteilungsleiter: 
berechneProvision(): 
Diese Methode berechnet die Provision eines Abteilungsleiters. Es wird die Anzahl der abgeschlossenen 
Verträge übergeben. 
Die Formel lautet: 
Grundgehalt * Provisionsfaktor 
Seite 1 
Anzahl der abgeschlossenen Verträge Provisionsfaktor 
1 2 
0.2 
3 5 
0.3 
ab 5 0.4 
berechneGehalt(): 
Diese Methode berechnet das Gehalt eines Abteilungsleiters. Die Formel zur Berechnung lautet: 
Grundgehalt + (Alter+Zugehörigkeit zu der Firma in Jahren)*10 + Provision 
Achtung: Ist der Mitarbeiter über 40 Jahre, bleibt der Faktor Alter bei der Berechnung konstant auf 40.


----------



## JavaBeginner77 (12. Mai 2006)

Kann mir keiner von euch weiter helfen ??


----------



## Sebastian_NameBelegt (13. Mai 2006)

JavaBeginner77 hat gesagt.:
			
		

> Kann mir keiner von euch weiter helfen ??



Ich habe mal etwas zusammengeschrieben.

Es existiert eine abstrakte Klasse (UnternehmensAngestellte).
Drei Klassen (Mitarbeiter, Facharbeiter, Abteilungsleiter) * erben von der Klasse und definieren Ihre eigene Methode zur Berechnung des Gehalts.

* Zusätzlich haben die Klasse Facharbeiter und Abteilungsleiter noch eine eigene abstrakte Oberklasse, FuehrungsKraft.
Diese definiert eine Methode zur Berechnung eines Gehaltzuschusses, je nach Alter und Länge der Zugehörigkeit


UnternehmensAngestellte
|
--> Mitarbeiter
|
-->FuehrungsKraft
--|--> Facharbeiter
--|--> Abteilungsleiter

Hinzu kommt eine Klasse ( Unternehmen ), die die einzelnen Instanzen erzeugt.

Alles befindet sich zusätzlich in einem Package (Unternehmen).



```
package Unternehmen;

import java.util.Calendar;
import java.util.Date;

/**
 * Die abstrakte Klasse [i]UnternehmensAngestellte[/i] dient als
 * Vorlage für konkrete Klassen.
 * Sie kann selber <u>nicht</u>, wegen [b]abstract[/b], direkt benutzt werden.
 * 


 * (Es gibt ja auch keine allgemeinen Unternehmensangestellte,
 * sondern jeder hat irgendeine Stellung im Unternehmen und daher
 * hat jede Ansammlung von mehreren Tätigkeiten eine Berufsbezeichnung)
 * 


 * Die Klasse bietet Eigenschaften und Methoden an mit denen man 
 * den Namen, das Geburtsdatum, das Alter, das Grundgehalt, das Eintrittsdatum 
 * im Unternehmen, und die Länge der Zugehörigkeit zum Unternehmen
 * eines Mitarbeiters abfragen kann.
 * 


 * @author Sebastian
 * @version 1.0
 */
public abstract class UnternehmensAngestellte {
	
	/**
	 * Name des Mitarbeiters
	 */
	private String name;
	
	/**
	 * Datum des Geburtstages
	 */
	private Date geburtstag;
		
	/**
	 * Hoehe des Grundgehaltes
	 */
	private double grundGehalt;
	
	/**
	 * Datum beim Eintritt in das Unternehmen
	 */
	private Date eintrittsDatum;
	
	/**
	 * Anzahl der noch verbleibenen Urlaubsttage
	 */
	private int urlaubsTage;
	
	/**
	 * Mitarbeitertype
	 */
	private String typ;
	
	/**
	 * Setzt die Anfangswert eines Mitarbeites.
	 * 
	 * @param name Name des Mitarbeites
	 * @param gDatum Geburtsdatum als String in Form von tt.mm.yyyy
	 * @param gehalt Das Grundgehalt des Mitarbeites
	 * @param eDatum Das Einstellungsdatum in Form von tt.mm.yyyy
	 * @param uTage Anzahl der Urlaubstage
	 */	
	UnternehmensAngestellte(String name, String gDatum, double gehalt, String eDatum, int uTage, String typ) {
		setzeName(name);
		setzeGehalt(gehalt);				
		setzeUrlaubsTage(uTage);
		setzeGeburtstag(gDatum);
		setzeEintrittsJahr(eDatum);
		setzeMitarbeiterTyp(typ);
	}
	
	/**
	 * Setzt den Name des Mitarbeiters.
	 * 
	 * @param pName Name des Mitarbeites
	 */
	private void setzeName(String pName) {
		name = pName;
	}
	
	/**
	 * Gibt den Namen des Mitarbeites zurück.
	 * 
	 * @return <code>name</code> Name des Mitarbeites
	 */
	public String holeName() {
		return name;
	}
	
	/**
	 * Setzt das Geburtsdatum des Mitarbeiters.
	 * 
	 * @param datum Datum als String in Form von tt.mm.yyyy
	 */
	private void setzeGeburtstag(String datum){ 
		geburtstag = setzeDatum(datum);	
	}
	
	/**
	 * Gibt das Geburtsdatum zurück.
	 * 
	 * @return <code>geburtstag</code> Geburtsdatum als Typ Date
	 */
	public Date holeGeburtstag() {
		return geburtstag;
	}
	
	/**
	 * Gibt das Alter des Mitarbeiters in Jahren zurück.
	 * 
	 * @return <code>berechneJahre(geburtstag)</code> Alter in Jahren
	 */
	public int holeAlter() {
		return berechneJahre(geburtstag);
	}
	
	/**
	 * Setzt das Eintrittsdatum des Mitarbeiters im Unternehmen.
	 * 
	 * @param datum Datum als String in Form von tt.mm.yyyy
	 */
	private void setzeEintrittsJahr(String datum) {
		eintrittsDatum = setzeDatum(datum);
	}
	
	/**
	 * Gibt das Datum des Eintritts ins Unternehmen zurück.
	 * 
	 * @return <code>eintrittsDatum</code> Geburtsdatum als Typ [i]Date[/i]
	 */
	public Date holeEintrittsDatum() {
		return eintrittsDatum;
	}
	
	/**
	 * Die die Anzahl der Jahre seit Eintritt im Unternehmen zurück.
	 * 
	 * @return <code>berechneJahre(eintrittsDatum)</code> Unternehmenszugehörigkeit in Jahren
	 */
	public int holeMitgliedsJahre() {
		return berechneJahre(eintrittsDatum);
	}
	
	/**
	 * Setzt das Grundgehalt eines Mitarbeiters.
	 * 
	 * @param gehalt Gehalt als Typ [i]double[/i]
	 */
	public void setzeGehalt(double gehalt) {
		grundGehalt = gehalt;
	}
	
	/**
	 * Gibt das berechnete Gehalt zurück.

	 * Wird von den erbenden Klassen überschrieben.
	 * 
	 * @return Gehalt als Type [i]double[/i]
	 */
	public abstract double berechneGehalt();
	
	/**
	 * Gibt das Grundgehalt eines Mitarbeiters zurück.
	 * 
	 * @return <code>grundGehalt</code> Grundgehalt als Type [i]double[/i]
	 */
	public double holeGrundGehalt() {
		return grundGehalt;
	}
	
	/**
	 * Setzt die Anzahl der Urlaubstage eines Mitarbeiters.
	 * 
	 * @param tage Tage als Typ [i]int[/i]
	 */
	public void setzeUrlaubsTage(int tage) {
		urlaubsTage = tage;
	}
	
	/**
	 * Aktualisiert die Anzahl der Urlaubstage, wenn der Mitarbeiter Urlaub nimmt.

	 * Wirft eine Exception wenn versucht wird zuviele Urlaubstage zu nehmen.
	 * 
	 * @param tage Anzahl der Tage als Typ [i]int[/i]
	 * @throws Exception
	 */
	public void nehmeUrlaub(int tage) throws Exception {
		if(berechneResturlaub() >= tage) {
			setzeUrlaubsTage(berechneResturlaub() - tage);
		} else {
			throw new Exception ( holeName() + " du dummer " + holeMitarbeiterTyp() + "! Soviele Urlaubstage hast du nicht mehr!");
		}
	}
	
	/**
	 * Gibt die Anzahl der restlichen Urlaubstage zurück.
	 * 
	 * @return <code>urlaubsTage</code> restliche Urlaubstage als Typ [i]int[/i]
	 */
	public int berechneResturlaub() {
		return urlaubsTage;
	}
	
	/**
	 * Ordnet dem Mitarbeiter einen bestimmten Typ zu.
	 * 
	 * @param mTyp Mitarbeitertyp vom Typ [i]String[/i]
	 */
	private void setzeMitarbeiterTyp(String mTyp) {
		typ = mTyp;
	}
	
	/**
	 * Gibt den Typ des Mitarbeiters zurück.

	 * z.B. die Stellung des Mitarbeiters.
	 * 
	 * @return <code>typ</code> Mitarbeitertyp als Typ [i]String[/i]
	 */
	public String holeMitarbeiterTyp() {
		return this.typ;
	}
	
	/*
	 * @see java.lang.Object#toString()
	 */
	public abstract String toString();	
	
	/**
	 * Erstellt ein Date Objekt aus dem übergebenen String (tt.mm.yyyy).
	 * 
	 * @param datum Datum als String in Form von tt.mm.yyyy
	 * @return Datum Objekt als Typ [i]Date[/i]
	 */
	private Date setzeDatum(String datum) {
		StringBuilder st = new StringBuilder(datum);
		
		int findex = st.indexOf(".");
		int lindex = st.lastIndexOf(".");
		
		int tag = Integer.valueOf(st.subSequence(0, findex).toString());
		int monat = Integer.valueOf(st.subSequence(findex+1, lindex).toString())-1;
		int jahr = Integer.valueOf(st.subSequence(lindex+1, st.length()).toString());
		
		Calendar c = Calendar.getInstance();
		c.set(jahr, monat, tag);
		
		return c.getTime();
	}
	
	/**
	 * Berechnet die Jahre zwischen dem übergebenen Date Objekt
	 * und dem jetzigen Zeitpunkt.
	 * 
	 * @param datum Datum als Typ [i]Date[/i]
	 * @return Jahre als Typ [i]int[/i]
	 */
	private int berechneJahre(Date datum) {
		Calendar c = Calendar.getInstance();
		c.setTime(datum);
		
		Calendar now = Calendar.getInstance();
		int tag = now.get(Calendar.DAY_OF_MONTH);
		int monat = now.get(Calendar.MONTH);
		int jahr = now.get(Calendar.YEAR);
		
		if(monat > c.get(Calendar.MONTH) || ( monat == c.get(Calendar.MONTH) && tag >= c.get(Calendar.DAY_OF_MONTH) ) ) {
			return (int) jahr - c.get(Calendar.YEAR);
		} else {
			return (int) jahr - c.get(Calendar.YEAR) - 1;
		}
	}
}
```


```
package Unternehmen;

/**
 * Die konkrete Klasse Mitarbeiter erbt von der abstrakten Klasse 
 * UnternehmensAngestellte die Eigenschaften und Methode.
 * 


 * -> Die Klasse Mitarbeiter definiert einen eigenen Mitarbeitertyp.

 * -> Die Klasse Mitarbeiter definiert Ihre eigene Methode für das Berechnen 
 * vom Gehalt. Dabei wird einfach auf die Methode <code>holeGrundGehalt()</code>
 * verwiesen.

 * -> Die Klasse Mitarbeiter überschreibt die Methode <code>toString()</code>.

 * 
 * @author Sebastian
 * @version 1.0
 */
public class Mitarbeiter extends UnternehmensAngestellte{
	
	/**
	 * Mitarbeitertype
	 * Typ ist Mitarbeiter 
	 */
	private static String typ = "Mitarbeiter";
	
	/**
	 * Setzt die Anfangswert eines Mitarbeites.
	 * Übergebe die Werte an den Konstruktor der Elternklasse.
	 * 
	 * @param name Name des Mitarbeites
	 * @param gDatum Geburtsdatum als String in Form von tt.mm.yyyy
	 * @param gehalt Das Grundgehalt des Mitarbeites
	 * @param eDatum Das Einstellungsdatum in Form von tt.mm.yyyy
	 * @param uTage Anzahl der Urlaubstage
	 */	
	Mitarbeiter(String name, String gDatum, double gehalt, String eDatum, int uTage) {
		super(name, gDatum, gehalt, eDatum, uTage, typ);
	}
	
	/**
	 * Gibt das Gehalt eines Mitarbeiters vom Typ 'Mitarbeiter' zurück
	 * Das berechnete Gehalt unterscheidet sich nicht vom Grundgehalt
	 * 
	 * @return Gehalt vom Typ [i]double[/i]
	 * @see UnternehmensAngestellte
	 */
	public double berechneGehalt() {
		return holeGrundGehalt();
	}
	

	/**
	 * Überschreibt die toString() Methode von der Elternklasse
	 * Gibt eine Zusammenfassung zurück
	 * 
	 * @return Zusammenfassung vom Typ [i]String[/i]
	 * @see UnternehmensAngestellte
	 */
	public String toString() {
		return holeName() + ", "+ holeMitarbeiterTyp() +", " + holeAlter() + " Jahre alt, arbeitet seit " 
		+ holeMitgliedsJahre() + " Jahren hier.\nGehalt: " + berechneGehalt() 
		+ "\nübriger Jahresurlaub: " + berechneResturlaub();
	}
}
```


```
package Unternehmen;

/**
 * Die Klasse Fuehrungskraft stellte für alle Führungskräfte
 * die Methode <code>berechneZuschuss()</code> zur Verfügung.
 * 
 * @author Sebastian
 * @version 1.0
 */
public abstract class FuehrungsKraft extends UnternehmensAngestellte {

	/**
	 * Setzt die Anfangswert eines Mitarbeites.
	 * Übergebe die Werte an den Konstruktor der Elternklasse.
	 * 
	 * @param name Name des Mitarbeites
	 * @param gDatum Geburtsdatum als String in Form von tt.mm.yyyy
	 * @param gehalt Das Grundgehalt des Mitarbeites
	 * @param eDatum Das Einstellungsdatum in Form von tt.mm.yyyy
	 * @param uTage Anzahl der Urlaubstage
	 */	
	FuehrungsKraft(String name, String gDatum, double gehalt, String eDatum, int uTage, String typ) {
		super(name, gDatum, gehalt, eDatum, uTage, typ);
	}

	/**
	 * Errechnet den Zuschuss für eine Fuehrungskraft
	 * Berücksichtigt bei der Berechung wird das Alter und die
	 * Länge der Zugehörigkeit.
	 * 
	 * @return Zuchuss vom Typ [i]double[/i]
	 */
	public double berechneZuschuss() {
		int faktor = holeAlter() <= 40 ? holeAlter() : 40;
		int zuschuss = (faktor + holeMitgliedsJahre()) * 10;
		
		return zuschuss;
	}
}
```


```
package Unternehmen;

/**
 * Die konkrete Klasse Facharbeiter erbt von der abstrakten Klasse 
 * UnternehmensAngestellte die Eigenschaften und Methode.
 * 


 * -> Die Klasse Facharbeiter definiert einen eigenen Mitarbeitertyp.

 * -> Die Klasse Facharbeiter definiert Ihre eigene Methode für das Berechnen 
 * vom Gehalt. Zusätzlich zum Grundgehalt bekommt ein Facharbeiter einen Zuschuss.
 * Dieser wird in der Methode <code>berechneZuschuss()</code> berechnet

 * -> Die Klasse Facharbeiter überschreibt die Methode <code>toString()</code>.

 * 
 * @author Sebastian
 * @version 1.0
 */
public class Facharbeiter extends FuehrungsKraft{
	
	/**
	 * Mitarbeitertype
	 * Typ ist Facharbeiter 
	 */
	private static String typ = "Facharbeiter";
	
	/**
	 * Setzt die Anfangswert eines Mitarbeites.
	 * Übergebe die Werte an den Konstruktor der Elternklasse.
	 * 
	 * @param name Name des Mitarbeites
	 * @param gDatum Geburtsdatum als String in Form von tt.mm.yyyy
	 * @param gehalt Das Grundgehalt des Mitarbeites
	 * @param eDatum Das Einstellungsdatum in Form von tt.mm.yyyy
	 * @param uTage Anzahl der Urlaubstage
	 */	
	Facharbeiter(String name, String gDatum, double gehalt, String eDatum, int uTage) {
		super(name, gDatum, gehalt, eDatum, uTage, typ);
	}

	/**
	 * Gibt das Gehalt eines Mitarbeiters vom Typ 'Facharbeiter' zurück.
	 * Das berechnete Gehalt unterscheidet sich vom Grundgehalt.
	 * 
	 * Es fließt der Zuschuss noch ein.
	 * 
	 * @return Gehalt vom Typ [i]double[/i]
	 * @see UnternehmensAngestellte
	 */
	public double berechneGehalt() {		
		return holeGrundGehalt()+berechneZuschuss();
	}
	
	/**
	 * Überschreibt die toString() Methode von der Elternklasse
	 * Gibt eine Zusammenfassung zurück
	 * 
	 * @return Zusammenfassung vom Typ [i]String[/i]
	 * @see UnternehmensAngestellte
	 */
	public String toString() {
		return holeName() + ", "+ holeMitarbeiterTyp() +", " + 
holeAlter() + " Jahre alt, arbeitet seit " + 
holeMitgliedsJahre() + " Jahren hier." + 
		"\nGehalt: " + berechneGehalt() + 
		"\nGehalt setzt sich aus " + holeGrundGehalt() + 
" Grundgehalt und "+ berechneZuschuss() + 
" Zuschuss zusammen." +
		"\nübriger Jahresurlaub: " + berechneResturlaub();
	}
}
```


```
package Unternehmen;

/**
 * Die konkrete Klasse Abteilungsleiter erbt von der abstrakten Klasse 
 * UnternehmensAngestellte die Eigenschaften und Methode.
 * 


 * -> Die Klasse Abteilungsleiter definiert einen eigenen Mitarbeitertyp.

 * -> Die Klasse Abteilungsleiter definiert Ihre eigene Methode für das Berechnen 
 * vom Gehalt. Zusätzlich zum Grundgehalt bekommt ein Abteilungsleiter eine Provision und einen Zuschuss.
 * Die Provision wird in der Methode <code>berechneProvision()</code> berechnet.
 * Der Zuschuss wird in der Methode <code>berechneZuschuss()</code> berechnet

 * -> Die Klasse Abteilungsleiter überschreibt die Methode <code>toString()</code>.

 * 
 * @author Sebastian
 * @version 1.0
 */
public class Abteilungsleiter extends FuehrungsKraft{
	/**
	 * Anzahl der Auftraege die der Abteilungsleiter abgeschlossen hat
	 */
	private int auftraege = 0;
	
	/**
	 * Mitarbeitertype
	 * Typ ist Abteilungsleiter 
	 */
	private static String typ = "Abteilungsleiter";
	
	/**
	 * Setzt die Anfangswert eines Mitarbeites.
	 * Übergebe die Werte an den Konstruktor der Elternklasse.
	 * 
	 * @param name Name des Mitarbeites
	 * @param gDatum Geburtsdatum als String in Form von tt.mm.yyyy
	 * @param gehalt Das Grundgehalt des Mitarbeites
	 * @param eDatum Das Einstellungsdatum in Form von tt.mm.yyyy
	 * @param uTage Anzahl der Urlaubstage
	 */	
	Abteilungsleiter(String name, String gDatum, double gehalt, String eDatum, int uTage) {
		super(name, gDatum, gehalt, eDatum, uTage, typ);
	}

	/**
	 * Gibt das Gehalt eines Mitarbeiters vom Typ 'Abteilungsleiter' zurück.
	 * Das berechnete Gehalt unterscheidet sich vom Grundgehalt.
	 * 
	 * Es wird je nach Anzahl von Vertragsabschluessen eine Provision gezahlt
	 * die sich am Grundgehalt orientiert.
	 * 
	 * @return Gehalt vom Typ [i]double[/i]
	 * @see UnternehmensAngestellte
	 */
	public double berechneGehalt() {
		// TODO Auto-generated method stub
		return holeGrundGehalt() + berechneZuschuss() + berechneProvision();
	}
	
	/**
	 * Berechnet anhand der Anzahl, der abgeschlossenen Auftraege
	 * die Hoehe der Provision
	 * 
	 * @return Provision als Typ [i]double[/i]
	 */
	public double berechneProvision() {
		double faktor = 0;
		
		switch (holeAuftragAnzahl()) {
			case 1:
			case 2:
					faktor = 0.2;
					break;
			
			case 3:
			case 4:
			case 5:
					faktor = 0.3;
					break;
			
			default:
					faktor = 0.4;
					break;
		}
		
		return holeGrundGehalt() * faktor;
	}
	
	/**
	 * Fügt neue Auftraege hinzu
	 * 
	 * @param anzahl Anzahl der neuen Auftraege
	 */
	public void neueAuftraege(int anzahl) {
		auftraege = holeAuftragAnzahl() + anzahl;
	}
	
	/**
	 * Gibt die Anzahl der Aufträge zurück
	 * 
	 * @return <code>auftraege</code> Anzahl der Auftraege
	 */
	public int holeAuftragAnzahl() {
		return auftraege;
	}

	/**
	 * Überschreibt die toString Methode von der Elternklasse
	 * Gibt eine Zusammenfassung zurück
	 * 
	 * @return Zusammenfassung vom Typ [i]String[/i]
	 * @see UnternehmensAngestellte
	 */
	public String toString() {
		return holeName() + ", "+ holeMitarbeiterTyp() +", " + 
holeAlter() + " Jahre alt, arbeitet seit " + holeMitgliedsJahre() + 
" Jahren hier." + "\nGehalt: " + berechneGehalt() + 
"\nGehalt setzt sich aus " + holeGrundGehalt() + 
" Grundgehalt, " + berechneZuschuss() + 
" Zuschuss und "+ berechneProvision() + "
 Provision, bei " + holeAuftragAnzahl() + 
" abgeschlossenen Auftraegen, zusammen." +
		"\nübriger Jahresurlaub: " + berechneResturlaub();
	}
}
```


```
package Unternehmen;

public class Unternehmen {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		try {
			
			Mitarbeiter m1 = new Mitarbeiter("Hans", "13.05.1969", 2100.55, "04.06.1995", 26);
			m1.nehmeUrlaub(5);
			m1.nehmeUrlaub(3);
			
			//
			
			Facharbeiter f1 = new Facharbeiter("Franz", "07.08.1963", 2900.57, "10.12.1983", 31);
			f1.nehmeUrlaub(16);
			f1.nehmeUrlaub(8);
			
			//
			
			Abteilungsleiter a1 = new Abteilungsleiter("Herbert", "01.002.1955", 4300.39, "08.03.1971", 34);
			a1.nehmeUrlaub(16);
			a1.nehmeUrlaub(12);
			
			a1.neueAuftraege(2);
			a1.neueAuftraege(1);
			
			//
			
			System.out.println(m1 + "\n");
			System.out.println(f1 + "\n");
			System.out.println(a1 + "\n");
			
		} catch (Exception e) {
			System.out.println(e);
		}
		
	}

}
```


Als Ausgabe erscheint dann:


```
Hans, Mitarbeiter, 37 Jahre alt, arbeitet seit 10 Jahren hier.
Gehalt: 2100.55
übriger Jahresurlaub: 18

Franz, Facharbeiter, 42 Jahre alt, arbeitet seit 22 Jahren hier.
Gehalt: 3520.57
Gehalt setzt sich aus 2900.57 Grundgehalt und 620.0 Zuschuss zusammen.
übriger Jahresurlaub: 7

Herbert, Abteilungsleiter, 51 Jahre alt, arbeitet seit 35 Jahren hier.
Gehalt: 6340.5070000000005
Gehalt setzt sich aus 4300.39 Grundgehalt, 750.0 Zuschuss und 1290.117 Provision, bei 3 abgeschlossenen Auftraegen, zusammen.
übriger Jahresurlaub: 6
```


Bei etwaigen Fragen und Verbesserungsvorschlägen stehe ich zur Verfügung.
Ich bin selber ein blutiger Anfänger, also habt Nachsicht.

cu Sebastian


----------



## JavaBeginner77 (14. Mai 2006)

Ich habe ein Verständisproblem in dem Abschnitt


```
private Date setzeDatum(String datum) { 
	      StringBuilder st = new StringBuilder(datum); 
	       
	      int findex = st.indexOf("."); 
	      int lindex = st.lastIndexOf("."); 
	 
	      int tag = Integer.valueOf(st.subSequence(0, findex).toString()); 
	      int monat = Integer.valueOf(st.subSequence(findex+1, lindex).toString())-1; 
	      int jahr = Integer.valueOf(st.subSequence(lindex+1, st.length()).toString());       
	      Calendar c = Calendar.getInstance(); 
	      c.set(jahr, monat, tag); 
	       
	      return c.getTime(); 
	   }
```

Warum gibt er mir da die Fehlermeldung aus, dass er "cannot invert from Integer to int"



Die Fhelermeldungen in der Konsole:

Exception in thread "main" java.lang.Error: Unresolved compilation problems: 
	The operator - is undefined for the argument type(s) Integer, int
	The method set(int, int) in the type Calendar is not applicable for the arguments (Integer, int, Integer)

	at Unternehmen.UnternehmensAngestellte.setzeDatum(UnternehmensAngestellte.java:243)
	at Unternehmen.UnternehmensAngestellte.setzeGeburtstag(UnternehmensAngestellte.java:96)
	at Unternehmen.UnternehmensAngestellte.<init>(UnternehmensAngestellte.java:67)
	at Unternehmen.Mitarbeiter.<init>(Mitarbeiter.java:35)
	at Unternehmen.Unternehmen.main(Unternehmen.java:11)


----------



## Sebastian_NameBelegt (14. Mai 2006)

Versuche dann mal mit 
	
	
	
	





```
parseInt
```
 anstatt 
	
	
	
	





```
valueOf
```
.
Oder du versuchst es als *int* zu casten.

Aber bei mir funzt es auch so. Ich nutze Java 5.


----------



## Sebastian_NameBelegt (14. Mai 2006)

Versuche dann mal mit 
	
	
	
	





```
parseInt
```
 anstatt 
	
	
	
	





```
valueOf
```
.
Oder du versuchst es als *int* zu casten.

Aber bei mir funzt es auch so. Ich nutze Java 5.

Sonst ist das auch nicht der wichtigste Teil. Du kannst es auch weglassen, dann musst du halt anstatt einen String ein Date Objekt direkt als Einstellungs- bzw. Geburtsdatum übergeben.


----------



## JavaBeginner77 (14. Mai 2006)

funzt !!! DANKE!

dann ist also ValueOf erst ab Java 5  drin?!


----------



## Guest (14. Mai 2006)

JavaBeginner77 hat gesagt.:
			
		

> funzt !!! DANKE!
> 
> dann ist also ValueOf erst ab Java 5  drin?!



Hier klicken für die Antwort


----------

