Endlosschleife

Status
Nicht offen für weitere Antworten.
Antoras

Antoras

Top Contributor
Hi,

hab ein Problem mit meiner do-while-Schleife:
Code: 
import javax.swing.*;
import java.awt.*;
import java.awt.event.*;

public class Zahlenspiel extends JApplet{
	private int counter = 0, zahl, zufall;
	
	private JTextField tf = new JTextField(8);
	private JLabel lb1 = new JLabel("Zahl zwischen 1 und 100 eingeben");
	private JLabel lb2 = new JLabel("");
	private JLabel lb3 = new JLabel("");	
	
	public Zahlenspiel(){	
		setLayout(new FlowLayout());	
		JButton b = new JButton("Prüfen");
		b.addActionListener(new ActionListener(){
        	public void actionPerformed(ActionEvent e){
        		pruefen();
        	}
		});
		add(lb1);
		add(tf);
		add(b);
		add(lb2);
		add(lb3);
		zufall = (int)(99*Math.random()+1);
	}	
	public void pruefen(){		
		System.out.println(""+zufall);
		do{
			zahl = Integer.parseInt(tf.getText());
			counter = counter++;
			lb2.setText(""+counter);
			if(zahl < zufall){
				lb3.setText("Zufallszahl ist größer");
			}else if(zahl > zufall){
				lb3.setText("Zufallszahl ist kleiner");
			 }else{
			 	lb3.setText("Zufallszahl ist gleich");	
			  }	 					
		}
		while(zahl == zufall);
	}
}
Das Problem ist, dass ich jetzt eine Endlosschleife hab. Erst wenn die eingegebene Zahl gleich der Zufallszahl ist ist das Programm zu Ende. Wie sage ich der Schleife, dass sie nach jedem Durchlauf auf eine neue Eingabe warten soll?

Zweites Problem: Der Counter geht nicht. Es wird nach jedem Durchlauf nur eine 0 angezeigt (wenn man den befehl der Zufallszahl in die pruefen-Methode schreibt).
 
Ah ja, jetzt geht es. Danke dir!

Hatte am Anfang nur eine Methode, da hab ich die Schleife gebraucht, aber so ist es natürlich tausendmal besser.
 
parabool hat gesagt.:
Schreibe nur counter++ oder counter=counter+1 (Langform)
Zum Vergrößern anklicken....
Diese beiden Ausdrücke sind nicht exakt gleich. Die Abkürzung für x=x+1 ist ++x, nicht x++. Die Semantik von x++ verstehen 90% der Programmieranfänger nicht.

(Sofern diese Ausdrücke nicht in größere Ausdrücke eingebettet sind, macht es aber keinen Unterschied.)
 
ja Postfix und Präfix. Hab nicht darauf geachtet
In dem Zusammenhang war's auch egal.

Aber hast natürlich recht. Man sollte präzise sein.

mmh...Programmieranfänger ? ... :shock:
 
Mir egal ob das x++ oder ++x heißt. Mal solange wie der Unterschied für mich nicht von Bedeutung ist.


Ich hätte da aber gerade nochmal ein Problem mit einer Endlosschleife:

Ich hab Textfelder eines "Magischen Quadrates" mit 2 Schleifen erstellt. Ich möchte, dass der Inhalt waagrecht und senkrecht immer 15 ergibt. So weit so gut. Weiter möchte ich, dass die Zahlen in den Textfelder solange gemischt werden bis dies eben auf alle Reihen (6Stück) zutrifft.

Code: 
private void mischen(){
       prüffinal = false;
       //Mischen der Zahlen
       do{
           for (int i=0; i<yway; i++){
               for (int j=0; j<xway; j++){
                   int zufalli = (int)(yway*Math.random());
                   int zufallj = (int)(xway*Math.random());
                   int blubb = zahlen[zufalli][zufallj];
                   zahlen[zufalli][zufallj] = zahlen[i][j];
                   zahlen[i][j] = blubb;
               }
           }
           for (int i=0; i<yway; i++){
               for (int j=0; j<xway; j++){
                   tf[i][j].setText(String.valueOf(zahlen[i][j]));
               }
           }
           //Überprüfung der Zahlen
           for (int i=0; i<yway; i++){
               for (int j=0; j<xway; j++){
                   summe[i] += zahlen[i][j];
                   prüf = summe[i];
               }
           }
           for (int i=0; i<xway; i++){
               for (int j=0; j<yway; j++){
                   summe[i+yway] += zahlen[j][i];
                   prüfnochmal = summe[i+yway];
               }
           }
           for (int i=0; i<summe.length; i++){
               lb[i].setText(String.valueOf(summe[i]));
           }
           if((prüf == 15) && (prüfnochmal == 15)){
              prüffinal = true;
           }               
       }
       while(!prüffinal);
    }
prüffinal ist ein boolean-Wert, die anderen beiden prüf sind int-Werte.

Ich weiß wo der Fehler liegt (glaube ich): prüf und prüfnochmal können nie 15 sein, da sie ja die Schleifen sind, die insgesamt 9 Textfelder zusammenzählen.
Am Anfang hab ich die Werte der Arrays alle einzeln zusammengezählt (also prüf=array[0]+array[1]...). Das war mir jedoch zu umständlich.
Gibt es da eine andere Möglichkeit wie man immer nur 3 Felder zusammenzählt, oder kann man das die alle nur so umständlich zusammenzählen?

Hier noch die komplette Klasse:
Code: 
import javax.swing.*;
import java.awt.*;
import java.awt.event.*;

public class MagischesQuadrat extends JApplet{
    private JTextField tf[][];
    private JLabel lb[];
    
    private int xway = 3, yway = 3, zahlen[][], summe[];
    boolean prüffinal;
    int prüf, prüfnochmal;

    public MagischesQuadrat(){
        getContentPane().setLayout(new BorderLayout());
        JPanel p = new JPanel(new FlowLayout());
        JButton b = new JButton("Start");
        b.addActionListener(new ActionListener(){
           public void actionPerformed(ActionEvent e){
                erstellen();
            }
        });
        p.add(b);
        b = new JButton("Mischen");
        b.addActionListener(new ActionListener(){
            public void actionPerformed(ActionEvent e){
                mischen();
            }
        });
        p.add(b);
        b = new JButton("Prüfen");
        b.addActionListener(new ActionListener(){
            public void actionPerformed(ActionEvent e){
                prüfen();
            }
        });
        p.add(b);
        getContentPane().add(p, BorderLayout.NORTH);

        zahlen = new int[yway][xway];
        tf = new JTextField[yway][xway];
        p = new JPanel(new GridLayout(yway, xway));
        for (int i=0; i<yway; i++){
            for (int j=0; j<xway; j++){
                tf[i][j] = new JTextField();
                p.add(tf[i][j]);
            }
        }
        getContentPane().add(p, BorderLayout.CENTER);

        summe = new int[yway + xway];
        lb = new JLabel[yway + xway];
        p = new JPanel(new GridLayout(1, yway + xway));
        for (int i=0; i<yway+xway; i++){
            lb[i] = new JLabel(" ");
            p.add(lb[i]);
        }
        getContentPane().add(p, BorderLayout.SOUTH);
    }
    private void erstellen(){
        int counter = 1;
        
        for (int i=0; i<yway; i++){
            for (int j=0; j<xway; j++){
               zahlen[i][j] = counter++;
                tf[i][j].setText(String.valueOf(zahlen[i][j]));
            }
        }        
    }
    private void mischen(){
       prüffinal = false;
       //Mischen der Zahlen
       do{
           for (int i=0; i<yway; i++){
               for (int j=0; j<xway; j++){
                   int zufalli = (int)(yway*Math.random());
                   int zufallj = (int)(xway*Math.random());
                   int blubb = zahlen[zufalli][zufallj];
                   zahlen[zufalli][zufallj] = zahlen[i][j];
                   zahlen[i][j] = blubb;
               }
           }
           for (int i=0; i<yway; i++){
               for (int j=0; j<xway; j++){
                   tf[i][j].setText(String.valueOf(zahlen[i][j]));
               }
           }
           //Überprüfung der Zahlen
           for (int i=0; i<yway; i++){
               for (int j=0; j<xway; j++){
                   summe[i] += zahlen[i][j];
                   prüf = summe[i];
               }
           }
           for (int i=0; i<xway; i++){
               for (int j=0; j<yway; j++){
                   summe[i+yway] += zahlen[j][i];
                   prüfnochmal = summe[i+yway];
               }
           }
           for (int i=0; i<summe.length; i++){
               lb[i].setText(String.valueOf(summe[i]));
           }
           if((prüf == 15) && (prüfnochmal == 15)){
              prüffinal = true;
           }               
       }
       while(!prüffinal);
    }
    private void prüfen(){
       /*test = false;  
       
           for (int i=0; i<yway; i++){
               for (int j=0; j<xway; j++){
                   summe[i] += zahlen[i][j];
                   test1 = summe[i] == 15;
               }
           }
           for (int i=0; i<xway; i++){
               for (int j=0; j<yway; j++){
                   summe[i+yway] += zahlen[j][i];
                   test2 = summe[i+yway] == 15;
               }
           }
           for (int i=0; i<summe.length; i++){
               lb[i].setText(String.valueOf(summe[i]));
           }*/
    }
}
 
/push

Falls ich das Problem nicht richtig beschrieben habe:
Felder eines Arrays sollen addiert und die Summe soll verglichen werden. Arrays kann man ja mit array[0]+array[1]+array[3]... addieren. Ich suche aber nach einer Möglichkeit wie man das "einfacher" machen kann.
Dies soll aber auch möglich sein wenn man das Array mit einer Doppelschleife erstellt werden. Das führt nämlich dazu, das Felder waggrecht/senkrecht nebeneinander angeordnet werden. Deren Inhalt möchte ich zusammenzählen, allerdings nicht alle Felder, sondern immer nur die Felder von Spalte 1, Spalte 2, ... und Zeile 1, Zeile 2, ...

Geht das irgendwie?
 
Bei magischen Quadraten zählen aber auch die Diagonalen oder ?

kopier mal das in deinen code rein:

Code: 
private void mischen() {
		prüffinal = false;
		// Mischen der Zahlen
		new Thread() {
			public void run() {

				do {
					for (int i = 0; i < yway; i++) {
						for (int j = 0; j < xway; j++) {
							int zufalli = (int) (yway * Math.random());
							int zufallj = (int) (xway * Math.random());
							int blubb = zahlen[zufalli][zufallj];
							zahlen[zufalli][zufallj] = zahlen[i][j];
							zahlen[i][j] = blubb;
								
						}
					}
					for (int i = 0; i < yway; i++) {
						for (int j = 0; j < xway; j++) {

							tf[i][j].setText(String.valueOf(zahlen[i][j]));
						}
					}

					prüffinal = isMagic(15);
				} while (!prüffinal);
			}
		}.start();
	}

	private boolean isMagic(int summe) {
		boolean magic = true;
		
		for (int x = 0; x < zahlen.length; x++) {
			int[] erg = summen(x);
			if (erg[0] != summe || erg[1] != summe) {
				magic = false;
				break;
			}
		}

		return magic;
	}

	private int[] summen(int j) {
		int summereihe = 0;
		int summespalte = 0;

		for (int i = 0; i < zahlen.length; i++) {
			summereihe += zahlen[i][j];
			summespalte += zahlen[j][i];
		}

		int[] summen = { summereihe, summespalte };
		return summen;
	}


nicht besonders schön, aber schnell und effizient , denke ich.
Um diene Schleife in mischen() habe ich noch einen Thread gelegt (kannst beim mischen zuschauen, und Oberfläche ist nicht blockert...)

Swingworker könnte man noch um Textfeldaktualisierung legen, geht aber auch so.

Gruss
p
 
Status
Nicht offen für weitere Antworten.

Aktuelle Jobs

Neue Themen

Ähnliche Themen

bidirektionale OneToMany Endlosschleife
Antworten: 6
endlosschleife
Antworten: 7
Endlosschleife bei User Input mit try Scanner
Antworten: 7
Edittext onTextChange endlosschleife
Antworten: 2
Endlosschleife Thread sauber beenden
Antworten: 19

Zurück
Oben