Methoden: tanken und fahren

Lösung geprüft

Die Aufgabe der heutigen Stunde ist tanken und fahren! Endlich füllen wir die beiden Methoden, in denen bis jetzt nur // TODO stand. Damit hört unser Auto auf, ein hübsches Möbelstück zu sein, und fängt an tatsächlich was zu tun.

Die Aufgabe besteht aus vier Teilen und baut aufeinander auf. Nimm sie dir der Reihe nach vor, sonst verhedderst du dich.

Die Aufgabenstellung lautet

Aufgabe 1: Implementieren Sie die Methode fahren in die Klasse Auto. Erklären Sie den Ablauf der Methode. Vorgabe: Variablen werden am Anfang einer Methode deklariert, eine Deklarierung mitten im Methodencode ist unschön und wird schnell unübersichtlich.

Aufgabe 2: Implementieren Sie anhand der Beschreibung die Methode tanken. Halten Sie sich an die genaue Abfolge der Beschreibung. Verwenden Sie if- bzw. if-else-Abfragen und sinnvolle Variablennamen.

Aufgabe 3: Aktuell können auch Autos mit einem ungültigen Wert erzeugt werden, zum Beispiel einem negativen Kraftstoffverbrauch. Schreibe den Konstruktor so um, damit dies nicht mehr möglich ist. Vor dem Abbruch soll eine genaue Fehlermeldung ausgegeben werden.

Aufgabe 4: Ersetzen Sie die Ausgabe des Kilometerstandes in der Klasse Autohaus durch den Aufruf der Methode ausgabe. Erweitern Sie die Klasse Autohaus und testen Sie damit die Klasse Auto – insbesondere auch das Erzeugen von Autos mit ungültigen Werten.

Lösungsprozess der Aufgabe

Auto.java

/* meininfokurs.cmrg.site */

/**
 *
 * Die fertige Klasse Auto mit tanken, fahren und abgesichertem Konstruktor
 *
 * @version 1.0 vom 13.09.2025
 * @meininfokurs.cmrg.site
 */

public class Auto {

// Anfang Attribute
private String Kennzeichen;
private double Kilometerstand;
private double Tankvolumen;
private double Kraftstoffverbrauch;
private double Kraftstoffmenge;
// Ende Attribute

//Konstruktor - Aufgabe 3: die Werte werden erst geprueft
public Auto(String Kennzeichen, double Tankvolumen, double Kraftstoffverbrauch) {
  if (Kennzeichen == null || Kennzeichen.equals("")) {
    System.out.println("Fehler: Das Kennzeichen darf nicht leer sein.");
    return;
  }
  if (Tankvolumen <= 0) {
    System.out.println("Fehler: Das Tankvolumen muss groesser als 0 sein.");
    return;
  }
  if (Kraftstoffverbrauch < 0 || Kraftstoffverbrauch > 50) {
    System.out.println("Fehler: Kraftstoffverbrauch darf nicht negativ sein oder ist zu unrealistisch hoch.");
    return;
  }

  this.Kennzeichen = Kennzeichen;
  this.Tankvolumen = Tankvolumen;
  this.Kraftstoffverbrauch = Kraftstoffverbrauch;
  Kilometerstand = 0;
  Kraftstoffmenge = 0;
}

// Anfang Methoden
public String getKennzeichen() {
  return Kennzeichen;
}

public double getKilometerstand() {
  return Kilometerstand;
}

public double getKraftstoffmenge() {
  return Kraftstoffmenge;
}


// Aufgabe 2: tanken
public void tanken(double Menge) {
double freierPlatz;

  if (Menge <= 0) {
    System.out.println("Fehler: Die Menge muss positiv sein.");
    return;
  }

  freierPlatz = Tankvolumen - Kraftstoffmenge;

  if (freierPlatz <= 0) {
    System.out.println("Der Tank ist bereits voll.");
    return;
  }

  if (Menge > freierPlatz) {
    Kraftstoffmenge = Tankvolumen;
    System.out.println("Es passten nur noch " + InOut.format2(freierPlatz)
        + " l hinein. Der Tank ist jetzt voll.");
  } else {
    Kraftstoffmenge += Menge;
    System.out.println("Getankt: " + InOut.format2(Menge) + " l. Im Tank: "
        + InOut.format2(Kraftstoffmenge) + " l.");
  }
}


// Aufgabe 1: fahren
public void fahren(double Strecke) {
double benoetigterKraftstoff, moeglicheStrecke, verbraucht;

  if (Strecke <= 0) {
    System.out.println("Keine Fahrt möglich, die Strecke muss positiv sein.");
    return;
  }

  benoetigterKraftstoff = Strecke * Kraftstoffverbrauch / 100.0;

  if (Kraftstoffmenge >= benoetigterKraftstoff) {
    Kraftstoffmenge -= benoetigterKraftstoff;
    Kilometerstand += Strecke;
    System.out.println("Gefahren: " + InOut.format2(Strecke) + " km. "
        + "Verbrauch: " + InOut.format2(benoetigterKraftstoff) + " l.");
  } else {
    moeglicheStrecke = Kraftstoffmenge / Kraftstoffverbrauch * 100.0;
    Kilometerstand += moeglicheStrecke;
    verbraucht = Kraftstoffmenge;
    Kraftstoffmenge = 0;
    System.out.println("Zu wenig Kraftstoff. Gefahren bis zum Stillstand: "
        + InOut.format2(moeglicheStrecke) + " km. "
        + "Verbraucht: " + InOut.format2(verbraucht) + " l.");
  }
}


public void ausgabe() {
  String info = "Auto: " + Kennzeichen + "\n"
              + "  Kilometerstand: " + InOut.format2(Kilometerstand) + " km\n"
              + "  Tankvolumen: " + Tankvolumen + " l\n"
              + "  Kraftstoffverbrauch: " + Kraftstoffverbrauch + " l/100km\n"
              + "  Kraftstoffmenge: " + InOut.format2(Kraftstoffmenge) + " l";
  System.out.println(info);
}
// Ende Methoden
} // end of class Auto

In der Aufgabenstellung wird gefordert, dass wir folgende Sachen umsetzen:

fahren implementieren und den Ablauf erklären können
tanken nach der Beschreibung implementieren
Den Konstruktor gegen unsinnige Werte absichern
Die Fehlermeldung zum Kraftstoffverbrauch exakt wie gefordert ausgeben
Im Autohaus die Ausgabe durch ausgabe() ersetzen und richtig testen

Der Ablauf von fahren

Das ist Teil b) von Aufgabe 1 – du sollst den Ablauf nicht nur hinschreiben, sondern erklären können. Die Methode arbeitet drei Fälle ab:

Unsinnige Eingabe. Ist die Strecke 0 oder negativ, gibt es eine Meldung und die Methode ist sofort fertig.
Genug Sprit. Der Kraftstoff reicht für die ganze Strecke: Sprit abziehen, Kilometer draufrechnen, ausgeben.
Zu wenig Sprit. Das Auto fährt, so weit es kommt, bleibt dann stehen. Tank auf 0, aber die gefahrenen Kilometer zählen trotzdem.

Der dritte Fall ist der, den man beim Selberschreiben vergisst. Es wäre ja auch einfacher zu sagen „zu wenig Sprit, fahre gar nicht". Nur macht ein echtes Auto das nicht – das fährt bis der Tank leer ist und steht dann irgendwo auf der Landstraße.

Die Rechnung mit dem Verbrauch

Der Kraftstoffverbrauch ist in Liter pro 100 Kilometer angegeben. Deshalb steht in beiden Richtungen eine 100 in der Formel:

// Wie viel Sprit brauche ich fuer eine Strecke?
benoetigterKraftstoff = Strecke * Kraftstoffverbrauch / 100.0;

// Wie weit komme ich mit dem Sprit, den ich noch habe?
moeglicheStrecke = Kraftstoffmenge / Kraftstoffverbrauch * 100.0;

Schreib die 100.0 mit Nachkommastelle, nicht als 100. Bei double ist das hier zwar egal, weil schon andere Werte double sind – wenn du aber mal nur mit int rechnest, schneidet Java gnadenlos alles nach dem Komma ab und du wunderst dich, warum 0 rauskommt. Angewöhnen lohnt sich.

tanken: die Reihenfolge ist die Aufgabe

Bei tanken gibt die Aufgabe keinen Code vor, sondern einen Text – und der beschreibt eine ganz bestimmte Reihenfolge. Die musst du einhalten, sonst kommen falsche Meldungen raus:

Erst prüfen, ob die Menge überhaupt positiv ist
Dann den freien Platz ausrechnen: Tankvolumen - Kraftstoffmenge
Ist kein Platz mehr da, ist der Tank voll – raus hier
Passt die gewünschte Menge nicht ganz rein, nur den Rest nachfüllen
Sonst ganz normal tanken

Denk an Schritt 4. Wenn dein Tank 50 Liter fasst, 45 drin sind und du 20 tankst, dürfen danach nicht 65 Liter drin sein. Passiert aber genau das, wenn du einfach Kraftstoffmenge += Menge; schreibst ohne vorher zu gucken.

Der abgesicherte Konstruktor

Aufgabe 3 ist die, bei der man am meisten lernt. Bisher konnte man ein Auto mit -3 Liter Verbrauch bauen. Das Programm lief, das Auto fuhr, und der Tank wurde beim Fahren voller. Prüfen wir die Werte vorher, kann das nicht mehr passieren:

if (Kraftstoffverbrauch < 0 || Kraftstoffverbrauch > 50) {
  System.out.println("Fehler: Kraftstoffverbrauch darf nicht negativ sein oder ist zu unrealistisch hoch.");
  return;
}

Den Text für die Zusatzaufgabe musst du genau so übernehmen, mit dem Punkt am Ende. Das || heißt „oder" – es reicht, wenn eine der beiden Bedingungen zutrifft.

Was return im Konstruktor wirklich macht

Auf dem Aufgabenblatt steht „Mit return; wird das Programm abgebrochen". Das ist etwas zu großzügig formuliert, und der Unterschied ist wichtig genug, dass ich ihn hier hinschreibe: return beendet die Methode, nicht das Programm. Der Rest deines main läuft ganz normal weiter.

Für den Konstruktor heißt das: das Objekt wird trotzdem erzeugt. Es existiert, es ist nur nicht befüllt – Kennzeichen ist null, alle Zahlen sind 0. Wenn du danach kaputtesAuto.fahren(100) aufrufst, passiert nichts Sinnvolles, aber es kracht auch nicht. Genau deshalb ist die Fehlermeldung so wichtig: sie ist das Einzige, woran du merkst, dass etwas schiefgelaufen ist.

Richtig aufräumen würde man das später mit Exceptions. Die hatten wir noch nicht, also bleibt es beim return mit Meldung – so will es die Aufgabe auch.

Testen im Autohaus

Aufgabe 4 will, dass du das Autohaus zur richtigen Testumgebung ausbaust. „Testen" heißt hier ausdrücklich auch: die Fälle ausprobieren, die schiefgehen sollen.

Autohaus.java

/* meininfokurs.cmrg.site */

/**
 *
 * Das Autohaus als Testumgebung fuer die Klasse Auto
 *
 * @version 2.0 vom 13.09.2025
 * @meininfokurs.cmrg.site
 */

public class Autohaus {

  public static void main(String[] args) {

    // --- normaler Ablauf ---
    Auto meinAuto = new Auto("WI-AB 123", 50, 6.5);
    meinAuto.tanken(20);
    meinAuto.fahren(100);
    meinAuto.ausgabe();

    // --- mehr tanken als reinpasst ---
    System.out.println("");
    meinAuto.tanken(100);
    meinAuto.ausgabe();

    // --- weiter fahren als der Sprit reicht ---
    System.out.println("");
    meinAuto.fahren(2000);
    meinAuto.ausgabe();

    // --- unsinnige Eingaben ---
    System.out.println("");
    meinAuto.tanken(-5);
    meinAuto.fahren(0);

    // --- ungueltige Autos: hier kommen die Fehlermeldungen ---
    System.out.println("");
    Auto negativ = new Auto("WI-XX 1", 50, -3);
    Auto durstig = new Auto("WI-XX 2", 50, 80);
    Auto ohneTank = new Auto("WI-XX 3", 0, 6.5);
    Auto ohneNamen = new Auto("", 50, 6.5);

  } // end of main

} // end of class Autohaus

Und das kommt dabei raus:

Konsole

Getankt: 20,00 l. Im Tank: 20,00 l.
Gefahren: 100,00 km. Verbrauch: 6,50 l.
Auto: WI-AB 123
  Kilometerstand: 100,00 km
  Tankvolumen: 50.0 l
  Kraftstoffverbrauch: 6.5 l/100km
  Kraftstoffmenge: 13,50 l

Es passten nur noch 36,50 l hinein. Der Tank ist jetzt voll.

Zu wenig Kraftstoff. Gefahren bis zum Stillstand: 769,23 km. Verbraucht: 50,00 l.

Fehler: Die Menge muss positiv sein.
Keine Fahrt möglich, die Strecke muss positiv sein.

Fehler: Kraftstoffverbrauch darf nicht negativ sein oder ist zu unrealistisch hoch.
Fehler: Kraftstoffverbrauch darf nicht negativ sein oder ist zu unrealistisch hoch.
Fehler: Das Tankvolumen muss groesser als 0 sein.
Fehler: Das Kennzeichen darf nicht leer sein.

Rechne die 769,23 km ruhig nach: 50 Liter im Tank, 6,5 Liter auf 100 km, also 50 / 6,5 · 100. Kommt hin. Wenn bei dir eine andere Zahl steht, hast du wahrscheinlich die 100 in der Formel vergessen.