Operatoren in der While Schleife

[777]

Ich komme nicht weiter:
Theoretisch dürfte der PC, das auf den Schirm geblitete Bild "Fliege" nur darstellen aber nie bewegen, da die Dinge innerhalb des Whilezweiges nie "true" werden.
Tut er aber doch: Warum?!?!!?

cya
David

....
public void run()
{
    
    while(true)
    {
    zufall2= (int)(Math.random()*10+1);





     switch(zufall2)
     {
     case 1:
            while(zufall!=1||zufall!=2||zufall!=3||zufall!=4||zufall!=5||zufall!=6||zufall!=7||zufall!=8||zufall!=9||zufall!=10)
            {
                posx++;    
                posy++;    
                //Fliege neu bliten:    
                try{
                Flieg.sleep(500);
                }
                catch(InterruptedException e)
                {
                }
                repaint();
   
            }
                
     break;
     
     case 2:
            while(zufall!=1||zufall!=2||zufall!=3||zufall!=4||zufall!=5||zufall!=6||zufall!=7||zufall!=8||zufall!=9||zufall!=10)
            {
            posx++;    
            posy--;    
            //Fliege neu bliten:    
            try{
            Flieg.sleep(zeit);
            }
            catch(InterruptedException e)
            {
            }
            repaint();
      
            }
                
     break;
     
     case 3:
            while(zufall!=1||zufall!=2||zufall!=3||zufall!=4||zufall!=5||zufall!=6||zufall!=7||zufall!=8||zufall!=9||zufall!=10)
            {
            posx--;    
            posy--;    
            //Fliege neu bliten:    
            try{
            Flieg.sleep(zeit);
            }
            catch(InterruptedException e)
            {
            }
            repaint();
       
            }
                
     break;
     
     case 4:
            while(zufall!=1||zufall!=2||zufall!=3||zufall!=4||zufall!=5||zufall!=6||zufall!=7||zufall!=8||zufall!=9||zufall!=10)
            {
            posx--;    
            posy++;    
            //Fliege neu bliten:    
            try{
            Flieg.sleep(zeit);
            }
            catch(InterruptedException e)
            {
            }
            repaint();
                    
            }
                zufall = (int)(Math.random()*10);
                break;
            
                 case 5:
            while(zufall!=1||zufall!=2||zufall!=3||zufall!=4||zufall!=5||zufall!=6||zufall!=7||zufall!=8||zufall!=9||zufall!=10)
            {
            posx--;    
   
            //Fliege neu bliten:    
            try{
            Flieg.sleep(zeit);
            }
            catch(InterruptedException e)
            {
            }
            repaint();
                    
            }

                break;
                 case 6:
            while(zufall!=1||zufall!=2||zufall!=3||zufall!=4||zufall!=5||zufall!=6||zufall!=7||zufall!=8||zufall!=9||zufall!=10)
            {
   
            posy++;    
            //Fliege neu bliten:    
            try{
            Flieg.sleep(zeit);
            }
            catch(InterruptedException e)
            {
            }
            repaint();
                    
            }

                break;
                             case 7:
            while(zufall!=1||zufall!=2||zufall!=3||zufall!=4||zufall!=5||zufall!=6||zufall!=7||zufall!=8||zufall!=9||zufall!=10)
            {
   
            posy=posy+2;   
            //Fliege neu bliten:    
            try{
            Flieg.sleep(zeit);
            }
            catch(InterruptedException e)
            {
            }
            repaint();
                    
            }

                break;
                
            
                             case 8:
            while(zufall!=1||zufall!=2||zufall!=3||zufall!=4||zufall!=5||zufall!=6||zufall!=7||zufall!=8||zufall!=9||zufall!=10)
            {
   
            posy=posy-2;   
            //Fliege neu bliten:    
            try{
            Flieg.sleep(zeit);
            }
            catch(InterruptedException e)
            {
            }
            repaint();
                    
            }

                break;
                             case 9:
            while(zufall!=1||zufall!=2||zufall!=3||zufall!=4||zufall!=5||zufall!=6||zufall!=7||zufall!=8||zufall!=9||zufall!=10)
            {
   
            posx=posx+2;    
            //Fliege neu bliten:    
            try{
            Flieg.sleep(zeit);
            }
            catch(InterruptedException e)
            {
            }
            repaint();
                    
            }

                break;
            
                             case 10:
            while(zufall!=1||zufall!=2||zufall!=3||zufall!=4||zufall!=5||zufall!=6||zufall!=7||zufall!=8||zufall!=9||zufall!=10)
            {
   
            posx=posx-2;    
            //Fliege neu bliten:    
            try{
            Flieg.sleep(zeit);
            }
            catch(InterruptedException e)
            {
            }
            repaint();
                    
            }


            

     break;
     default: break;
     }
  
    }
}


public void paint(Graphics g)
{
Image fly = getImage(getCodeBase(),"fliege.jpg");
g.drawImage(fly,posx,posy,this);
zufall = (int)(Math.random()*10+1);
ausgabe.setText(""+zufall);
}

public void start()
{
Flieg = new Thread(this);
Flieg.start();
}

}

 

[Leroy42]

Ich habe zwar keine Ahnung was dein Programm bezwecken soll, auf jeden Fall
sind die Anweisungen der Art

 while(zufall!=1||zufall!=2||zufall!=3||zufall!=4||zufall!=5||zufall!=6||zufall!=7||zufall!=8||zufall!=9||zufall!=10)

schon äußerst suspekt. Warum schreibst du hier nicht einfach while (true)

while (zufall != 1) bedeutet, daß der Interpreter in der Schleife bleibt solange zufall nicht 1 ist
while (zufall != 2) bedeutet, daß der Interpreter in der Schleife bleibt solange zufall nicht 2 ist

while (zufall!=1 || zufall!=2) bedeutet dementsprechend, daß die Schleife nie verlassen wird.

Anders gesagt, die Schleife wird verlassen wenn !(zufall!=1 || zufall!=2) wahr ist.
Nach deMorgan also wenn (zufall==1 && zufall==2) ist.

Erklär mir mal wie zufall gleichzeitig 1 und 2 sein kann ???:L

Die einzige Möglichkeit wäre wenn zufall nicht-lokal ist und in einem anderen Thread während
der Abfrage geändert wird; damit würde die Eigenschaft gleichzeitig ja entfallen.

Überleg dir lieber nochmal was genau deine while-Bedingung bedeuten soll

 

[777]

Eigentlich sollte mein Programm bedeuten, dass der Interpreter NIE in die Schleife kommt, weil er ja so lange drin bleibt, wie das alles NICHT 1,2,3 und so weiter ist.
Also müsste er doch direkt wieder herausspringen.
Was genau das Programm bedeutet?
Es soll ein Spiel werden- aber das dauert noch...

Ich bin jetzt schon so weit, wie ich kommen wollte: Das die Fliege per Zufall ihren Kurs ändert:

     switch(zufall2)
     {
     case 1:
            while(zufall!=1)
            {
                posx++;    
                posy++;    
                //Fliege neu bliten:    
                try{
                Flieg.sleep(500);
                }
                catch(InterruptedException e)
                {
                }
                repaint();
   
            }
                
     break;
     
     case 2:
            while(zufall!=1)
            {
            posx++;    
            posy--;    
            //Fliege neu bliten:    
            try{
            Flieg.sleep(zeit);
            }
            catch(InterruptedException e)
            {
            }
            repaint();
      
            }
                
     break;
     
     case 3:
            while(zufall!=1)
            {
            posx--;    
            posy--;    
            //Fliege neu bliten:    
            try{
            Flieg.sleep(zeit);
            }
            catch(InterruptedException e)
            {
            }
            repaint();
       
            }
                
     break;
     
     case 4:
            while(zufall!=1)
            {
            posx--;    
            posy++;    
            //Fliege neu bliten:    
            try{
            Flieg.sleep(zeit);
            }
            catch(InterruptedException e)
            {
            }
            repaint();
                    
            }
                zufall = (int)(Math.random()*10);
                break;
            
                 case 5:
            while(zufall!=1)
            {
            posx--;    
   
            //Fliege neu bliten:    
            try{
            Flieg.sleep(zeit);
            }
            catch(InterruptedException e)
            {
            }
            repaint();
                    
            }

                break;
                 case 6:
            while(zufall!=1)
            {
   
            posy++;    
            //Fliege neu bliten:    
            try{
            Flieg.sleep(zeit);
            }
            catch(InterruptedException e)
            {
            }
            repaint();
                    
            }

                break;
                             case 7:
            while(zufall!=1)
            {
   
            posy=posy+2;   
            //Fliege neu bliten:    
            try{
            Flieg.sleep(zeit);
            }
            catch(InterruptedException e)
            {
            }
            repaint();
                    
            }

                break;
                
            
                             case 8:
            while(zufall!=1)
            {
   
            posy=posy-2;   
            //Fliege neu bliten:    
            try{
            Flieg.sleep(zeit);
            }
            catch(InterruptedException e)
            {
            }
            repaint();
                    
            }

                break;
                             case 9:
            while(zufall!=1)
            {
   
            posx=posx+2;    
            //Fliege neu bliten:    
            try{
            Flieg.sleep(zeit);
            }
            catch(InterruptedException e)
            {
            }
            repaint();
                    
            }

                break;
            
                             case 10:
            while(zufall!=1)
            {
   
            posx=posx-2;    
            //Fliege neu bliten:    
            try{
            Flieg.sleep(zeit);
            }
            catch(InterruptedException e)
            {
            }
            repaint();
                    
            }


            

     break;
     default: break;
     }
  
    }

 

[Leroy42]

Nachtrag:

Wenn der Interpreter in eine der inneren Schleifen eintritt, wie soll er da jemals
wieder herauskommen :shock: Die Variable zufall wird innerhalb der Schleifen
nie verändert.

Und noch ein Tip(p) zum Programmierstil. Anstatt 10 fast identische
Schleifenkörper zu schreiben die sich nur darin unterscheiden wie die x-y-Werte
pro Durchlauf verändert werden, versuch doch mal diesen Teil auszuklammern.

Beispiel:

static final int[][] delta = {
	{+1,+1},{+1,-1},{-1,-1},{-1,+1},
	{-1, 0},{+1, 0},{ 0,+2},{ 0,-2},
	{+2, 0},{-2, 0}};
	
public void run() {
	while (true) {
		int zufall2 = (int)(Math.random()*10);
		while ("wasAuchImmer") {
			posx += delta[zufall2][0];
			posy += delta[zufall2][1];
			repaint();
			try {Flieg.sleep(500);} catch(InterruptedException e) {}
		}
	}
}

 

[777]

Diese Syntax verstehe ich noch nicht, da ich erst vor kurzer Zeit mit Java angefangen habe...

 

[Leroy42]

Das Konstrukt ist ein 2-dimensionales Array (Feld) in dem die deltas (Unterschiede)
zwischen den alten und neuen x und y Werten gespeichert sind.

Aber wenn du noch keine Arrays hattest, vergiß es (vorläufig )

Der Punkt ist, daß du den gemeinsamen Teil der inneren Schleifen
nur einmal schreibst und die Fallunterscheidung in die eine Schleife
hineinziehst. Also

public void run() {
	while (true) {
		int zufall2 = (int)(Math.random()*10);
		while ("wasAuchImmer") {
                           switch (zufall2) {
                               case 0 : posx += 1; posy += 1; break;
                               case 1 : posx += 1; posy += -1; break;
                               case 2 : posx += -1; posy += -1; break;
                               case 3 : posx += -1; posy += 1; break;
                               ...
                           }
			repaint();
			try {Flieg.sleep(500);} catch(InterruptedException e) {}
		}
	}
}

Der Vorteil ist die Übersichtlichkeit, ersparte Schreibarbeit und Vermeidung
von Redundanz. Falls du den gemeinsamen Teil (repaint, sleep) ändern mußt
brauchst du dies nur einmal zu tun und es kann nicht passieren daß von deinen
9 Kopien deines codes versehentlich eine vergißt zu ändern.

Merksatz: Oberste Tugend eines Programmierers == Faulheit