Klassenhirarchien zur Implementierung von Fahrzegen

[coldstone]

Hallo liebe Freunde,

hätte einige Ansatzschwierigkeiten mit der folgenden Aufgabe.

"Entwerfen Sie eine Klassenhierarchie zur Implementierung von Fahrzeugen.
Es soll eine abstrakte Oberklasse Fahrzeug geben. Davon abgeleitet sind die konkreten Klassen
Auto, Fahrrad, Schiff und Segler.
Ihre Klassen sollen von folgendem Java-Code ohne Modifikationen verwendet werden k¨onnen:

Fahrzeug[] fahrzeuge = { new Auto(), new Fahrrad(), new Schiff(),new Segler() };
for (int i = 0; i < fahrzeuge.length; i++) {
Fahrzeug fz = fahrzeuge[i];
System.out.println(fz + " wird angetrieben von: " + fz.antrieb()
+ "; " + fz + " " + fz.bewegung());
}

Dabei sollen die folgenden Ausgaben produziert werden:

Auto wird angetrieben von: Motor; Auto faehrt
Fahrrad wird angetrieben von: Mensch; Fahrrad faehrt
Schiff wird angetrieben von: Motor; Schiff schwimmt
Segler wird angetrieben von: Wind; Segler schwimmt

Entwerfen Sie für dieses Szenario eine sinnvolle Klassenhierarchie mit allen ben¨otigten Methoden."

Meine überlegung wäre:

Fahrzeug[] fahrzeuge = { new Auto(), new Fahrrad(), new Schiff(),
new Segler() };

Auto(), Fahrrad(), Schiff() und Segler() als Klassen zu erzeugen. (Zumindest zwingt mich eclipse dazu) :bahnhof:

Meine Hauptklasse sehe dann so aus:

public abstract class Fahrzeug {
	
	
	

	public static void main (String[] args) {
		
		Fahrzeug[] fahrzeuge = { new Auto(), new Fahrrad(), new Schiff(),new Segler() };
				for (int i = 0; i < fahrzeuge.length; i++) {
				Fahrzeug fz = fahrzeuge[i];
				System.out.println(fz + " wird angetrieben von: " + fz.antrieb()
				+ "; " + fz + " " + fz.bewegung());
				}
			}

	public Fahrzeug bewegung() {


		// TODO Auto-generated method stub
		return null;
	}

	public Fahrzeug antrieb() {
		// TODO Auto-generated method stub
		return null;
	}
}

Meine Klasse Auto:

public class Auto extends Fahrzeug {
	
	
public static void main(String[] args) {
		
		System.out.println("Auto");
	}

}

Zumindest bekomme ich jetzt in der Ausgabe:

Auto@45bab50a wird angetrieben von: null; Auto@45bab50a null

Woher kommen diese buchstaben und zahlen nach "Auto"? ICh kriege sie nicht weg.

 

[HimBromBeere]

Deine abstrakte Klasse hat mit der static main nichts zu tun (genau wie die ableitenden Klassen), deshalb raus damit. Die static main darf im Programm nur einmal auftauchen und fungiert als Eintrittspunkt für dein Programm. Die solltest du also in eine neue Klasse auslagern und von da aus deine ganzen Fahrzeuge erstellen.

Die beiden in der Klasse Fahrzeug deklarierten Funktionen antrieb() und bewegung() müssen abstrakt sein und in den ableitenden Klassen überschrieben werden. Darin wird dann die Ausgabe gemacht (z.B.

return "Motor"

oder

return "fährt"

 

[Gonzo17]

Du hast da grundlegende Prinzipien der Vererbung nicht verstanden.

Ziel ist es doch, dass die Methoden antrieb() und bewegung() einen Text zurückgeben, der abhängig davon ist, welches Objekt du gerade fragst. Also erstellst du die abstrakte Oberklasse Fahrzeug mit zwei abstrakten Methoden, sodass jede Unterklasse gezwungen wird, die Methoden zu implementieren.

Was du machst, ist folgendes. Du hast eine Klasse Fahrzeug, die NICHT abstrakt ist (erste Anforderung, die du umsetzen sollst laut Aufgabe) und in dieser die beiden Methoden (auch nicht abstrakt). In der Unterklasse Auto überschreibst du die Methoden nicht, weshalb sie, wie zuvor definiert, null liefern. Stattdessen (und das ist auch fehlendes Verständnis) hast du eine main-Methode, die effektiv aber nie aufgerufen wird und das soll sie auch nicht, weil sie einfach falsch ist.

Du solltest vielleicht mal ein paar einfache Tutorials machen, die genau solche einfache OOP zeigen.

 

[coldstone]

Mich irritiert nur in der aufgabenstellung dieser Satz: "Es soll eine abstrakte Oberklasse Fahrzeug geben. Davon abgeleitet sind die konkreten Klassen"! Deswegen bin ich davon ausgegangen das es eine abstrakte Klasse sen muss.

 

[HimBromBeere]

Was du machst, ist folgendes. Du hast eine Klasse Fahrzeug, die NICHT abstrakt ist (erste Anforderung, die du umsetzen sollst laut Aufgabe) und in dieser die beiden Methoden (auch nicht abstrakt)

Ööööööhm, also meines Verständnisses nach IST die Klasse Fahrzeug die abstrakte Oberklasse mit den abstrakten Methoden antrieb() und bewegung()

EDIT: Oooh, tschuldigung, hab den Satz falsch interpretiert... ignorier meinen Beitrag einfach

EDITcoldstone

Davon abgeleitet sind die konkreten Klassen"! Deswegen bin ich davon ausgegangen das es eine abstrakte Klasse sen muss.

Das hast du auch richtig angenommen, nur machst du es in deinem bisherigen Code einfach noch nicht ^^

 

[coldstone]

In der Unterklasse Auto überschreibst du die Methoden nicht, weshalb sie, wie zuvor definiert, null liefern.

Zu diesen methoden bin ich noch nicht gekommen. Was mich :autsch: macht ist diese Zeile:

Fahrzeug[] fahrzeuge = { new Auto(), new Fahrrad(), new Schiff(),new Segler() };

Was ist Auto() in diesem Fall? Objekt, Methode oder keine ahnung was. Ich hätte jetzt gedacht das sind methoden.

 

[HimBromBeere]

Auto()

Nennt sich Konstruktor und ist weder Methode noch Variable. Das, was da drin steht, wird ausgeführt, wenn eine neue Instanz dieser Klasse erstellt wird. Im Konstruktor wird dieses Objekt dann gewissermaßen zusammengebaut, wobei die meisten Zustände (Instanzvariablen) gesetzt werden.
Ist den Methoden aber nicht völlig unähnlich, hat nur keinen Rückgabewert (auch nicht void) und wird nur ein einziges Mal pro Instanz ausgeführt.

EDIT: Im Fall Auto() könntest du z.B. eine Art Standardauto definieren, welches z.B. rot ist und einen Heckspoiler hat.

 

[Gonzo17]

Sorry. Es ist wohl heute nicht mein Tag. Natürlich ist die Klasse abstrakt. Aber die Methoden sind es nicht.

 

[coldstone]

Also ist dies schonmal der richtige weg oder:

public class FahrzeugTest {
    
    public static void main (String[] args) {
        
        Fahrzeug[] fahrzeuge = { new Auto(), new Fahrrad(), new Schiff(),new Segler() };
                for (int i = 0; i < fahrzeuge.length; i++) {
                Fahrzeug fz = fahrzeuge[i];
                System.out.println(fz + " wird angetrieben von: " + fz.antrieb()
                + "; " + fz + " " + fz.bewegung());
                }
            }
}

Und als nächstes eine abstrakte Klasse Fahrzeug mit den Methoden antrieb() und bewegung() zu erzeugen.
Also:

public abstract class Fahrzeug {
	
	public static void antrieb() {
		
		??????????????
	}
	
	
	public static void bewegung() {
		
		??????????????
	}
	
}

Richtig???

 

[Gonzo17]

Falsch. Ersetze bei den Methoden static durch abstract. Und schau dir am besten nochmal genau an, was abstract und static bedeuten.

 

[HimBromBeere]

Deine Fahrzeugtest ist schonmal sehr gut, kriegst ´nen Daumen...
Zur Klasse Fahrzeug schau dir nochmal meinen Beitrag von 21:07 an...

 

[coldstone]

public abstract class Fahrzeug {
	
	public  void antrieb() {
			
		
	}	
	
	public void bewegung() {
		
		
	}
	
}

Korrekt???

 

[HimBromBeere]

du musst die beiden Methoden in der Klasse Fahrzeug abtsrakt gestalten, womit du alle ableitenden Klasse (Auto, Segler, ...) zwingst, diese Methode zu implementieren.

 

[Beni]

Besser, aber nicht richtig.

1. Erstmal brauchen "antrieb" und "bewegung" einen Rückgabetyp, sonst werden Codes wie

wird angetrieben von: " + fz.antrieb()

nicht kompilieren. Du kannst nicht einen String mit "nichts" (nichts = void) kombinieren. In deinem Fall würde sich "String" als Rückgabetyp anbieten.

2. Was genau sollen "antrieb" und "bewegung" in Fahrzeug machen? Du kannst es drehen und wenden wie du willst, es gibt keine sinnvolle Aufgabe für die Methoden in Fahrzeug (sehr wohl aber in Auto, Schiff, etc...). Mit anderen Worten, den Body (das "{...}") musst du weglassen, und die Methode als "abstract" deklarieren. Schau mal in deinen Unterlagen nach, wohin das "abstract" genau gehört.

 

[coldstone]

Also ich glaube so ist es richtig:

public abstract class Fahrzeug {
	
	public abstract String antrieb();	
	
	public abstract String bewegung();
		

}

Ich verstehe aber immer nocht nicht was dieses abstract bewirkt und wie ich jetzt die methode antrieb oder bewegung bearbeiten kann?

Meine überlegung wäre um es logisch zu erklären:

antrieb() ---> wenn fahrzeug[0] || fahrzeug [2] dann gebe "Motor" zurück
wenn fahrzeug[1] dann gebe "Mensch" zurück
wenn fahrzeug[3] dann gebe "Wind" zurück.

bewegung() -----> wenn fahrzeug[0] || fahrzeug[1] dann gebe "faehrt" zurück
wenn fahrzeug[2] || fahrzeug[3] dann gebe "schwimmt" zurück

Dies hätte ich jetzt mit if schleife versucht, aber ich weis nicht wie ich dies anwenden muss?

 

[guest637]

Ich halte ehrlich gesagt abstrakte Methoden für so eine Pillepalle-Aufgabe für ziemlichen Overkill, denn das Verhalten dieser Methoden ist schlicht und ergreifend 2 einmalig gesetzte Strings zurückzugeben. Da wird nix berechnet, kein anderer Algorithmus implementiert, keine ifs, einfach nur ein schlichtes "return irgendeinString;". Abstrakte Methoden sind für so ein Szenario unnötige Code-Duplizierung. Oder soll bei 10 Unterklassen dann 10 mal die gleiche Methode implementiert werden?

Sowas hier ist doch viel einfacher:

public abstract class Fahrzeug {

	private final String antrieb;
	private final String bewegung;

	public Fahrzeug(final String antrieb, final String bewegung) {
		this.antrieb = antrieb;
		this.bewegung = bewegung;
	}

	public String antrieb() {
		return antrieb;
	}

	public String bewegung() {
		return bewegung;
	}

}

Und dann einfach nur in jeder Klasse den Konstruktor aufrufen:

public class Auto extends Fahrzeug {

	public Auto() {
		super("Motor", "faehrt");
	}

}

 

[coldstone]

Vielen dank an alle für die nette hilfe. Mir geht es darum nachzuvolliehen zu können wie mann auf diese Lösungswege kommt. Gibt es da bestimmte Strukturen wie man an so eine Aufgabe ranngeht, oder ist es nur lesen, lesen, lesen, üben, üben, üben????

 

[HimBromBeere]

Erstens lieber Gast steht in der Aufgabenstellung schonmal der Hinweis, dass die Oberklasse abstrakt sein soll. OK, das würde tendentiell auch ohne auch nur eine einztige abstrakte Methode gehen, aber wozu dann die Klasse abstrakt gestalten?!
Zweitens geht es hier weniger um eine kurze Formulierung sondern eher um die Grundzüge von OOP, Polymorphie und so, jedenfalls hab ich das mal so rausgelesen und da kommt man um Interfaces und Abstraktion nicht drumrum...

 

[Kiri]

Also ich glaube so ist es richtig:

public abstract class Fahrzeug {
	
	public abstract String antrieb();	
	
	public abstract String bewegung();
}

Ich verstehe aber immer nocht nicht was dieses abstract bewirkt und wie ich jetzt die methode antrieb oder bewegung bearbeiten kann?

OK, jetzt hast du deine abstrakte Klasse Fahrzeug, fehlen noch die konkreten Klassen Auto, Fahrrad, Schiff und Segler, die jeweils von Fahrzeug erben (Schlüsselwort "extends"). Jede dieser Klassen haben die Methoden antrieb und bewegung, die wiederum jeweils einen passenden String zurückgeben!

Kriegst du das hin?

 

[coldstone]

OK, jetzt hast du deine abstrakte Klasse Fahrzeug, fehlen noch die konkreten Klassen Auto, Fahrrad, Schiff und Segler, die jeweils von Fahrzeug erben (Schlüsselwort "extends"). Jede dieser Klassen haben die Methoden antrieb und bewegung, die wiederum jeweils einen passenden String zurückgeben!

Kriegst du das hin?

public class Auto extends Fahrzeug {
 
    public Auto() {
        super(antrieb("Motor");
        super(bewegung("faehrt");
    }
 
}

Ich weis nicht ob der Syntax korrekt ist für "super(antrieb("Motor");" Bitte nicht köpfen!

 

[Kiri]

public class Auto extends Fahrzeug {
 
    public Auto() {
        super(antrieb("Motor");
        super(bewegung("faehrt");
    }
 
}

Ich weis nicht ob der Syntax korrekt ist für "super(antrieb("Motor");" Bitte nicht köpfen!

Da hat dich guest... glaub ich auf die falsche Fährte geführt.

In der Konkreten Klassen, müssen sich ja die abstrakten Methoden der abstrakten Klasse wiederfinden.

Also so:

public class Auto extends Fahrzeug{
    public String antrieb(){  //String ist der Rückgabetyp
        return "Motor";  //"Motor" ist der String der zurückgegeben wird
    }
}

So, da fehlt noch eine Methode, diese bitte einfügen, dasselbe dann für die drei fehlenden Klassen! Das wäre es dann schon

 

[HimBromBeere]

Probier´s aus...

EDIT: Verdammt, zu spät... jetzt muss ich doch noch was Konstruktives schreiben, mal überlegen. Achja, die beiden Methoden antrieb und bewegen müssen in deinen Klassen Auto, Segler, ... überschrieben werden (müssen dort also definiert werden).
Du musst jetzt nur noch überlegen: was soll denn die Funktion antrieb bei einem Auto ZURÜCKGEBEn (return)?

 

[coldstone]

OK korrektur:

public  class Autos extends Fahrzeug {
 
   public  String antrieb() {
	return "Motor";

   } 
   
   public String bewegung()  {
	return "faehrt";
   }
}

 

[HimBromBeere]

Jaaaaaaaaaaaaaaaaaaaaaaa, und nun noch für die anderen Klassen...:toll::toll:

 

[Kiri]

OK korrektur:

public  class Autos extends Fahrzeug {
 
   public  String antrieb() {
	return "Motor";

   } 
   
   public String bewegung()  {
	return "faehrt";
   }
}

mach aus Autos Auto dann passt das. :toll: Nun noch für die anderen drei (Fahrrad, Schiff und Segeln), dann kannst es ausprobieren. Das kriegst du aber hin - bin dann mal weg.

 

[coldstone]

Vielen dank für die hilfen. Habt ihr noch eine Tipp wie mann sowas bei Klausuren angeht ohne hilfsmittel?

 

[HimBromBeere]

Naja, du musst dir überlegen, welche Beziehungen zwischen deinen Objekten bestehen sollen /das läuft meistens auf sowas hinaus wie ein Auto IST ein Fahrzeug und HAT Räder).

Ein IST heißt hierbei immer, dass eine allgemeine Klasse (Fahrzeug) irgendwie spezifiziert wird (Auto), ein
HAT bedeutet eine Eigenschaft, die das Objekt besitzen soll (z.B. HAT ein Auto als Antrieb einen Motor).