Folge 4.1: Autofahren

In dieser Folge 4 wollen wir eine neue Klasse modellieren, und zwar die Klasse Auto. Dazu müssen wir Attribute und Verhaltensweisen festlegen, die ein Auto charakterisieren. Aus den Attributen erstellen wir dann Instanzvariablen, die Verhaltensweisen werden durch Getter- und manipulierende Methoden (zum Beispiel Setter-Methoden) dargestellt. Auch Ausgabe-Methoden werden benötigt, um die Attributwerte in der Konsole anzuzeigen.

Schritt 1 - Klasse Auto erzeugen

Die Klasse Auto soll zunächst folgende Attribute besitzen:

• Marke (VW, BMW, Mercedes, Audi, Renault etc.)
• Aktueller Kilometerstand
• Maximaler Tankinhalt
• Aktueller Tankinhalt
• Benzinverbrauch auf 100 km

Natürlich könnte man hier noch viel mehr Attribute berücksichtigen wie beispielsweise Typ, Farbe, Leistung, Zulassungsdatum und so weiter, aber wir wollen die Sache ja übersichtlich halten und beschränken uns daher auf einige wenige Attribute, die sich direkt auf das Fahren beziehen.

Durch welche Instanzvariablen könnte man diese Attribute darstellen?

Die Marke kann nur durch eine Zeichenkette (String) dargestellt werden. Alle anderen genannten Attribute sollen in unserem Beispiel durch Kommazahlen (double) dargestellt werden. Der aktuelle Kilometerstand könnte beispielsweise 34602.3 betragen, der maximale Tankinhalt 67.8 Liter, der aktuelle Tankinhalt 23.5 Liter und der Benzinverbrauch auf 100 km 7.5 Liter.

Welche Methoden sollte die Klasse Auto besitzen?

Der Konstruktor sollte die Marke, den maximalen Tankinhalt und den Benzinverbrauch auf 100 km festlegen. Diese Werte sollen in unserem Beispiel später nicht mehr verändert werden können. Daher werden auch keine Setter-Methoden für diese Attribute benötigt.

Der aktuelle Kilometerstand und der aktuelle Tankinhalt sind dagegen stark variabel und sollten jederzeit angepasst werden können. Dazu benötigen wir dann zwei Setter-Methoden, die natürlich auch Validierungen durchführen. Ein negativer Tankinhalt ist nicht möglich, ebenso wenig ein aktueller Tankinhalt, der größer ist als der maximale Tankinhalt. Auch der aktuelle Kilometerstand kann nicht negativ sein; dies muss von der Setter-Methode verhindert werden.

Sie können Ihre Methode mit folgendem Zahlenbeispiel überprüfen:

• Tankinhalt: 24 Liter
• Verbrauch: 6 Liter pro 100 km

Dann hat das Auto eine Reichweite von 400 km.

Schritt 2 - Das Auto kann fahren

Nun soll unser Auto auch fahren können. Erinnern Sie sich an das shapes-Projekt aus den ersten beiden Folgen? Dort besaßen die Grafikobjekte die Methode moveRight(), mit der ein Objekt um genau 50 Pixel nach rechts verschoben wurde.

Unser Auto bewegt sich nicht auf dem Bildschirm, sondern nur als Objekt im Speicher. Das Fahren simulieren wir daher, indem wir den Kilometerstand verändern. Die Methode fahre() soll das Auto jeweils genau 1 km weiterfahren lassen. Eine erste Version dieser Methode wäre sehr einfach:

public void fahre()
{
   kilometerstand++;
}

Natürlich genügt das noch nicht. Beim Fahren wird Benzin verbraucht. Verbraucht ein Auto beispielsweise 6,7 Liter auf 100 km, so werden auf einem Kilometer 0,067 Liter benötigt. Der Tankinhalt muss also bei jedem Kilometer entsprechend verringert werden.

Schritt 3 - Das Auto kann mehrere km fahren

Angenommen, wir wollen das Auto 20 km fahren lassen. Dann wäre es sehr lästig, wenn wir die Anweisung

meinAuto.fahre();

zwanzigmal in den Quelltext der Testklasse aus Übung 4.1-5 schreiben müssten. Für solche Wiederholungen gibt es in Java eine elegantere Lösung:

    public void fahre()
    {
        if (getReichweite() >= 1)
        {
            kilometerstand++;
            tankinhalt = tankinhalt - verbrauch / 100;
        }
    }   

    public void fahre(int strecke)
    {
        int gefahren = 0;
        while (gefahren < strecke)
        {
            fahre();
            gefahren++;
        }
    }    

Wir sehen hier zwei Versionen der Methode fahre(). Die erste Methode lässt das Auto genau einen Kilometer fahren und berechnet anschließend den neuen Tankinhalt.

Die zweite Methode lässt das Auto eine beliebige Strecke fahren. Dazu ruft sie die erste Methode mehrfach auf. Die Wiederholung erfolgt mit einer while-Schleife.

Analyse der Methode fahre(int strecke)

Die gewünschte Strecke wird der Methode als int-Parameter übergeben.

Die lokale Variable gefahren speichert die bereits zurückgelegte Strecke. Zu Beginn hat sie den Wert 0.

Im Schleifenkopf wird überprüft, ob die bereits gefahrene Strecke kleiner ist als die gewünschte Strecke:

while (gefahren < strecke)

Ist diese Schleifenbedingung erfüllt, wird der Schleifenrumpf ausgeführt. Zunächst wird die parameterlose Methode fahre() aufgerufen. Anschließend erhöht die Anweisung

gefahren++;

die Variable gefahren um 1. Danach springt das Programm zum Schleifenkopf zurück und überprüft die Schleifenbedingung erneut.

Soll das Auto beispielsweise 10 km fahren, wird die Schleife zehnmal durchlaufen. Danach hat die Variable gefahren den Wert 10. Die Bedingung gefahren < strecke ist nun nicht mehr erfüllt, die Schleife endet und damit auch die Methode fahre(int strecke).

Wieso sind zwei Methoden mit dem gleichen Namen möglich?

In der Klasse Auto befinden sich jetzt zwei Methoden mit dem gleichen Namen fahre(). Wie ist das möglich? Muss nicht jede Methode einen eigenen und eindeutigen Namen haben?

Nein. In Java dürfen mehrere Methoden denselben Namen besitzen, wenn sie sich in ihrer Parameterliste unterscheiden. Die beiden Methoden

public void fahre()
public void fahre(int strecke)

haben zwar denselben Namen, aber unterschiedliche Parameterlisten. Java erkennt deshalb beim Methodenaufruf automatisch, welche der beiden Methoden gemeint ist:

meinAuto.fahre();      // fährt genau 1 km
meinAuto.fahre(20);    // fährt 20 km

Mehrere Methoden mit demselben Namen, aber unterschiedlichen Parameterlisten nennt man Methodenüberladung. Dieses Konzept werden wir später noch genauer kennenlernen.