Frage zu Interfaces Bsp.

[PsychoStyle]

Schönen Tag, hab nen kleines Problem, wo ich nicht weiter komme und ich hoffe hier gibt es nen paar Programmierer, die lust und Zeit haben sich mit mir zu beschäftigen!

Also, meine Aufgabenstellung war es, ein Programm zuschreiben mit den Klassen Fahrzeug, Motorrad, PKW, Person, Fahrzeughalter und Test. Soweit sogut, Motorrad, PKW erben von Fahrzeug und Fahrzeughalter von Person. Legt man ein Fahrzeug oder einen Halter an, baut man im Konstruktor die Verbindung zum Fahrzeug / zum Halter auf und über Parameter des Konstruktor kann man Typ / Reifenanzahl und / oder Türenanzahl fest legen. Funktioniert alles prima, aber jetzt kommt der Teil, wo ich nicht weiter komme...

Teil 5: Aufgabe Fahrzeug und Fahrzeughalter
Teil a.)
Objekte der Klasse Fahrzeug sind eigentlich sinnlos. Das liegt daran, dass die Klasse
typerscherweise abstrakt zu definieren ist. Machen Sie die Klasse Fahrzeug abstrakt.
Es entfällt auch der Konstruktor. Der Konstruktor der Subklassen muß natürlich
bleiben.
Teil b.)
Lagern Sie alle Methoden der Klasse Fahrzeug in ein Interface aus und
implementieren Sie das Interface in ide Klasse Fahrzeug wieder.
Passen Sie die Anwendung entsprechend an

Ersteinmal der Code von den Klassen:

 public class Fahrzeug {
	private String typ;
	private int anzahlRäder;
	protected Fahrzeughalter halter;	
	
	  ////////////////////////////////////////////
	 //              Konstruktoren             //
	////////////////////////////////////////////
	
	//Konstruktor 1
	public Fahrzeug(Fahrzeughalter halter, int anzahlRäder)
	{
		this.halter = halter;					//Beziehung zum Halter aufbauen
		this.setAnzahlRäder(anzahlRäder);
		this.typ = "allgemeines Fahrzeug";
		halter.uebernimmt(this);				//Beziehung vom Halter zum Auto

	}
	
	  ////////////////////////////////////////////
	 //            Getter und Setter           //
	////////////////////////////////////////////
	public String getTyp() {
		return typ;
	}

	public void setTyp(String typ) {
		this.typ = typ;
	}

	public int getAnzahlRäder() {
		return anzahlRäder;
	}

	public void setAnzahlRäder(int anzahlRäder) {
		this.anzahlRäder = anzahlRäder;
	}
	

	 public String getHalter() {
		return halter.getVorname() + " "+ halter.getNachname();
	}

	public void setHalter(Fahrzeughalter halter) {
		this.halter = halter;
	}

	////////////////////////////////////////////
	 //                 toString               //
	////////////////////////////////////////////
	public String toString() {
		return typ + " mit " + anzahlRäder + " Rädern";
	}
}




public class Motorrad extends Fahrzeug{
	
	  ////////////////////////////////////////////
	 //          Standardkonstruktor           //
	////////////////////////////////////////////
	public Motorrad()
	{
		this.setAnzahlRäder(2);
		this.setTyp("Motorrad");
		halter.uebernimmt(this);				//Beziehung vom Halter zum Auto
	}
	
	public Motorrad(Fahrzeughalter halter)
	{
		this.setAnzahlRäder(2);
		this.setTyp("Motorrad");
		this.setHalter(halter);					//Beziehung vom Auto zum Halter
		halter.uebernimmt(this);				//Beziehung vom Halter zum Auto
	}
	
	
	  ////////////////////////////////////////////
	 //                toString                //
	////////////////////////////////////////////

	public String toString() {
		return super.toString();		
	}
	
}




public class PKW extends Fahrzeug {

	private int anzahlTüren;

	  ////////////////////////////////////////////
	 //             Konstruktoren              //
	////////////////////////////////////////////
	
	// Standardkonstruktor
	public PKW() {
		this.setAnzahlRäder(4);
		this.setTyp("PKW");
	}

	// Konstruktor 1
	public PKW(int anzahlTüren) {
		this.setAnzahlTüren(anzahlTüren);
		this.setAnzahlRäder(4);
		this.setTyp("PKW");
		halter.uebernimmt(this);				//Beziehung vom Halter zum Auto
	}

	// Konstruktor 2
	public PKW( Fahrzeughalter halter, int anzahlRäder, int anzahlTüren) {
		this.setAnzahlTüren(anzahlTüren);
		this.setAnzahlRäder(anzahlRäder);
		this.setTyp("PKW");
		this.setHalter(halter);
		halter.uebernimmt(this);				//Beziehung vom Halter zum Auto
	}

	  ////////////////////////////////////////////
	 //            Getter und Setter           //
	////////////////////////////////////////////
	public void setAnzahlTüren(int anzahlTüren) {
		this.anzahlTüren = anzahlTüren;
	}

	public int getAnzahlTüren() {
		return anzahlTüren;
	}
	
	  ////////////////////////////////////////////
	 //                toString                //
	////////////////////////////////////////////
	public String toString() {
		return super.toString() +"und " + anzahlTüren + " Türen";
	}
}




public class Person {
	private String vorname;
	private String nachname;
	
	  ////////////////////////////////////////////
	 //             Konstruktoren              //
	////////////////////////////////////////////
	
	//Standardkonstruktor
	public Person(){
		
	}
	
	//Konstruktor 1
	public Person(String vorname, String nachname)
	{
		this.vorname = vorname;
		this.nachname = nachname;
	}
	
	  ////////////////////////////////////////////
	 //           Getter und Setter            //
	////////////////////////////////////////////
	public String getVorname() {
		return vorname;
	}

	public void setVorname(String vorname) {
		this.vorname = vorname;
	}

	public String getNachname() {
		return nachname;
	}

	public void setNachname(String nachname) {
		this.nachname = nachname;
	}
	
	  ////////////////////////////////////////////
	 //               toString                 //
	////////////////////////////////////////////
	public String toString()
	{
		return  vorname+ nachname;
	}
}




public class Fahrzeughalter extends Person {
	
	private Fahrzeug f;
	
	  ////////////////////////////////////////////
	 //             Konstruktoren              //
	////////////////////////////////////////////
	public Fahrzeughalter(String vorname, String nachname){
		this.setVorname(vorname);
		this.setNachname(nachname);
	}
	
	public void uebernimmt(Fahrzeug f){
		this.f = f;
	}

	public Fahrzeug getFahrzeug() {
		return f;
	}

}




public class Test {
	public static void main(String[] args) {
		
		Fahrzeughalter[ ] fzh = new Fahrzeughalter[ ] { new Fahrzeughalter("Riese ",
		"Goliath"), new Fahrzeughalter("Berti ","Vogts"), new Fahrzeughalter("Uwe ",
		"Seeler")};
		Fahrzeug[ ] fz = new Fahrzeug [ ] { new Fahrzeug(fzh[0],16),
		new PKW(fzh[1],4,5),
		new Motorrad(fzh[2])};
		for(int i = 0; i < fzh.length; i++)
		{
		System.out.println("Das Fahrzeug von " + fzh[i] + " ist ein "+
		fzh[i].getFahrzeug()+".");
		}
		for(int i = 0; i < fzh.length; i++)
		{
		System.out.println("Das Fahrzeug ist ein " + fz[i] + ".");
		System.out.println("Es gehört " + fz[i].getHalter()+".");
		}
	}
}

Okay, und mein Problem ist nun, ich versteh nicht wie ich das mit dem Interface realisieren soll?
Wenn ich ein Interface mit den Methoden von Fahrzeug erstelle und dieses implementiere bin ich ja dazu gezwungen in PKW und Motorrad die ganzen Getter / Setter neu zuschreiben, da man ja in diesen dann auch die Methoden des Interfaces braucht, oder? Wie würdet ihr das am besten machen?

 

[Marco13]

Die Klassen können dann alle von der Klasse "AbstractFahrzeug" erben.

 

[PsychoStyle]

Ja, aber sie erben dann doch auch das Interface mit? Also... dass sie auch den Aufbau des Interfaces benötigen, mit den Methoden, oder? Dann müsste man ja die ganzen Methoden aus Fahrzeug jeweils in PKW / Motorrad kopieren und Fahrzeug wär eigentl. ziemlich sinnlos. Hab ich da nen Denkfehler?

 

[Michael...]

Wenn ich ein Interface mit den Methoden von Fahrzeug erstelle und dieses implementiere bin ich ja dazu gezwungen in PKW und Motorrad die ganzen Getter / Setter neu zuschreiben, ...

Nein. Aufgabenstellung ist alle Methoden(rümpfe) aus der Klasse Fahrzeug in ein Interface aus zulagern. Die abstrakte Klasse Fahrzeug implementiert dieses Interface.
Einzelne Methoden werden dabei konkret implementiert anderer abstract --> alle von Fahrzeug erbenden Klassen müssen nur noch die abstrakten Methoden implementieren.

 

[PsychoStyle]

Gut, danke! Ich versuch mich mal dran.

Also, wenn eine Klasse von einer Klasse erbt, die ein Interface implementiert hat, wird das Interface nicht weitervererbt? ^^

 

[Michael...]

Also, wenn eine Klasse von einer Klasse erbt, die ein Interface implementiert hat, wird das Interface nicht weitervererbt? ^^

Doch, dadurch dass die Superklasse das Interface implementiert, wird es auch an die Kindklassen indirekt weiter"vererbt".
Wenn das Interface in der Superklasse bereits konkret implementiert ist, müssen das die Kindklassen nicht noch einmal tun. Das ist ja dann eine gewöhnliche Vererbung.

 

[PsychoStyle]

Doch, dadurch dass die Superklasse das Interface implementiert, wird es auch an die Kindklassen indirekt weiter"vererbt".

Ja aber genau das ist ja mein Problem, denn wenn das Interface weitervererbt wird, muss ich in PKW / Motorrad nun die Methoden schreiben, die vorher nur in Fahrzeug waren und ich benutzen konnte, da sie vererbt wurden und nun brauchen die Klassen die Methoden auch, da sie sich ja an die Struktur des Interfaces halten?!

The type Motorrad must implement the inherited abstract method FahrzeugInterface.Fahrzeug(Fahrzeughalter, int)
Quick fix: add unimplemented Methods

Tut mir leid, wenn ich mich gerade dumm anstelle...

 

[Michael...]

In folgendem Bsp. werden im Interface drei Methode definiert. Die abstrakte Klasse implementiert dieses Interface. (Da sie abstract ist muss sie aber die Methoden nicht unbedingt implementieren)
Die Methode setName(...) wird konkret implementiert, setMethode2(...) wird gar nicht implementiert und setMethode3(...) wird als abstract Methode implementiert (macht jetzt nicht unbedingt Sinn).

Die Klasse Motorrad (erbt von Fahrzeug) kann (ohne eigene Implementierung) die Methode setName(...) verwenden, muss aber die beiden anderen Methoden, die von Fahrzeug nicht bzw. nur abstract implementiert wurden, selbst implementieren.

interface FahrzeugInterface {
	public void setName(String name);
	public void setMethode2(String some);
	public void setMethode3(String some);
}

abstract class Fahrzeug implements FahrzeugInterface {
	private String name;
	
	public void setName(String name) {
		this.name = name;
	}
	
	public abstract void setMethode3(String some);
}

class Motorrad extends Fahrzeug {
	public void setMethode2(String some) {
		// TODO ...
	}

	@Override
	public void setMethode3(String some) {
		// TODO ...
	}
}

 

[PsychoStyle]

Verstanden, vielen Dank!

 

[PsychoStyle]

Geht alles, super, danke!