Sandhaufen Rechnung mit Schubkarre

[AndreasBaum]

Hallo Java Community,

ich bin neu hier und bringe auch direkt eine Frage mit. Wir haben vor 2 Wochen in unserer IT-Klasse (Fachabi, 11. Klasse) mit Java angefangen und haben natürlich erst mit dem theoretischen Teil angefangen. PAP (Programm Ablauf Pläne) und so weiter. Wenn man sich in die Denkweise noch nicht hereinversetzen kann, ist das ein ziemlich guter Anfang muss ich sagen.

Unser Lehrer hat in der letzten Woche ein Beispiel an die Tafel gemalt, welches wie folgt aussieht.

Punkt A: Derzeitiger Standort der Schubkarre, leere Fläche
Punkt B: Sandhaufen, 10 Schubkarrenladungen

Wie man sich nun denken kann, muss die Schubkarre von Punkt A nach Punkt B, dort eine Ladung abheben und wieder zu Punkt A bringen, bis der Sandhaufen bei Punkt B 0 ist (Wiederholung bis 0).

Es ist zwar keine notwendige Hausaufgabe, aber wer sich damit vertraut machen will, kann sich schonmal in den Editor einarbeiten. Dies habe ich getan, komme allerdings überhaupt nicht zurecht, da mir der Syntax total fremd ist und ich das notwendige "Java-Denken" wohl auch noch nicht beherrsche.

Ich hab nun die Frage an euch, wie muss der Quellcode aussehen, damit das funktioniert?

Ich habe schon eine Überlegung für das Ganze, allerdings haperts an der Umsetzung.. hier mal meine Überlegung:

• Start
• Schubkarre fährt nach Punkt B (Textausgabe)
• Schubkarre hebt eine Ladung des Sandhaufens ab (Sandhaufen B -1)
• Schubkarre fährt zurück nach Punkt A (Textausgabe)
• Schubkarre läd Ladung ab (Sandhaufen A +1)
• Allgemeine Überprüfung (Wenn Sanhaufen B < als 1, dann zu Ende springen, ansonsten zu Start springen)
• Ende (Textausgabe)

Kann mir jemand erklären wie ich das umsetzen kann? Am besten mit der einfachsten Methode, ohne viel erforderliches Wissen, so dass ich das nachvollziehen kann.

Ich bin dankbar über jede hilfreiche Antwort.

Auf eine gute Zusammenarbeit in dem Forum.


Mit freundlichen Grüßen
Andreas Baum

 

[Guest]

als erstes brauchst du ein int, das die größe des Sandhaufens B angibt, das erstellst du und weißt den wert 10 zu mit:
int haufenB = 10;
dann noch ein int, um Sandhaufen A darzustellen, mit Anfangswert 0:
int haufenA = 0;

jetzt brauchst du eine Schleife, die so immer wieder durchläuft, bis haufenB < 1 ist:

while(haufenB >= 1){


}


jetzt kannst du die Schleife füllen:


while(haufenB >= 1){
System.out.println("bin bei Sandhaufen B");

haufenB = haufenB - 1;

System.out.println("jetzt bin ich wieder bei Sandhaufen A");

haufenA = haufenA + 1;

}

 

[Miggel]

ich hoffe, der code erklärt sich von alleine:

public class Sandkasten{

    public int ladungB = 10;
    public int ladungA = 0;
    
    public Sandkasten(){

      schubkarrenFahren();                  //Methodenaufruf

    }

    public void schubkarrenFahren(){

      for(int i=ladungB;i>0;i--){         //Schleife, wird 10mal durchgeführt

         System.out.println("Schubkarren fährt zu B");
         ladungB = ladungB - 1; //Kann auch: ladungB--;
         System.out.println("Verbleibende Ladungen bei B: "+String.valueOf(ladungB));
         System.out.println("Schubkarren fährt zu A");
         ladungA = ladungA + 1; //  ladungA++
         System.out.println("Ladungen bei A: "+String.valueOf(ladungA));
      }
      
      
      System.out.println("Ladungen bei A: "+String.valueOf(ladungA));
      System.out.println("Ladungen bei B: "+String.valueOf(ladungB));
    }


  public static void main(String[] args){       //Diese Methode wird ganz am ANfang gestartet
       new Sandkasten();
  }

}

 

[AndreasBaum]

Herzlichen Dank euch Beiden!

@Miggel: Ich schreib' mal ein paar Kommentare in deinen Code, ob ich alles richtig verstanden habe.

ich hoffe, der code erklärt sich von alleine:

public class Sandkasten{

//Klassendefinition (oder wie man das nennt)

    public int ladungB = 10;

//Wert für Haufen B

    public int ladungA = 0;

//Wert für Haufen A
    
    public Sandkasten(){

//Die oben-erstellte Sandkastenklasse wir hier aufgerufen, damit die "Funktion" zugewiesen werden kann, oder?

      schubkarrenFahren();                  //Methodenaufruf

    }

    public void schubkarrenFahren(){

      for(int i=ladungB;i>0;i--){         //Schleife, wird 10mal durchgeführt

//Das ist eine Bedingung oder? Also wenn Ladung B größer als 0 ist, wird alles wiederholt.

         System.out.println("Schubkarren fährt zu B");
         ladungB = ladungB - 1; //Kann auch: ladungB--;
         System.out.println("Verbleibende Ladungen bei B: "+String.valueOf(ladungB));
         System.out.println("Schubkarren fährt zu A");
         ladungA = ladungA + 1; //  ladungA++
         System.out.println("Ladungen bei A: "+String.valueOf(ladungA));
      }
     
//Textausgabe 
      
      System.out.println("Ladungen bei A: "+String.valueOf(ladungA));
      System.out.println("Ladungen bei B: "+String.valueOf(ladungB));
    }

//Weitere Textausgaben

  public static void main(String[] args){       //Diese Methode wird ganz am ANfang gestartet
       new Sandkasten();
  }

//Das hier versteh ich nicht ganz, wieso steht das am Ende vom Code, wenn die Methode schon am Anfang gestartet wird?

}

Hat mir aufjedenfall weitergeholfen, ich versuch es mal zu kompilieren.

Mit freundlichen Grüßen
Andreas Baum

 

[Guest]

wenn ein code gestartet wird, sucht java nach der main-class (in diesen Fall in zeile 44) und führt sie durch.
public Sandkasten() ruft garnix auf, es muss erst von der main-classe aus gestartet werden, indem eine neue instanz von Sandkasten erschaffen wird (zeile 45: new Sandkasten(); )

 

[Miggel]

Also, ich versuch mal den Quelltext zu erklären. Wenn man ein Java Programm ausführt wird immer zuerst die main-Methode(Zeile44) ausgeführt. In diesem Fall ruft die Main-Methode den Konstruktor der Klasse Sandkasten auf (new Sandkasten() ). Nun wird im Konstruktor (bitte nachlesen, falls du nicht weist was ein Konstruktor ist) die Methode schubkarrenFahren() aufgerufen.
So jetzt gehts um den Abschnitt:

      for(int i=ladungB;i>0;i--){        

     System.out.println("Schubkarren fährt zu B");
         ladungB = ladungB - 1; //Kann auch: ladungB--;
         System.out.println("Verbleibende Ladungen bei B: "+String.valueOf(ladungB));
         System.out.println("Schubkarren fährt zu A");
         ladungA = ladungA + 1; //  ladungA++
         System.out.println("Ladungen bei A: "+String.valueOf(ladungA));
      }

int i=ladungB bedeutet, die Variable i wird in diesem Fall auf 10 gesetzt => i=10
i>0 => Solange i größer als 0 ist, wird die Schleife (die Operationen zwischen den geschweiften Klammern ausgeführt)
jedesmal, wenn eine komplette Schleife durchlaufen ist, wird i um eins vermindert, d.h. irgendwann ist i=0 und die Schleife wird nicht mehr ausgeführt.

Da der Schubkarren jetzt 10 mal hin und her gefahren ist, wird die Schleife beendet und es geht weiter im Programm:

      System.out.println("Ladungen bei A: "+String.valueOf(ladungA));
      System.out.println("Ladungen bei B: "+String.valueOf(ladungB));

In diesem Fall wird nun nur noch die aktuellen Ladungen der Haufen ausgegeben:
ladungA =10
ladungB =0

mfg
Miggel

 

[AndreasBaum]

Okay, hab den Code ein wenig abgeändert.

public class Sandkasten2{

    public int ladungB = 10;
    public int ladungA = 0;

    public Sandkasten2(){

      schubkarrenFahren();

    }

    public void schubkarrenFahren(){

           System.out.println("----------");
           System.out.println("");
           System.out.println("* Starte Schubkarren-Script..");
           System.out.println("");
           System.out.println("----------");
           System.out.println("");
           System.out.println("Schubkarre befindet sich bei Punkt A");
           System.out.println("Aktuelle Sandladungen bei Punkt A: "+String.valueOf(ladungA));
           System.out.println("Aktuelle Sandladungen bei Punkt B: "+String.valueOf(ladungB));
           System.out.println("");

      for(int i=ladungB;i>0;i--){

         System.out.println("Schubkarre fährt zu Punkt B");
         System.out.println("Schubkarre läd Sand auf");
         ladungB = ladungB - 1;
         System.out.println("Aktuelle Sandladungen bei Punkt B: "+String.valueOf(ladungB));
         System.out.println("");
         System.out.println("Schubkarre fährt zu Punkt A");
         System.out.println("Schubkarre läd Sand ab");
         ladungA = ladungA + 1;
         System.out.println("Aktuelle Sandladungen bei Punkt A: "+String.valueOf(ladungA));
         System.out.println("");
      }


      System.out.println("----------");
      System.out.println("");
      System.out.println("* Überprüfe Ergebnisse..");
      System.out.println("");
      System.out.println("----------");
      System.out.println("");
      System.out.println("Schubkarre befindet sich bei Punkt A");
      System.out.println("Aktuelle Sandladungen bei Punkt A: "+String.valueOf(ladungA));
      System.out.println("Aktuelle Sandladungen bei Punkt B: "+String.valueOf(ladungB));
      System.out.println("");
      System.out.println("----------");
      System.out.println("");
      System.out.println("* Schubkarren-Script erfolgreich beendet..");
      System.out.println("");
      System.out.println("# Changed 04-10-2008 04:44 PM");
      System.out.println("");
      System.out.println("----------");

    }


  public static void main(String[] args){
       new Sandkasten2();
  }

}

Ist das okay vom Code her? Das Compile-Ergebnis gefällt mir jedenfalls ^^

 

[Guest]

jop ist ok, der code ist halt durch die vielen System.outs ziemlich lang.
Wenn du denn kürzer haben willst, könntest du auch sowas machen:

statt
System.out.println("");
System.out.println("----------");
System.out.println("");

in schubkarrenFahren() schreibst du immer:

seperator();

dann brauchste nurnoch die methode:

public void seperator(){
System.out.println("");
System.out.println("----------");
System.out.println(""); }


würde denn code ein bissel kürzen, is aber eig. egal

 

[AndreasBaum]

Ah, aber die Bezeichnung 'seperator' hast du gegeben, oder? Also ist keine Vorgabe. Also könnte ich auch das ganze so definieren?

public void blub(){
System.out.println("");
System.out.println("----------");
System.out.println(""); }

und dann halt im Code mit blub(); einfügen?

 

[anderer Gast]

Genau