So kannst du einem Konstruktor im Java Programm ein Objekt übergeben
Du kannst deinen Java Konstruktoren auch Objekte übergeben.
Bisher haben wir in der Parameterliste lediglich primitive Datentypen übergeben.
So sah das aus.
public class ThisReferenz {
int nummer;
public ThisReferenz(int nummer) {
this.nummer = nummer;//Zuweisung mit this
}
public static void main(String[] args) {
ThisReferenz ersteReferenz = new ThisReferenz(22);
System.out.println(ersteReferenz.nummer);
}
}Du hast eine Klasse mit einem Konstruktor.
Dieser bekommt beim Aufruf ein Argument (in diesem Fall 22) übergeben.
Dann weist der Konstruktor im Rumpf diesen Argumentwert der Instanzvariable zu.
Fertig.
Inhalt
So kannst du einem Konstruktor ein Objekt übergeben
Legen wir einen zweiten Konstruktor für die Java Klasse an.
Und dieser soll jetzt das erste Objekt als Argument übergeben bekommen.
So geht’s
public class ThisReferenz {
int nummer;
public ThisReferenz(int nummer) {
this.nummer = nummer;//Zuweisung mit this
}
public ThisReferenz(ThisReferenz erstelltesObjekt){ //Konstruktor erwartet Objekt
this.nummer=erstelltesObjekt.nummer;
}
public static void main(String[] args) {
ThisReferenz ersteReferenz = new ThisReferenz(22);
ThisReferenz zweiteReferenz = new ThisReferenz(ersteReferenz);//zweites Objekt
System.out.println(ersteReferenz.nummer);
System.out.println(zweiteReferenz.nummer);//Ausgabe der Instanzvariablen
}
}Du kannst einen zweiten Java Konstruktor anlegen und somit den ersten überladen.
Du kannst dann dem zweiten Konstruktor ein Objekt in der Parameterliste übergeben.
Das Objekt ist eigentlich eine Variable vom Datentyp der Klasse.
In diesem Fall ist der Datentyp „ThisReferenz“.
Den Namen der Variable kannst du frei wählen.
Im Rumpf des Konstruktors kannst du dann die Zuweisung mit dem Keyword this vornehmen.
Wichtig dabei ist, dass du dich dann auf die Referenzvariable beziehst, welche du in der Parameterliste übergeben hast.
this.nummer=erstelltesObjekt.nummer;
Natürlich kannst du zum Objekt weitere lokale Variablen übergeben
Lass uns rechnen.
Wir übergeben einem dritten Konstruktor noch eine lokale Variable vom Datentyp Integer.
Und diese lokale Variable wird dann mit der Instanzvariablen multipliziert.
Und so sieht es dann aus.
public class ThisReferenz {
int nummer;
public ThisReferenz(int nummer) {
this.nummer = nummer;//Zuweisung mit this
}
public ThisReferenz(ThisReferenz erstelltesObjekt, int faktor){ //Konstruktor erwartet Objekt und lokale Variable
this.nummer=erstelltesObjekt.nummer*faktor;//Instanzvariable wird vor der Zuweisung multipliziert
}
public static void main(String[] args) {
ThisReferenz ersteReferenz = new ThisReferenz(22);
ThisReferenz zweiteReferenz = new ThisReferenz(ersteReferenz, 2);//zweites Objekt
System.out.println(ersteReferenz.nummer);
System.out.println(zweiteReferenz.nummer);//Ausgabe der Instanzvariablen
}
}Und das ganze am Beispiel eines linearen Umsatzplanes.
Es wäre doch schön, wenn Umsätze planbar wären.
Planbar sind diese….
Aber meistens geht der Plan nicht auf.
Dennoch müssen sämtliche Unternehmen Business- oder Budgetpläne anfertigen.
Und so einen Umsatzplan möchte ich auch anfertigen.
In diesem Zusammenhang möchte ich dir zeigen, wie du deinen Java Konstruktoren ein Objekt übergibst.
Die Ausgangslage unseres fiktiven Unternehmens ist relativ überschaubar.
Wir setzen eine Umsatzsteigerung von 5.000 Euro je Monat voraus.
Ach, wenn es doch so einfach wäre
Und so stelle ich mir das ganze vor.
Wir haben in einer Klasse zwei Konstruktoren.
Der erste Konstruktor verarbeitet zwei Instanzvariablen.
Den Umsatz und den entsprechenden Monat.
Der zweite Konstruktor verarbeitet ein bereits bestehendes Objekt.
Er nimmt also Objekt 1 und addiert 5000 Euro Umsatz hinzu.
Den Monatswert erhöht der Konstruktor um eins.
Machen wir, oder?
Also entwirf eine Klasse „AbsatzPlan“ mit zwei Instanzvariablen
Die Variable „monatAbsatz“ speichert den jeweiligen Monat als Zahl.
Die zweite Variable „planAbsatz“ speichert den Umsatz.
Der erste Konstruktor erwartet zwei Argumente (Monat und Absatz) und weist diese Werte den Instanzvariablen zu.
Der zweite Konstruktor erwartet ein Objekt.
Und dann erhöht der Konstruktor die Instanzvariablen entsprechend.
Die entsprechenden Werte der Instanzvariablen lasse ich mir über eine Instanzmethode ausgeben.
Und diese Methode rufe ich direkt in beiden Konstruktoren auf.
Und so sieht der Umsatzplan für Januar bis April aus.
public class AbsatzPlan {
int monatAbsatz; //Monat als Zahl
double planAbsatz; //Umsatz in Euro
public AbsatzPlan(int monatAbsatz, double planAbsatz){
this.monatAbsatz=monatAbsatz; //Zuweisung des Monates
this.planAbsatz=planAbsatz; //Zuweisung des Absatzes
gibInfos(); //Aufruf der Methode
}
public AbsatzPlan (AbsatzPlan planObjekt){
this.monatAbsatz=planObjekt.monatAbsatz+1; //Zuweisung des Monates und Erhöhung um eins
this.planAbsatz=planObjekt.planAbsatz+5000; //Zuweisung des Absatzes und Erhöhung um 5000
gibInfos(); //Aufruf der Methode
}
void gibInfos(){ //Methode gibt Infos zu den Instanzvariablen
System.out.println("Für den Monat "+monatAbsatz+" plane ich "+planAbsatz+" Euro.");
}
public static void main(String[] args) {
AbsatzPlan jan = new AbsatzPlan (1,1000); //Startmonat mit Aufruf des ersten Konsstruktors
AbsatzPlan feb = new AbsatzPlan(jan); //dem zweiten Konstruktor wird das erste Objekt übergeben
AbsatzPlan mrz = new AbsatzPlan(feb); //dem zweiten Konstruktor wird das zweite Objekt übergeben
AbsatzPlan apr = new AbsatzPlan(mrz);
}
}Zusammenfassung:
- Neben primitiven Datentypen kannst du einem Konstruktor auch ein Objekt übergeben.
- Implementiere einfach einen Konstruktor, welcher in seiner Parameterliste ein Objekt erwartet.
- Innerhalb des Konstruktorrumpfes kannst du die Instanzvariablen zuweisen oder die Werte sogar verändern.
Über den Autor
