title: Why is my 2D Array Maze not printing what is generated?
body: <p>My aim was to generate a maze made of a 2D Array of Cell objects. Below is the code for both the cell and the maze. Using the debugger I can see that booleans are changing values, and the generation progresses as expected, however when it gets the the printing, there is no path. 
  All of the walls are still in place and I can't seem to figure out where the disconnect is,if there is one? </p>
  
  <p>Here is the Cell class:</p>
  
  <pre><code>public class Cell {
      //coordinates
      private int x;
      private int y;
      //cell status
      private boolean visited;
      //cell walls status
      private boolean northWall;
      private boolean southWall;
      private boolean eastWall;
      private boolean westWall;
  
      public Cell(int x, int y) {
          this.x = x;
          this.y = y;
          visited =  false;
          northWall= true;
          southWall= true;
          eastWall = true;
          westWall = true;
      }
  
      public int getX() {
          return x;
      }
  
      public int getY() {
          return y;
      }
  
      public boolean isVisited() {
          return visited;
      }
  
      public void setVisited(boolean visited) {
          this.visited = visited;
      }
  
      public boolean isNorthWall() {
          return northWall;
      }
  
      public void setNorthWall(boolean northWall) {
          this.northWall = northWall;
      }
  
      public boolean isSouthWall() {
          return southWall;
      }
  
      public void setSouthWall(boolean southWall) {
          this.southWall = southWall;
      }
  
      public boolean isEastWall() {
          return eastWall;
      }
  
      public void setEastWall(boolean eastWall) {
          this.eastWall = eastWall;
      }
  
      public boolean isWestWall() {
          return westWall;
      }
  
      public void setWestWall(boolean westWall) {
          this.westWall = westWall;
      }
  </code></pre>
  
  <p>Here is the Maze class:</p>
  
  <pre><code>public class Maze {
  private Cell[][] maze;
  private int height;
  private int width;
  
  //generate the full 2d array of cell objects. all the 'visited's are false and all the walls are true(that's done in the cells constructor).
  
  public Maze(int height, int width) {
      //initialize the number of rows and columns in the maze with the numbers entered
      this.height = height;
      this.width = width;
  
      //initialize the 2d maze with the number of spaces allocated by the height and width entered
      maze = new Cell[height][width];
      //fill the maze with cells
      generateMaze();
      //dig a an open path through the maze
      generatePath();
      //print the maze in the console
      printMaze();
  }
  
  /**
   * The generateMaze method fills the maze with unvisited, walled cells.
   */
  public void generateMaze() {
      for(int i = 0; i &lt; height; i++) {
          for(int j = 0; j &lt; width; j++) {
              maze[i][j] = new Cell(i, j);
          }
      }
  }
  
  /**
   * The generatePath method digs or generates a random open path through the maze of cells.
   */
  private void generatePath() {
      //Find the starting point to start digging.
      Random rand = new Random();
      int row = rand.nextInt(height);
      int col = rand.nextInt(width);
  
      //starting cell
      maze[row][col].setVisited(true);
  
      //start digging the path
      dig(row, col);
  
  }
  
  //Depth-First Searching Algorithm that digs in increments of 1
  public void dig(int row, int column){
      //generate four random directions
      Integer[] randDirs = generateRandomDirections();
      //examine each direction
      for(int i = 0; i &lt; randDirs.length;i++) {
          switch (randDirs[i]) {
              case 1: //Up
                  //whether one cells up is in the maze or not
                  if (row - 1 &lt;= 0) {
                      continue;
                  }
                  //whether one cells up has been visited
                  if (!maze[row - 1][column].isVisited()) {
                      maze[row - 1][column].setVisited(true);
                      maze[row][column].setNorthWall(false);
                      maze[row - 1][column].setSouthWall(false);
                      dig(row - 1, column);
                  }
                  break;
              case 2: //Right
                  //whether one cells right is in the maze or not
                  if (column + 1 &gt;= width - 1) { //alternative: (column + 2 &gt;= width - 1) ??
                      continue;
                  }
                  //whether one cells right has been visited
                  if (!maze[row][column + 1].isVisited()) {
                      maze[row][column + 1].setVisited(true);
                      maze[row][column].setEastWall(false);
                      maze[row][column + 1].setWestWall(false);
                      dig(row, column + 1);
                  }
                  break;
              case 3: //Down
                  //whether one cells down is in the maze or not
                  if (row + 1 &gt;= height - 1) {//alternative: (row + 2 &gt;= height - 1) ??
                      continue;
                  }
                  //whether one cells down has been visited
                  if (!maze[row + 1][column].isVisited()) {
                      maze[row + 1][column].setVisited(true);
                      maze[row][column].setSouthWall(false);
                      maze[row + 1][column].setNorthWall(false);
                      dig(row + 1, column);
                  }
                  break;
              case 4: //Left
                  //whether one cells left is in the maze or not
                  if (column - 1 &lt;= 0) {
                      continue;
                  }
                  //whether one cells left has been visited
                  if (!maze[row][column - 1].isVisited()) {
                      maze[row][column - 1].setVisited(true);
                      maze[row][column].setWestWall(false);
                      maze[row][column - 1].setEastWall(false);
                      dig(row, column - 1);
                  }
                  break;
          }
      }
  }
  
  /**
   * The generateRandomDirections() class generates an array with random directions 1-4
   * @return Array containing 4 directions in random order
   */
  public Integer[] generateRandomDirections() {
      ArrayList&lt;Integer&gt; randoms = new ArrayList&lt;&gt;();
      for(int i = 0; i &lt; 4; i++) {
          randoms.add(i + 1);
      }
      Collections.shuffle(randoms);
      return randoms.toArray(new Integer[4]);
  }
  
  /**
   * The printMaze() method prints out the maze of cells generated by the GenerateMaze class, to the console.
   */
  public void printMaze() {
      for (int i = 0; i &lt; height; i++) {
          System.out.println();
          for (int j = 0; j &lt; width; j++) {
              Cell current = new Cell(i, j);
              StringBuilder string = new StringBuilder();
              if(current.isWestWall()){
                  string.append("|");
              }
              if(current.isSouthWall()) {
                  string.append("_");
              }
              else{
                  string.append(" ");
              }
              System.out.print(string);
          }
      }
  }
  </code></pre>
  
  <p>I always end up with the following output:</p>
  
  <pre><code>|_|_|_|_|_|_|_
  |_|_|_|_|_|_|_
  |_|_|_|_|_|_|_
  |_|_|_|_|_|_|_
  |_|_|_|_|_|_|_
  |_|_|_|_|_|_|_
  |_|_|_|_|_|_|_
  Process finished with exit code 0
  </code></pre>
  
  <p>Any ideas would be appreciated, as to what my problem might be. Thank you. </p>