Home > Informatik > Informatik EF > Folge 4

Folge 4.1: Autofahren

Wir wollen jetzt ein Programm schreiben, welches den Benzinverbrauch eines Autos simuliert. Unsere neue Klasse heißt demzufolge Auto.

Schritt 1 - Neue Klasse erzeugen

Erzeugen Sie eine neues leeres Projekt mit der Klasse Auto.

Doppelklicken Sie auf die Klasse Auto um den Quelltext zu bearbeiten. Bereinigen Sie dann den Quelltext so, dass nur noch der Minimalquelltext übrig ist:

public class Auto
{
   public Auto()
   {
   }
}

Interne Links:

Schritt 2 - das Auto kann fahren

Was soll unser Auto alles können? Ähnlich wie bei dem Waage-Projekt wollen wir uns zunächst Gedanken darüber machen, welche Methoden die Auto-Objekte benötigen, damit sie "fahren" können.

   public void fahren(double km)
	{
	}

Das wäre ein erster Vorschlag für eine Methode zum Fahren. Wir geben beispielsweise den Wert 12.0 als Parameter an, und unser Auto legt eine Strecke von 12.0 km zurück. Natürlich muss diese Streckenveränderung irgendwo gespeichert werden, und damit kommen wir auch schon zum ersten Attribut unserer Klasse, dem Kilometerstand des Tachos.

public class Auto
{
   double kmStand;

   public Auto()
   {
      kmStand = 100;
   }

   public void fahren(double km)
   {
      kmStand += km;
   }
}

Geben Sie diesen Quelltext ein, kompilieren Sie und erzeugen Sie ein Objekt auto1 der Klasse Auto. Rufen Sie dann die Methode fahren mit dem Wert 12.0 auf und inspizieren Sie das Objekt.

Wir inspizieren nach dem Fahren das Objekt

Das Attribut kmStand hat tatsächlich den Wert 12.0

Interne Links:

Exkurs: Der += Operator und seine Verwandten

Im Quelltext der Methode fahren hätte man natürlich auch schreiben können:

kmStand = kmStand + km;

Eine Zuweisung, die den Wert einer Variable um eine bestimmte Zahl erhöht, nennt man Inkrementation. Eine solche Inkrementation kann man auch einfacher schreiben:

kmStand += km;

Diese kurze Anweisung mit dem += Operator besagt: Erhöhe den Wert der Variable kmStand um den Wert km.

Neben dem += Operator gibt es auch den -=, den *= und den /= Operator.

Interne Links:

Übungen

Sie erhalten zwei Zusatzpunkte, wenn Sie für die folgenden drei Übungen die formatierte Ausgabe verwenden und alle Zahlen mit genau zwei Nachkommastellen anzeigen.

Übung 4.1-1 (6 Punkte)

Ergänzen Sie den Quelltext der Klasse Auto um ein Attribut, das die noch vorhandene Benzinmenge in Litern speichert. Der Tank des Autos soll maximal 70 Liter Benzin fassen, und das Auto soll durchschnittlich 7.3 Liter pro 100 km Fahrstrecke verbrauchen.

Verändern Sie nun die Methode fahren derart, dass beim Fahren tatsächlich Benzin verbraucht wird. Der Kilometerstand und der Benzinstand des Autos sollen durch eine weitere neue Methode anzeigen in der Konsole ausgegeben werden. Schreiben Sie auch diese Methode.

Übung 4.1-2 (3 Punkte)

Bei der vorherigen Übung sind wir davon ausgegangen, dass der Tank des Autos maximal 70 Liter Benzin fasst. Es gibt aber auch Autos, deren Tank nur 50 Liter fasst; andere Autos wiederum können bis zu 80 oder 90 Liter betankt werden.

Machen Sie Ihr Auto flexibler, so dass der Benutzer der Klasse das maximale Fassungsvermögen des Tanks beim Erzeugen eines Auto-Objektes festlegen kann.

Übung 4.1-3 (2 Punkte)

Auch der Verbrauch des Autos soll nun beim Erzeugen der Auto-Objekte flexibel festgelegt werden können, denn nicht jedes Auto verbraucht im Schnitt 7.3 Liter/100 km. Ergänzen Sie die Klasse entsprechend.

Interne Links:

Schritt 3 - Testklassen

Es ist Ihnen sicherlich auch schon aufgefallen, dass man beim Entwickeln einer Klasse diese recht häufig testen muss. Sobald man den Quelltext etwas verändert hat, muss man neu kompilieren, und alle Objekte, die man vorher angelegt hatte, sind wieder verschwunden. Also muss wieder ein neues Objekt erstellt werden, und alle Methoden müssen wieder aufgerufen werden. Oft haben diese Methoden mehrere Parameter, die dann auch noch angegeben werden müssen.

All diese Arbeit kann man sich erleichtern, wenn man die Klasse - hier Auto - von einer Testklasse prüfen lässt. Hier der Quelltext einer Klasse Test, welche die Klasse Auto auf Herz und Nieren testet:

public class Test
{
   Auto otto;
 
   public Test()
   {
      otto = new Auto(10000, 70, 7.5);
      otto.fahren(20);
      otto.anzeigen();
      otto.fahren(60);
      otto.anzeigen();
      otto.fahren(20);
      otto.anzeigen();
      otto.fahren(30);
      otto.anzeigen();
      otto.fahren(80);
      otto.anzeigen(); 
      otto.fahren(280);
      otto.anzeigen(); 
   }
}

Zuerst wird im Konstruktor der Testklasse (andere Methoden sind hier gar nicht nötig) ein Auto-Objekt otto initialisiert, und zwar ein Auto, das schon 10.000 km gefahren ist, ein Tankvolumen von 70 Litern hat und einen durchschnittlichen Verbrauch von 7.5 Litern / 100 km hat.

Anschließend fährt das Auto 20 km, danach werden die wichtigsten Attributwerte angezeigt, zum Beispiel der aktuelle Benzinverbrauch, der ja von der gefahrenen Strecke abhängt. Danach wird die fahren-Methode mehrmals mit verschiedenen Werten aufgerufen, und jedes Mal werden die Attributwerte durch Ausführen der anzeigen-Methode überprüft.

Mithilfe dieser Testklasse und der Konsolenausgabe lässt sich leicht überprüfen, ob der Quelltext der zu entwickelnden Klasse wirklich das tut, was er soll.

Der Arbeitsaufwand für Sie als Entwickler ist recht gering, nachdem Sie die Testklasse fertiggestellt haben.

Es reicht, wenn Sie nach jeder Veränderung der zu Klasse Auto das Projekt kompilieren (ein Tastenbefehl) und dann ein Objekt der Testklasse erzeugen (ein Mausklick).

Da der gesamte Test bereits im Konstruktor der Testklasse durchgeführt wird, muss nach dem Erzeugen des Testklassen-Objekts auch keine weitere Methode mehr aufgerufen werden, um den eigentlichen Test durchzuführen.

Interne Links:

Schritt 4 - Tanken

Übung 4.1-4 (4 Punkte)

Erweitern Sie Ihre Klasse Auto so, dass das Auto wieder vollgetankt werden kann. Ein Attribut für das Tankvolumen hatten Sie ja bereits angelegt; falls nicht, müssen Sie das jetzt nachholen.

In der tanken-Methode muss natürlich dafür gesorgt werden, dass der Tank nicht überläuft; der noch vorhandene Tankinhalt und das getankte Benzin dürfen zusammen nicht den maximalen Tankinhalt überschreiten!

Interne Links:

if-else-Anweisung

Schritt 5 - Fahren

Wir wollen jetzt das Auto "richtig" fahren lassen. Den Graphikmodus von Java beherrschen wir noch nicht, darum müssen wir das Fahren in der Textkonsole simulieren.

Wir hatten ja bereits eine Methode zum Fahren programmiert, die zum Beispiel so aussehen könnte:

public void fahren(double km)
{
   if (tankinhalt > km * verbrauch/100)
   {
      kmStand += km;
      tankinhalt -= km * verbrauch/100;
   }
   else
   {
      kmStand += tankinhalt / (verbrauch/100);
      tankinhalt = 0;
   }
}

Dies ist eine mögliche Version der fahren-Methode, der Kilometerstand wird um die gefahrenen Kilometer erhöht, der Tankinhalt wird verringert, allerdings ist der Benzinverbrauch hier konstant und nicht von der Außentemperatur oder der Motortemperatur abhängig. Hier würde sich ein Betätigungsfeld für unterforderte Schüler(innen) bieten...

Leichte Übung für unterforderte Schüler(innen)

Machen Sie den Verbrauch des Autos von der Außentemperatur abhängig, für die Sie natürlich ein neues Attribut in die Klasse Auto einbauen müssen.

Anspruchsvollere Übung für unterforderte Schüler(innen)

Der Verbrauch eines Benzinmotors sinkt mit der Temperatur des Motors. Je wärmer der Motor ist, desto weniger Benzin verbraucht er auf 100 km. Am Anfang hat der Motor die gleiche Temperatur, die außen herrscht (Außentemperatur). Mit jedem gefahrenen Kilometer steigt die Motortemperatur an, bis ein maximaler Wert um 100 ºC erreicht ist. Ein noch höherer Wert ist schädlich für den Motor und wird durch geeignete Kühlmechanismen verhindert. Das Kühlwasser ist mit chemischen Zusätzen versehen, so dass es auch Temperaturen von über 100 ºC annehmen kann, ohne zu kochen. Die Temperatur des Kühlwassers bzw. des Motors wird in einem Auto normalerweise auch angezeigt.

Ergänzen Sie die Klasse Auto entsprechend; lassen Sie Ihrer Kreativität dabei freien Lauf!

Weiter geht es mit der Folge 4.2: while-Schleifen