Comment trouver une erreur de récursion infinie dans un programme Java?

Question

import java.lang.reflect.Array; 
    import java.util.*; 


    public class TMS { 

     private static int row = 5, col = 5; 
     private static String[][] board = new String[row][col]; 
     private static String[][] board_copy = new String[row][col]; 

     public static void main(String[] args) { 
      for(String[] array:board) { 
       Arrays.fill(array, "_"); 
      } 
      create_mines(); 
      Scanner input = new Scanner(System.in); 
      int inpx = 0, inpy; 

      while(inpx != 69){ 
       show_board(); 
       inpx = input.nextInt(); 
       inpy = input.nextInt(); 
       if(board_copy[inpx][inpy] == "*"){ 
        System.out.println("YOU LOOSE"); 
        break; 
       } 
       check_move(inpx, inpy); 
      } 
     } 

     public static void show_board() { 
      for(String[] row: board){ 
       for(String element: row){ 
        System.out.print(element+"\t"); 
       }System.out.println(); 
      } 
     } 

     public static void create_mines() { 
      Random rand = new Random(); 
      rand.nextInt(); 

      for(String[] array:board_copy) { 
       Arrays.fill(array, "_"); 
      } 
      board_copy[1][1] = "*"; 
      board_copy[3][1] = "*"; 
      board_copy[3][3] = "*"; 
      board_copy[2][4] = "*"; 
     } 

     public static void check_move(int posx, int posy){ 
      int mines = 0; 
      if(posx-1 >= 0 && posy-1 >= 0) 
       mines = (board_copy[posx-1][posy-1] == "*")? (mines+1):mines; 
      if(posx >= 0 && posy-1 >= 0) 
       mines = (board_copy[posx][posy-1] == "*")? (mines+1):mines; 
      if(posx+1 < row && posy+1 < col) 
       mines = (board_copy[posx+1][posy+1] == "*")? (mines+1):mines; 
      if(posx-1 >= 0 && posy >= 0) 
       mines = (board_copy[posx-1][posy] == "*")? (mines+1):mines; 
      if(posx+1 < row && posy >= 0) 
       mines = (board_copy[posx+1][posy] == "*")? (mines+1):mines; 
      if(posx >= 0 && posy+1 < col) 
       mines = (board_copy[posx][posy+1] == "*")? (mines+1):mines; 
      if(posx-1 >= 0 && posy+1 < col) 
       mines = (board_copy[posx-1][posy+1] == "*")? (mines+1):mines; 
      if(posx+1 < row && posy-1 >= 0) 
       mines = (board_copy[posx+1][posy-1] == "*")? (mines+1):mines; 
      board[posx][posy] = Integer.toString(mines); 

      if(mines == 0){ 
       if((posx-1) >= 0 && (posy-1) >= 0) { 
        System.out.println((posx-1)+" "+(posy-1)); 
        check_move((posx - 1), (posy - 1)); 
       } 
       if(posx >= 0 && (posy-1) >= 0) { 
        System.out.println((posx)+" "+(posy-1)); 
        check_move(posx, (posy - 1)); 
       } 
       if((posx+1) < row && (posy+1) < col) { 
        System.out.println((posx+1)+" "+(posy+1)); 
        check_move((posx + 1), (posy + 1)); 
       } 
       if((posx-1) >= 0 && posy >= 0) { 
        System.out.println((posx-1)+" "+(posy)); 
        check_move((posx - 1), posy); 
       } 
       if((posx+1) < row && posy >= 0) { 
        System.out.println((posx+1)+" "+(posy)); 
        check_move((posx + 1), posy); 
       } 
       if(posx >= 0 && (posy+1) < col) { 
        System.out.println((posx)+" "+(posy+1)); 
        check_move(posx, (posy + 1)); 
       } 
       if((posx-1) >= 0 && (posy+1) < col) { 
        System.out.println((posx-1)+" "+(posy+1)); 
        check_move((posx - 1), (posy + 1)); 
       } 
       if((posx+1) < row && (posy-1) >= 0) { 
        System.out.println((posx+1)+" "+(posy-1)); 
        check_move((posx + 1), (posy - 1)); 
       } 
      } 
     } 
    } 

Apparemment, j'appelle la méthode check_move à l'infini pendant la récursivité. Je ne peux pas savoir pourquoi cela continue indéfiniment. Voici le message d'erreur:

Exception in thread "main" java.lang.StackOverflowError 
    at java.lang.Integer.toString(Integer.java:402) 
    at TMS.check_move(TMS.java:70) 
    at TMS.check_move(TMS.java:79) 
    at TMS.check_move(TMS.java:79) 
    at TMS.check_move(TMS.java:95) 
    at TMS.check_move(TMS.java:79) 
    at TMS.check_move(TMS.java:95) 
    at TMS.check_move(TMS.java:79) 
    at TMS.check_move(TMS.java:95) 
    at TMS.check_move(TMS.java:79) 
    at TMS.check_move(TMS.java:95) 
    at TMS.check_move(TMS.java:79) 
    at TMS.check_move(TMS.java:95) 
    at TMS.check_move(TMS.java:79) 
    at TMS.check_move(TMS.java:95) 
    at TMS.check_move(TMS.java:79) 
    at TMS.check_move(TMS.java:95) 
    at TMS.check_move(TMS.java:79) 
    at TMS.check_move(TMS.java:95) 
    at TMS.check_move(TMS.java:79) 
    at TMS.check_move(TMS.java:95) 
    at TMS.check_move(TMS.java:79) 
    at TMS.check_move(TMS.java:95) 
    at TMS.check_move(TMS.java:79) 
    at TMS.check_move(TMS.java:95) 
    at TMS.check_move(TMS.java:79) 
    at TMS.check_move(TMS.java:95) 
    at TMS.check_move(TMS.java:79) 
    at TMS.check_move(TMS.java:95) 
    at TMS.check_move(TMS.java:79) 
    at TMS.check_move(TMS.java:95) 
    . 
    . 
    . 
    . 
(GOES ON FOREVER) 

Answer 1

Votre récursivité ne se terminera pas si, par exemple, vous avez deux cellules adjacentes sans mines. Par exemple, si une position (posx, posy) il n'y a pas à moi que vous appelez check_move au (posx-1, posy-1) dans la ligne

if((posx-1) >= 0 && (posy-1) >= 0) { 
     System.out.println((posx-1)+" "+(posy-1)); 
     check_move((posx - 1), (posy - 1)); 

Maintenant, si (posx-1, posy-1) a également pas de mines, vous appellerez à check_move (posx, posy) dans la ligne

if((posx+1) < row && (posy+1) < col) { 
    System.out.println((posx+1)+" "+(posy+1)); 
    check_move((posx + 1), (posy + 1)); 

Et cela continuera pour toujours. Vous devez trouver un moyen de mettre fin à la récursivité dans tous les cas. Par exemple, vous pouvez avoir un drapeau 'checked' sur chaque cellule qui vous empêche de rappeler check_move dans une position déjà testée (il peut y avoir d'autres façons ...). Et comme Andreas le signale, votre inpx = 69 n'aura pas l'effet désiré, car votre routine appellera une exception avant de revenir au test de boucle while.