Verzögerung der Methodenausführung in Java

Question

Ich habe ein Problem mit der Ausführung der Methoden in einer for-Schleife. Ich möchte, dass mein Programm die Methode programmedMoving() fünfmal ausführt.

Diese programmedMoving() Methode besteht aus zwei Methoden:

die erste (chooseTheDirection()) führt etwas Algorithmus und gibt die Point2D, zu dem das Objekt bewegen sollte;

der zweite (moveToThePoint()) sollte diesen Punkt bekommen und das Objekt bewegen.

public boolean dispatchKeyEvent(KeyEvent e) { 
if (e.getKeyCode() == KeyEvent.VK_H) { 
      for(int i=0; i<5; i++{ 
       programmedMoving(); 
      } 
     } 
} 

////////////////////////////////////////////////////////////////// 

private void programmedMoving(){ 
     chooseTheDirection(); //returns the Point2D 
     moveToThePoint();//according to the direction starts moving the point 
    } 

Das Problem ist, dass es chooseTheDirection() Methode 5 mal ohne Warten auf die moveToThePoint() Ausführung der Methode ist es zu Ende führt. Wenn also das Objekt auf der JPanel beginnt, sich tatsächlich zu bewegen, bietet die Methode chooseTheDirection() bereits 5 Point2D Punkte, während ich es brauche, um nur eins zu liefern, und warte auf das Ende der nächsten Methode.

Könnte mir jemand sagen, was mache ich falsch? Vielen Dank.

ZUSÄTZLICH:

private Direction chooseDirection(){ 
    final List<Direction> directionList = Collections.unmodifiableList(Arrays.asList(Direction.values())); 

    int pick = random.nextInt(directionList.size()); 
    dir = directionList.get(pick); 
    directionsArchive.add(dir); 
    System.out.println("dir " + dir + " " + directionsArchive); 
    if(directionsArchive.size() == 1){ 
     dir = directionsArchive.get(0); 
     System.out.println("equal to one taken " + dir + " size of dir " + directionsArchive.size()); 
     directionsArchive.add(dir); 
    } 
    if(directionsArchive.size() > 1){ 
     int last = directionsArchive.size()-1; 
     System.out.println("index of last " + last); 
     if(directionsArchive.get(last).equals(dir)){ 
      pick = random.nextInt(directionList.size()); 
      dir = directionList.get(pick); 
      directionsArchive.add(dir); 
     } 
     System.out.println("more than one taken " + dir + " size of dir " + directionsArchive.size()); 
     directionsArchive.add(dir); 
    } 
    else{ 
    directionsArchive.add(dir); 
    System.out.println(" size of dir " + directionsArchive.size());} 
    return dir; 
} 


private void moveToThePoint(){ 
    if(dir.equals(Direction.NORTH)){ 
     this.robot.turnUp(); 
     this.robot.go(); 
    } 
    if(dir.equals(Direction.SOUTH)){ 
     this.robot.turnDown(); 
     this.robot.go();    
    } 
    if(dir.equals(Direction.EAST)){ 
     this.robot.turnRight(); 
     this.robot.go(); 
    } 
    if(dir.equals(Direction.WEST)){ 
     this.robot.turnLeft(); 
     this.robot.go(); 
    } 
} 

// SOME EXAMPLES TO THE MOVING METHODS. I PROVIDED ONLY ONE, CAUSE THEY ARE PRETTY SIMILAR 
    public void turnDown() 
    { 
     //System.out.println("Robot - Turn Down!"); 
     this.m_nXDir = 0; 
     this.m_nYDir = 1; 
    } 

    public void go() 
    { 
     this.m_nStep = 1; 
     //System.out.println("Robot - Go!"); 
    } 

public void move(int d, int e) 
{ 
    //from start to finish 
    int x = d + this.m_nStep * this.m_nXDir; 
    int y = e + this.m_nStep * this.m_nYDir; 

    int w = getWidth(); 
    int h = getHeight(); 

    setBounds(x, y, w, h); 
} 

Answer 1

moveToThePoint eigentlich nicht das Objekt verschieben, setzt er lediglich die Schrittgröße auf 1 nehme ich die tatsächliche move() Funktion auf einem Timer aufgerufen wird.

Hier gibt es 2 Vorschläge, wie es zu beheben:

den Entscheidungsalgorithmus Re-run (programmedMoving) für jeden Schritt.

oder

Warteschlange für zukünftige Bewegungen. Sie speichern eine Warteschlange mit zukünftigen Bewegungen für das Objekt, und jedes Mal, wenn es auf move() geplant ist, entfernen Sie den nächsten Zug aus der Warteschlange und führen ihn aus.