OOP Vererbung und Problem bei Zählschleife in einer Methode

Erste Aufgabenstellung: Die Operation fahren() liefert kein Funktionsergebnis. Sie „fährt“ die als Argument km vom Typ int übergebene Zahl von Kilometern. Der Kilometerstand wird angepasst und der Kraftstoffvorrat verringert sich entsprechend. Wir können natürlich nur so weit fahren, wie es der Kraftstoffvorrat im Tank zulässt.

Ich habe hier allerdings das Problem, wenn ich 300 kilometer fahren will, mit 5 Liter Verbrauch auf 100 km, werde ich 15 Liter bei den 300 km verbrauchen. Von den 30 Liter die ich momentan im Tank habe, werden die 15 abgezogen und ich habe nach der Fahrt noch 15 Liter im Tank. Bei 600 km Fahrt habe ich den Tank genau auf 0 Liter leer gefahren. Allerdings wenn ich 900 km fahre, komme ich ja nur 600 km weit, aber ich bekomme in der Methode fahren() das nicht so richtig umgesetzt.

Zweite Aufgabenstellung Die Klasse Omnibus erweitert die Klasse Auto um das private Attribut anzahlSitze, das die Anzahl der Sitzplätze eines Omnibusses angibt. Die Klasse besitzt einen allgemeinen Konstruktor, der die Attributwerte initialisiert. Die Operation toString() wandelt ein Omnibus-Objekt in eine Zeichenkette, die alle Attributwerte enthält, und liefert diese Zeichenkette als Ergebnis zurück. Implementieren Sie die Klasse Omnibus. Überlegen Sie, welche Operationen der Basisklasse Auto Sie dabei verwenden können.

Also soll ich hier die Methoden fahren() und tanken() übergeben? Oder was würde sich noch anbieten?

Ich hoffe mir kann hier jemand weiterhelfen :)


Ich habe eine (Ober)Klasse Auto:
Java:
class Auto{
 
  private int kmStand;
  private double verbrauch;
  private double tankVolumen;
  private double kraftstoffVorrat;
 
  public Auto(int kmStand, double verbrauch, double tankVolumen, double kraftstoffVorrat){
    this.kmStand=kmStand;
    this.verbrauch = verbrauch;
    this.tankVolumen = tankVolumen;
    this.kraftstoffVorrat = kraftstoffVorrat;   
  }
 
  public void info(){
    System.out.println("Kilometerstand: "+kmStand);
    System.out.println("Verbrauch: "+verbrauch);
  }
 
  public String toString(){
    return "Kilometerstand "+kmStand+" Verbrauch "+verbrauch+" Tankvolumen "+tankVolumen+" Kraftstoffvorrat "+kraftstoffVorrat;
  }
 
  public void fahren(int km){
    
    for(int i=1;i<=km;i++){
      if((i*verbrauch)/100<=kraftstoffVorrat){
        kmStand++;
      
      }
      else{
        kraftstoffVorrat-=((i-1)*verbrauch)/100;
        break;
      }
      
      
    }
   kraftstoffVorrat-=(km*verbrauch)/100;
  }
    
  public void tanken(double liter){
    for(int i=1; i<=liter; i++){
      if(kraftstoffVorrat<tankVolumen){
        kraftstoffVorrat++;
      }
      else{
        break;
      }
    }
  }
}
eine (Unter)Klasse Omnibus:
Java:
class Omnibus extends Auto{
 
  private int anzahlSitze;
 
  public Omnibus(int kmStand, double verbrauch, double tankVolumen, double kraftstoffVorrat, int anzahlSitze){
    super(kmStand, verbrauch, tankVolumen, kraftstoffVorrat);
    this.anzahlSitze=anzahlSitze;
  }
 
  public String toString(){
    return super.toString()+""+anzahlSitze;
  }
}
und noch eine Main mit der ich alles testen kann:
Java:
public class Autotest{
 
  public static void main( String[] args){
    
    Auto goggoMobil = new Auto(0,5.0,50,30);
    System.out.println("Anfang");
    System.out.println(goggoMobil.toString());
    goggoMobil.fahren(300);
    System.out.println("Nach der Fahrt");
    System.out.println(goggoMobil.toString());
    goggoMobil.tanken(45);
    System.out.println("Nach dem Tanken");
    System.out.println(goggoMobil.toString());
    
    //Omnibus goggoBus = new Omnibus(0,5.0,50,30);
    
    
  } 
}
 
Also bezüglich fahren:
Wie wäre es, wenn Du erst berechnest, wie viele km du noch fahren kannst? Dann sollte es doch möglich sein, zu sagen, wie viele km gefahren wurde und was der Tank Inhalt ist, oder?

Und was Omnibus angeht: Da hast Du vom Prinzip her doch eine Lösung gebaut. Die ist evtl. noch zu verschönern (Probier es mal aus - was gibt denn toString zurück?) aber das sieht sonst ok aus. Deine Frage verstehe ich da gerade nicht ganz.
 
Ich habe hier allerdings das Problem
Du hast doch schon alles geschrieben. Du musst es nur der Reihe nach in Code umsetzen :)

Code:
reichweite := Anzahl km, die mit kratstoffVorrat bei verbrauch gefahren werden kann
Falls km > reichweite, dann
    wird reichweite Kilometer weit gefahren
sonst
    wird km Kilometer weiter gefahren
 
Alter Code: Wenn ich in meine Methode fahren() 300 eingebe und vorher ein Auto erzeugt habe mit 5 Liter auf 100 km, 30 Liter im Tank und einem Kilometerstand von 0, dann bekomme ich das Ergebnis(Ausgabe):
Kilometerstand 300 Verbrauch 5.0 Tankvolumen 50.0 Kraftstoffvorrat 15.0

Bei dem selben Objekt nur mit fahren(600) erhalte ich:
Kilometerstand 600 Verbrauch 5.0 Tankvolumen 50.0 Kraftstoffvorrat 0.0

Bei dem selben Objekt mit diesmal fahren(900) erhalte ich:
Kilometerstand 600 Verbrauch 5.0 Tankvolumen 50.0 Kraftstoffvorrat -45.0 (soll ja auch 0 ergeben)

Bei meiner Methode kann ja nicht mehr so viel fehlen, der Fehler kann ja nicht so groß sein, bin halt zu unerfahren deswegen wende ich mich an dieses Forum.

Java:
  public void fahren(int km){

    for(int i=1;i<=km;i++){
      if((i*verbrauch)/100<=kraftstoffVorrat){
        kmStand++;
      
      }
      else{
        kraftstoffVorrat-=((i-1)*verbrauch)/100;
        break;
      }
    }
   kraftstoffVorrat-=(km*verbrauch)/100;
  }
Dein Lösungsschritt
Code:
reichweite := Anzahl km, die mit kratstoffVorrat bei verbrauch gefahren werden kann
Falls km > reichweite, dann
    wird reichweite Kilometer weit gefahren
sonst
    wird km Kilometer weiter gefahren
[/QUOTE]

meine umsetzung :oops:: sorry aber ich brauch da nochmal etwas unterstützung.
Hier weiß ich nicht wie ich dieses := interpretieren soll
reichweite := Anzahl km, die mit kratstoffVorrat bei verbrauch gefahren werden kann
Java:
  public void fahren(int km){
    
    reichweite = km*verbrauch/100;
    if(km>reichweite){
      kmStand += reichweite;     
    }
    else{
      kmStand+=km;
    }
Fehlercode: reichweite cannot be resolved to a variable
 
Was ist denn reichweite in Deinem Code? Du willst doch eine neue lokale Variable haben, in der Du das zwischenzeitig speichern kannst. Also wie machst Du eine lokale Variable?
 
Hier weiß ich nicht wie ich dieses := interpretieren soll
Das ist einfach eine Zuweisung, wobei der Doppelpunkt zur besseren Unterscheidung zum Vergleich (in Java "==") dient . In der Mathematik steht ":=" für "definiert als", Du kannst das also interpretieren als
"reichweite sei definiert als die Anzahl der Kilometer, die mit einem gegebenen Kraftstoffvorrat bei gegebenem Verbrauch gefahren werden kann".

Natürlich musst Du die Variable reichweite noch deklarieren (s. Antwort von @JustNobody).

Außerdem stimmt die Berechnung der Reichweite nicht ganz. Bei einem Verbrauch von 5 l/100 km und einem Tankinhalt von 20 l kannst Du wie weit fahren? 20 l * 100 km / 5 l = 400 km.

Bzgl. "wird reichweite Kilometer gefahren": ändert sich beim Fahren nur der Kilometerstand?
 
Das ist einfach eine Zuweisung, wobei der Doppelpunkt zur besseren Unterscheidung zum Vergleich (in Java "==") dient . In der Mathematik steht ":=" für "definiert als", Du kannst das also interpretieren als
"reichweite sei definiert als die Anzahl der Kilometer, die mit einem gegebenen Kraftstoffvorrat bei gegebenem Verbrauch gefahren werden kann".

Natürlich musst Du die Variable reichweite noch deklarieren (s. Antwort von @JustNobody).

Außerdem stimmt die Berechnung der Reichweite nicht ganz. Bei einem Verbrauch von 5 l/100 km und einem Tankinhalt von 20 l kannst Du wie weit fahren? 20 l * 100 km / 5 l = 400 km.

Bzgl. "wird reichweite Kilometer gefahren": ändert sich beim Fahren nur der Kilometerstand?
Java:
  public void fahren(int km){
    double reichweite;
    reichweite = km*verbrauch/100;
    if(reichweite<=kraftstoffVorrat){
      kmStand += km;
      kraftstoffVorrat-=reichweite;
    }
    else{
      kmStand += ((kraftstoffVorrat*100)/verbrauch);
      kraftstoffVorrat=0;
    }
Bitte nochmal prüfen.
Sieht meiner Meinung nach gut aus.
 
Zuletzt bearbeitet:
Ja, so rum geht es natürlich auch: dann ist aber "reichweite" der falsche Ausdruck. Das wäre dann eher streckenVerbrauch.
 
Ja, so rum geht es natürlich auch: dann ist aber "reichweite" der falsche Ausdruck. Das wäre dann eher streckenVerbrauch.
Nochmal vielen Dank. Hier nochmal mein Code:
Oberklasse Auto:
Java:
public void info(){
    System.out.println("Kilometerstand: "+kmStand);
    System.out.println("Verbrauch: "+verbrauch);
  }
 
  public String toString(){
    return "Kilometerstand "+kmStand+", Verbrauch "+verbrauch+", Tankvolumen "+tankVolumen+", Kraftstoffvorrat "+kraftstoffVorrat;
  }
 
  public void fahren(int km){
    double streckenverbrauch;
    streckenverbrauch = km*verbrauch/100;
    if(streckenverbrauch<=kraftstoffVorrat){
      kmStand += km;
      kraftstoffVorrat-=streckenverbrauch;
    }
    else{
      kmStand += ((kraftstoffVorrat*100)/verbrauch);
      kraftstoffVorrat=0;
    }
    
    
    /*for(int i=1;i<=km;i++){
      if((i*verbrauch)/100<=kraftstoffVorrat){
        kmStand++;
      
      }
      else{
        kraftstoffVorrat-=((i-1)*verbrauch)/100;
        break;
      }
    }
   kraftstoffVorrat-=(km*verbrauch)/100;*/
  }
    
  public void tanken(double liter){
    for(int i=1; i<=liter; i++){
      if(kraftstoffVorrat<tankVolumen){
        kraftstoffVorrat++;
      }
      else{
        break;
      }
    }
  }
}
Die Unterklasse Omnibus
Java:
class Omnibus extends Auto{
 
  private int anzahlSitze;
 
  public Omnibus(int kmStand, double verbrauch, double tankVolumen, double kraftstoffVorrat, int anzahlSitze){
    super(kmStand, verbrauch, tankVolumen, kraftstoffVorrat);
    this.anzahlSitze=anzahlSitze;
  }
 
  public String toString(){
    return super.toString()+", Anzahl Sitze "+anzahlSitze;
  }
}
Und meine Main
Java:
public class Autotest{
 
  public static void main( String[] args){
    
    /*Auto goggoMobil = new Auto(0,5.0,50,30);
    System.out.println("Anfang");
    System.out.println(goggoMobil.toString());
    goggoMobil.fahren(800);
    System.out.println("Nach der Fahrt");
    System.out.println(goggoMobil.toString());
    goggoMobil.tanken(45);
    System.out.println("Nach dem Tanken");
    System.out.println(goggoMobil.toString());
    */
    
    Omnibus goggoBus = new Omnibus(0,5.0,50,30,5);
    System.out.println(goggoBus.toString());
    goggoBus.fahren(300);
    System.out.println(goggoBus.toString());
  } 
}
 
Bis auf die Methode tanken() sieht das ok aus: die kannst Du ganz ähnlich wie fahren() ohne Schleife umsetzen, ist nur etwas einfacher :)
 
Passende Stellenanzeigen aus deiner Region:

Neue Themen

Oben