Verständnis Probleme bei der while-Schleife und continue

W

werdas34

Bekanntes Mitglied
Hallo,

ich bin Anfänger was das programmieren angeht und habe folgendes Problem:
Ich habe das Spiel Zahlenraten mit mehreren while-Schleifen realiseirt. 😀
Nun wollte ich es erweitern. Wenn man auf Abbrechen drückt erscheint die Meldung "Bist du dir sicher?" Ja oder Nein. Drückt man auf nein sollte man wieder zum Anfang gelangen. Dies tut er jedoch nicht sondern kehrt wieder zur Bist du dir Sicher? Aufforderung zurück. Was ich nicht ganz verstehe.

Code: 
import javax.swing.JOptionPane;

public class RichtigesZahlenraten
{

    public static void main(String[] args) {
 
    {
     
        boolean dauerschleife = false;
        while(!dauerschleife)
        {
     
        boolean again = false;
        int nochmal = 0;
        boolean allein = false;
        boolean safe = false;
        int sicher = 0;
        int spielwahl = 0;
        String eingabeSucheZahl = "";
        String eingabeFindungZahl = "";
        int sucheZahl = 0;
        int findeZahl = 0;
        int versuche = 0;
        boolean erraten = false;
     
        //Auswahl ob man alleine spielt oder zuzweit oder garnicht mehr spielen möchte
        spielwahl = JOptionPane.showConfirmDialog(null, "Willst du das Spiel Zahlenraten alleine spielen?");     
 
        //Spielauswahl und das Erzeugen der zu Suchenden Zahl
        while(!allein)
          {
              if(spielwahl == 0)
              {
              //Suchende Zahl mit Random erzeugen
              sucheZahl = (int) (Math.random()*1000+1);
              allein = true;
              }
              if(spielwahl == 1)
              {
              //Eingabe der gesuchten Zahl
              eingabeSucheZahl = JOptionPane.showInputDialog("Bitte geben Sie eine Zahl zwischen 1 und 1000 ein!");
              sucheZahl = Integer.parseInt(eingabeSucheZahl);
              allein = true;
              }
              //Abbrechen Funktion
              if(spielwahl == 2)
              {
                  sicher = JOptionPane.showConfirmDialog(null, "Bist du dir sicher?", "Zahlenraten1000", JOptionPane.YES_NO_OPTION);
                  safe = true;
              }
              while(safe)
            {
                  if(sicher == 0)
              {
              JOptionPane.showMessageDialog(null, "Komm bald wieder!");
              System.exit(0);
              }
                  if(sicher == 1)
              {
              safe = false;
              System.out.println("Test!");
              continue;
              }
            }
              }
        }
    }
    }
}

Ich verstehe das ganze nicht so ganz. Durch klicken des Button Nein wird safe auf false gesetzt damit ich aus der Schleife rauskomme und dann sollte (zumindest meines Wissens nach) wieder von vorne Angefangen werden da die erste Schleife (dauerschleife) immer noch auf true ist.
Und was genau ist der Schleifenkopf einer while Schleife?
Da continue; laut Tutorial zurück zum Schleifenkopf führt, wo ist dann wie bei mir der Schleifenkopf wenn mehrer while-Schleilfen verschachtelt sind?

Oder wie realsiert man sonst eine Art Dauerschleife?

Danke für jede hilfreiche Antwort
mfg
werdas34
 
Zuletzt bearbeitet:
Hey, Zustandsautomat, und das ganze einmal auf Papier aufzeichnen.

Alternativ in Methoden extrahieren.

Kann mich später mal daran begeben.
 
Danke für die schnelle Antwort.
Ich bin noch ganz am Anfang von Java, deswegen die wahrscheinlich sehr umständliche Realisierung des Spiels. Ich kenne mich bisschen mit Methoden aus aber nicht besonders. 🙁

Vorallem würde ich halt gerne wissen wieso es bei mir nicht funktioniert. Entweder hab ich einen Logikfehler im Kopf oder habe irgendwas noch nicht richtig verstanden.

Aber gerne darfst du eine andere Lösung vorschlagen, aber bitte dann auch erläutern was die so kann. 🙂
 
Continue bezieht sich nur auf die Schleife auf die es angewandt wird, also keine die darüber oder darunter liegt. Entferne einfach das continue, da die (innere) While eh aufhört weil safe nicht mehr true ist
 
Ok danke.
continue bezieht sich immer auf die Schleife in der es steht. Gut zu wissen.

Auch wenn ich continue rauslösche hab ich das selbe Problem.
Ich nutze Eclipse falls das weiterhilft, wobei ich das stark bezweifle.
 
werdas34 hat gesagt.:
Wenn man auf Abbrechen drückt erscheint die Meldung "Bist du dir sicher?" Ja oder Nein. Drückt man auf nein sollte man wieder zum Anfang gelangen.
Zum Vergrößern anklicken....
Du könntest mit break die mittlere Schleife verlassen, falls der Nein-Button geklickt wird. Dann wird ja auch das Ende der äußeren Schleife erreicht, so daß sie ihre nächste Iteration startet:
Java: 
if (sicher==JOptionPane.NO_OPTION) {
    break;
}
 
(ungelabeltes) continue bezieht sich immer auf die direkt "umliegende" Schleife, nicht auf if's oder andere Kontrollstrukturen - oder "höhergelegene" Schleifen, etc. Aber ich bewege mich gleich noch mal da dran.
 
Hier, so hätte ich das gemacht:
Java: 
    /**
     * Calcs some things ....
     *
     * @param args images a, b, and c.
     * @throws java.io.IOException
     */
    public static void main(String[] args) throws IOException {
        // Deklariere hier viele Varaiblen....
        int find = -1;
        BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
        /*
        Beschreibe hier die Modes....
         */
        int mode = 0;
        while (true) {
            if (mode == 0) {
                System.out.println("alleine (1) oder zu zweit (2)?:");
                if (Integer.parseInt(in.readLine()) == 1) {
                    mode = 1;
                } else {
                    mode = 3;
                }
            } else if (mode == 1) {
                find = (int) (Math.random() * 1000) + 1;
                mode = 2;
            } else if (mode == 2) {
                System.out.println("Du rätst:");
                int r = Integer.parseInt(in.readLine());
                if (r < find) {
                    System.out.println("Die gesuchte Zahl ist größer");
                } else if (r > find) {
                    System.out.println("Die gesuchte Zahl ist kleiner");
                } else {
                    System.out.println("Glückwunsch, du hast gewonnen!!!!");
                    mode = 0;
                }
            } else if (mode == 3) {
                find = (int) (Math.random() * 1000) + 1;
                mode = 4;
            } else if (mode == 4) {
                System.out.println("Erster Spieler rät:");
                int r = Integer.parseInt(in.readLine());
                if (r < find) {
                    System.out.println("Die gesuchte Zahl ist größer");
                    mode = 5;
                } else if (r > find) {
                    System.out.println("Die gesuchte Zahl ist kleiner");
                    mode = 5;
                } else {
                    System.out.println("Glückwunsch, erster Spierler gewinnt!!!!");
                    mode = 0;
                }
            } else if (mode == 5) {
                System.out.println("Zweiter Spieler rät:");
                int r = Integer.parseInt(in.readLine());
                if (r < find) {
                    System.out.println("Die gesuchte Zahl ist größer");
                    mode = 4;
                } else if (r > find) {
                    System.out.println("Die gesuchte Zahl ist kleiner");
                    mode = 4;
                } else {
                    System.out.println("Glückwunsch, zweiter Spieler gewinnt!!!!");
                    mode = 0;
                }
            }
        }
    }

Und noch eine ausgabe:
Code: 
alleine (1) oder zu zweit (2)?:
2
Erster Spieler rät:
100
Die gesuchte Zahl ist größer
Zweiter Spieler rät:
177
Die gesuchte Zahl ist größer
Erster Spieler rät:
999
Die gesuchte Zahl ist kleiner
Zweiter Spieler rät:
555
Die gesuchte Zahl ist kleiner
Erster Spieler rät:
250
Die gesuchte Zahl ist kleiner
Zweiter Spieler rät:
222
Die gesuchte Zahl ist kleiner
Erster Spieler rät:
180
Die gesuchte Zahl ist größer
Zweiter Spieler rät:
195
Die gesuchte Zahl ist größer
Erster Spieler rät:
205
Die gesuchte Zahl ist größer
Zweiter Spieler rät:
209
Die gesuchte Zahl ist kleiner
Erster Spieler rät:
208
Die gesuchte Zahl ist kleiner
Zweiter Spieler rät:
207
Glückwunsch, zweiter Spieler gewinnt!!!!
alleine (1) oder zu zweit (2)?:
1
Du rätst:
500
Die gesuchte Zahl ist kleiner
Du rätst:
250
Die gesuchte Zahl ist kleiner
Du rätst:
100
Die gesuchte Zahl ist größer
Du rätst:
150
Die gesuchte Zahl ist größer
Du rätst:
160
Die gesuchte Zahl ist größer
Du rätst:
170
Die gesuchte Zahl ist kleiner
Du rätst:
165
Glückwunsch, du hast gewonnen!!!!
alleine (1) oder zu zweit (2)?:
Nee
Exception in thread "main" java.lang.NumberFormatException: For input string: "Nee"

Bitte beachten, dass eine Benutzereingabe immer validiert und ggf wiederholt werden muss - dazu böte sich eine Methode an. 🙂
 
@Meniskusschaden:
hab jetzt da wo vorhin continue; stand, durch break ersetzt.
Das Problem ist das selbe xD.
@DerWissende:
Danke für die Mühe. Ich werde mich da mal reinlesen.

Aber ich würde gern halt wissen warum meine Version nicht geht.
Ich mein, klickt man bei der Aufforderung "Bist du dir sicher?" auf Nein wird die Schleife safe geöffnet und man geht wieder aus der Schleife, da safe == false ist. Da aber die Schleife dauerschleife noch offen ist müsste ich quasi wieder zum Anfang gelangen.

Könnt ihr mir zumindest sagen ob meine Logik tatsächlich Sinn machen würde und theoretisch funktionieren müsste. 😀
 
werdas34 hat gesagt.:
@Meniskusschaden:
hab jetzt da wo vorhin continue; stand, durch break ersetzt.
Das Problem ist das selbe xD.
Zum Vergrößern anklicken....
Warum hast du es denn dort gemacht und nicht an der Stelle, die ich vorgeschlagen hatte?
werdas34 hat gesagt.:
Aber ich würde gern halt wissen warum meine Version nicht geht.
Ich mein, klickt man bei der Aufforderung "Bist du dir sicher?" auf Nein wird die Schleife safe geöffnet und man geht wieder aus der Schleife, da safe == false ist. Da aber die Schleife dauerschleife noch offen ist müsste ich quasi wieder zum Anfang gelangen.
Zum Vergrößern anklicken....
Dadurch verlässt du zwar die innere Schleife, aber nicht die mittlere Schleife, die durch die Variable allein gesteuert wird.
 
Es scheint überhaupt keinen Fall zu geben, in dem du die innere Schleife mehrmals durchlaufen willst und du kämpfst offenbar damit, sie wieder zu verlassen. Wofür hast du die Schleife eigentlich überhaupt vorgesehen?
 
Sorry :O
Tut mir leid. Du meintest die mittlere Schleife. Ok danke. Die Meldung verschwindet wieder.
Aber das wäre auch gegangen, wenn man auf Nein drückt das safe auf false und dazu die Variable allein auf true geschaltet wird oder? Denn am Ende werden die Variabeln wieder zurückgesetzt.

Die allein Schleife dient dazu ob ich quasi mit Math.Random eine Zahl erzeuge, eine Eingabe für den Benutzer ermögliche oder eben ob der Benutzer abbrechen möchte. Und will man nochmal spielen (das kommt noch) muss ja wieder eine Zahl erzeugt werden bzw der Benutzer dazu aufgefordert werden.
Ich denke mal es gibt viel einfachere und effizientere Methoden diese Aufgabe zu realsieren. Aber ich bin Anfänger und habe gehört das die while Schleife ernorm wichtig ist, daher auch diese Übung mit vielen while Schleifen.
 
Stimmt die safe Schleife hätte man bestimmt anders, vorallem eleganter lösen können. Bei Ja wird das Programm geschlossen und bei Nein kommt man wieder zum Anfang.
Nur da ich gerne eine Nochmal spielen Funktion einbauen möchte, und ich es bisjetzt theoretisch nur so lösen kann, indem ich viele while Schleifen baue. Brauche ich eine Schleife wird die auf true gestellt und ich kann sie verlassen in dem ich sie false schalte. Sind alle geschlossen bis auf die übergeordnetste, komm ich theoretisch wieder zum Anfang. 😀

Meniskusschaden hat gesagt.:
Ja, ich glaube, das hätte auch funktioniert.
Zum Vergrößern anklicken....
Ja, es funktioniert. 😀
 
werdas34 hat gesagt.:
Stimmt die safe Schleife hätte man bestimmt anders, vorallem eleganter lösen können. Bei Ja wird das Programm geschlossen und bei Nein kommt man wieder zum Anfang.
Nur da ich gerne eine Nochmal spielen Funktion einbauen möchte, und ich es bisjetzt theoretisch nur so lösen kann, indem ich viele while Schleifen baue. Brauche ich eine Schleife wird die auf true gestellt und ich kann sie verlassen in dem ich sie false schalte. Sind alle geschlossen bis auf die übergeordnetste, komm ich theoretisch wieder zum Anfang. 😀
Zum Vergrößern anklicken....
Du hast dort doch bereits eine Fallunterscheidung, die in beiden Fällen dazu führt, dass die Schleife verlassen wird. Dann kannst du die Schleife doch gleich ganz weglassen und nur die Fallunterscheidung behalten.
 
Meniskusschaden hat gesagt.:
Du hast dort doch bereits eine Fallunterscheidung, die in beiden Fällen dazu führt, dass die Schleife verlassen wird. Dann kannst du die Schleife doch gleich ganz weglassen und nur die Fallunterscheidung behalten.
Zum Vergrößern anklicken....
Ich verstehe nicht ganz was du meinst.
Meinst du die Fallunterscheidung "Willst du Zahlenraten .... spielen?" Ja Nein Abbrechen
Von den drei Auswahlmöglichkeiten sind sind zwei definiert (Ja/Nein). Und du meinst jetzt die Abbrechen Schleife ?
Oder reden wir grad aneinander vorbei ?
Ich könnte sie ohne Schleife platzieren. Aber da besteht die Gefahr das plötzlich die Meldung Bist du dir sicher? auftaucht ohne das sie da hingehört. Also wenn man sie irgendwo gut platzieren kann, braucht man keine Schleife. Und ich sehe die Schleife bisschen wie eine Schublade. Einen Schritt bevor du die Schublade safe aufmachen willst, musst du sie auf true stellen. Ist die Schublade offen und der Inhalt ausgeben (in dem Fall Bist du dir sicher?) wird sie durch false geschlossen. Ich versteh schon die Schleife durchläuft nur einmal den Prozess und das ist vermutlich unnötig. Aber ich behalte mir den Gedanken im Hinterkopf, falls ich mal alles so habe wie ich es mir vorstelle, und while besser verstaden habe. Dann versuche ich die eine Schleife aufzulösen. Aber im Moment bin ich froh wenn es funktioniert. 😀
 
Ich meine diese Schleife:
Java: 
while (safe) {
    if (sicher == 0) {
        JOptionPane.showMessageDialog(null, "Komm bald wieder!");
        System.exit(0);
    }
    if (sicher == 1) {
        safe = false;
        System.out.println("Test!");
        continue;
    }
}
Falls sicher==0odersicher==1wird die Schleife oder sogar das gesamte Programm bereits beim ersten Durchlauf beendet. Falls keine der Bedingungen zutrifft, wird die Schleife nie wieder beendet.
 
Es kann nur der Fall sicher == 0 bzw sicher == 1 da ich ja eine Ja/Nein Aufforderung zum Klicken vorgebe.
Klickt man auf ja wird der Fall sicher == 0 ausgeführt klickt man auf nein wird der andere ausgeführt.
 
Gut. An sowas müsste man als Profi drandenken bzw. so einer würde es denn eh anders machen.
Zum Beispiel kann man bei mir auch eine Zahl höher als 1000 eingeben obwohl man nur bis 1000 raten darf.
 
werdas34 hat gesagt.:
@DerWissende:
Danke für die Mühe. Ich werde mich da mal reinlesen.
Zum Vergrößern anklicken....

Ist kein Magierding, du siehst, ich hab einfach nur ein "Entwurfsmuster" angewandt, und benötigte nur 2 Variablen.

Du müsstest unbedingt eine Methode:
Java: 
    private static boolean jaNeinMitText(String text) {
        int o;
        do {
            o = JOptionPane.showConfirmDialog(null, text);
        } while (o == JOptionPane.CANCEL_OPTION || o == JOptionPane.CLOSED_OPTION);
        return o == JOptionPane.YES_OPTION;
    }

"einfügen"....

(Wobei o leicht mit 0 zu verwechseln ist, etwas blöde Wahl.)
 

Aktuelle Jobs

Neue Themen

Ähnliche Themen

Verständnis - Frage mehrere SQL Statements in While Schleife
Antworten: 0
verschachtelte For-Schleife - continue
Antworten: 8
Schleife von anderer Methode stoppen? (Start continue)
Antworten: 18
continue in verschachtelter Schleife
Antworten: 6
Unterschied zwischen break und continue in einer Schleife
Antworten: 14

Zurück
Oben