Konstruktoren und Vererbung

[Lukases2]

Aufgabe:
Aufgabe: Verwaltung von Immobilien
Als Erweiterung der objektorientierten Programmierung haben Sie letzte Woche das Konzept der
Konstruktoren und die Vererbung von Klassen kennengelernt. Mit diesen neuen Möglichkeiten
können Sie nun folgendes Problem effizient lösen:
Es sollen eine Vielzahl von verschiedenen Immobilien verwaltet werden, die grundsätzlich alle
folgende Eigenschaften erfüllen:

UML:
Immobilie
-----------------------
- ort : String
- flaeche : double
- mieter : String
- preis : int
-----------------------
+ Immobilie(ort : String, flaeche : double, preis : int)
+ setMieter(mieter : String) : void
+ getMieter() : String
+ setMietpreis(preis : int) : void
+ getMietpreis() : int
+ getOrt() : String
+ getWohnflaeche() : double


Es werden zwei verschiedene Arten von Immobilien vermietet:
Zunächst für Privatpersonen der Typ Wohnung, der eine Immobilie mit dem zusätzlichen Attribut
wohnflaeche ist. Außerdem auch der Typ Betreiberimmobilie für gewerbliche Zwecke, welche eine
Immobilie mit dem zusätzlichen Attribut zusatzkosten ist.
Implementieren Sie die Klasse Immobilie wie oben beschrieben und entwerfen Sie die beiden
Klassen Wohnung und Betreiberimmobilie so kompakt wie möglich.
Gegeben sind folgende Daten:
Ort: Köln, Fläche: 160.5, Wohnfläche: 120, Preis: 4870, Zusatzkosten: 2100
Testen Sie Ihr Programm in einer Klasse Verwaltung, indem Sie einmal ein Objekt vom Typ
Wohnung und ein Objekt vom Typ Betreiberimmobilie anlegen. Fügen Sie außerdem jeweils einen
Mieter hinzu.

Folgendes habe ich dazu geschrieben:

package eightpack;

public class Immobilie {
	
	public String ort;
	public double flaeche;
	public String mieter;
	public int preis;
	public int zusatzkosten;
	
	public void setMieter(String mieter){}
	
	public String getMieter(){
		return mieter;
	}
	
	//Mieter
	
	public void setMietpreis(int preis){}
	
	public int getMietpreis(){
		return preis;
	}
	
	//Preis
	
	public void setOrt(String ort){}
	
	public String getOrt(){
		return ort;
	}
	
	public void setZusatzkosten(int zusatzkosten){}
	
	public int getZusatzkosten(){
		return zusatzkosten;
	}
	
	//Zusatzkosten
	
	public void setFlaeche(double flaeche){}
	
	public double getWohnflaeche(){
		return flaeche;
	}
	
	//Fläche
}

und

package eightpack;

public class Verwaltung {
	
	public static void main(String[] args){
		
		Immobilie betreiberimmobilie = new Immobilie();
		betreiberimmobilie.setOrt("Köln");
		betreiberimmobilie.setFlaeche(160.5);
		betreiberimmobilie.setMietpreis(4870);
		betreiberimmobilie.setZusatzkosten(2100);
		
		Immobilie wohnung = new Immobilie();
		
	}
}

Meine Fragen dazu:
- "So kompakt wie möglich" heißt vermutlich: "Benutzen Sie Vererbung/Konstruktoren". Wie kann ich das einbringen?
- Wenn ich "+ Immobilie(ort : String, flaeche : double, preis : int)" kann ich nicht implementieren, weil die Klasse schon
so heißt. Was soll ich also da machen?

 

[Saheeda]

Kann es sein, dass mit "+ Immobilie(ort : String, flaeche : double, preis : int)" ein Konstruktor gemeint ist?
Ich habe zwar schon häufiger mit Klassendiagrammen gearbeitet, aber diese Schreibweise habe ich noch nicht gesehen.

Laut Aufgabe sollst du zwei Klassen "Wohnung" und "Betreiberimmobilie" entwerfen, die von Immobilie erben. Bisher hast du nur ein Objekt vom Typ Immobilie namens "wohnung".

 

[Lukases2]

Diese Art von Klassendiagramm ist gemeint.
So sieht mein Code jetzt aus:

package eightpack;

public class Immobilie {
	
	public String ort;
	public double flaeche;
	public String mieter;
	public int preis;
	
	
	public Immobilie(String ort, double flaeche, int preis){}
	
	public void setMieter(String mieter){
	}
	
	public String getMieter(){
		return mieter;
	}
	
	public void setMietpreis(int preis){
	}
	
	public int getMietpreis(){
		return preis;
	}
	
	public String getOrt(){
		return ort;
	}
	
	public double getWohnflaeche(){
		return flaeche;
	}
}

package eightpack;

public class Wohnung extends Immobilie {
	
	public double wohnflaeche;
	
	public Wohnung(String ort, double flaeche, int preis, int wohnflaeche){
		super(ort, flaeche, preis);
		this.wohnflaeche = wohnflaeche;
	}
}

package eightpack;

public class Betreiberimmobilie extends Immobilie {
	
	public int zusatzkosten;
	
	public Betreiberimmobilie(String ort, double flaeche, int preis, int zusatzkosten){
		super(ort, flaeche, preis);
		this.zusatzkosten = zusatzkosten;
	}
}

package eightpack;

public class Verwaltung {
	
	public static void main(String[] args){
	
		Immobilie s1 = new Immobilie();
		
	}
}

In der Klasse "Verwaltung" bekomme ich jetzt den Fehler: "The constructor Immobilie() is undefined". Warum? Ich habe das doch sonst auch so machen können.

 

[Saheeda]

Jup, mir war schon bewusst, dass du von UML-Klassendiagrammen redest, ich hab nur noch nie gesehen, dass dort auch Konstruktoren verzeichnet werden.

Jede Klasse besitz den Default-Konstruktor "public Klassenname(){}". Indem du einen eigenen definierst, überschreibst du diesen. Deine Klasse Immobilien besitzt jetzt also nur noch diesen Konstruktor, aber keinen parameterlosen.
btw ist dien Immobilien-Konstruktor ziemlich sinnfrei, du machst mit den übergebenen Parametern nix.

 

[Joose]

In der Klasse "Verwaltung" bekomme ich jetzt den Fehler: "The constructor Immobilie() is undefined". Warum? Ich habe das doch sonst auch so machen können.

Wie Saheeda schon sagte, die Klasse Immobilie hat keinen parameterlosen Konstruktor mehr.
Die Aufgabe lautet:

Testen Sie Ihr Programm in einer Klasse Verwaltung, indem Sie einmal ein Objekt vom Typ
Wohnung und ein Objekt vom Typ Betreiberimmobilie anlegen. Fügen Sie außerdem jeweils einen
Mieter hinzu.

Sprich du sollst ein Objekt vom Typ Wohnung bzw. Betreiberimmobilie machen nicht aber von Immobilie.

Jup, mir war schon bewusst, dass du von UML-Klassendiagrammen redest, ich hab nur noch nie gesehen, dass dort auch Konstruktoren verzeichnet werden.

Klar in dem UML Diagramm sollte man natürlich auch festlegen können mit welchen Parametern ein Konstruktor aufgerufen werden kann, bzw. welche Konstruktoren nur für die Klasse selber interessant sind

 

[Lukases2]

Das gleiche passiert auch hier:

package eightpack;

public class Verwaltung {
	
	public static void main(String[] args){
		
		Wohnung w1 = new Wohnung();
		
	}
}

Ich habe noch nicht ganz verstanden, warum diese Fehlermeldung kommt.

 

[Lukases2]

Update: ich habe jetzt noch eine Klasse "Mieter" hinzugefügt:

package eightpack;

public class Mieter {
	
	public String mieter;
	
	public void setMieter(String mieter){}
	
	public String getMieter(){
		return mieter;
	}
}

und meine "Verwaltung" sieht jetzt so aus:

package eightpack;

public class Verwaltung {
	
	public static void main(String[] args){
		
		Wohnung w = new Wohnung("Köln", 160.5, 4870, 1000);
		
		Mieter m = new Mieter();
		m.setMieter("Ralf Beispiel");
	}
}

Jetzt habe ich noch nicht ganz verstanden, wie ich das testen soll. Was soll ich mir denn da jetzt anzeigen lassen?

@ alle, die evtl. ähnliche Probleme mit Konstruktoren haben, wie ich: Diese Seite erklärt das ziemlich gut.

 

[Joose]

Ich habe noch nicht ganz verstanden, warum diese Fehlermeldung kommt.

Jede Klasse muss min. 1 Konstruktor haben. Dafür gibt es den parameterlosen Defaultkonstruktor.
Dieser muss nicht extra definiert werden sondern existiert bei jeder Klasse.

Wird aber von dir ein Konstruktor (mit Parametern) definiert "existiert" der Defaultkonstruktor nicht mehr.
Definierst du einen Konstruktor ohne Parameter "überschreibt" dein parameterloser Konstruktor den Defaultkonstruktor.

Update: ich habe jetzt noch eine Klasse "Mieter" hinzugefügt:

Den Mieter solltest du wohl noch zu deiner Immobilie hinzufügen.
Bzw. fehlt dir die 2.Immobilie, laut Aufgabestellung sollst du in der Verwaltung 2 Objekte anlegen.

Jetzt habe ich noch nicht ganz verstanden, wie ich das testen soll. Was soll ich mir denn da jetzt anzeigen lassen?

Dass kann dir leider nur die Aufgabenstellung bzw. deren Verfasser beantworten