Path Finding Question

Question

Im re-familiarizing myself with Java and have decided to crack at the Knights Tour puzzle. Now my code already finds one path (if possible) for every starting path, or returns nothing if it hits a dead end.
However id like to expand it to find all paths, anyone offer any help with this? below is the code of the main and the board classes, the co-ord basically is returning an X/Y value
package KnightsTour;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.List;
public class KnightsTour
     public static void main (String args[])
          new KnightsTour();
     public KnightsTour()
          int boardWidth = 0, boardHeight = 0;
          System.out.println("Input Width :");
          boardWidth = getConsoleValue();
          System.out.println("Input Height :");
          boardHeight = getConsoleValue();
          long temp = System.currentTimeMillis();
          int totalPaths = getTotalPaths(boardWidth, boardHeight);
          System.out.println("\nSuccessful paths for board size :" + boardWidth + "x" + boardHeight + " is :" + totalPaths);
          System.out.println("\nTime taken to calculate was :" + (System.currentTimeMillis() - temp) + "ms");
     /* returns an Integer read from the console */
     private int getConsoleValue()
          int boardSize = 0;
          String line = null;
         try
           BufferedReader is = new BufferedReader(new InputStreamReader(System.in));
           line = is.readLine();
           boardSize = Integer.parseInt(line);
         catch (NumberFormatException ex)
           System.err.println("Not a valid number: " + line);
         catch (IOException e)
           System.err.println("Unexpected IO ERROR: " + e);
         return boardSize;
     /* returns value of number of Paths for a given board */
     public static int getTotalPaths(int width, int height)
          int totalPaths = 0;
          for(int w = 0; w < width; w++)
               for(int h = 0; h < height; h++)
                    Coordinate startingPos = new Coordinate(w, h);
                    System.out.println("\nStarting at " + startingPos );
                    Board board = new Board(height, width, startingPos);
                    List<Coordinate> results = resolvePuzzle(board);
                    if (results != null)
                         for (Coordinate c : results)
                              System.out.print(c + " ");
                         totalPaths++;
                    else
                         System.out.print("No Path Found");
          return totalPaths;
     /* a list of the moves made to resolve the puzzle */
     public static List<Coordinate> resolvePuzzle(Board currentBoard){
          if (currentBoard.isFinish())
               return currentBoard.getCurrentPath();
          List<Coordinate> possibleMove = currentBoard.getPossibleMove();
          if (possibleMove.size() == 0)
               return null;
          for (Coordinate c : possibleMove)
               currentBoard.move(c);
               List<Coordinate> results = resolvePuzzle(currentBoard);
               if (results == null)
                    currentBoard.undo();
               else
                    return results;
          return null;          
} the board
package KnightsTour;
import java.util.ArrayList;
import java.util.List;
public class Board
          private boolean [][] visitedBoard;
          private Coordinate currentPos = null;
          private List<Coordinate> knightMoves = new ArrayList<Coordinate>();
          private List<Coordinate> currentPath = new ArrayList<Coordinate>();
          public Board(int boardHeight, int boardWidth, Coordinate start)
               initKnight();
               visitedBoard = new boolean [boardWidth][boardHeight];
               move(start);
          /* a Knight has 8 different moves it can make, and this represents them all */
          public void initKnight()
               knightMoves.add(new Coordinate (-1, -2));
               knightMoves.add(new Coordinate (1, -2));
               knightMoves.add(new Coordinate (2, -1));
               knightMoves.add(new Coordinate (2, 1));
               knightMoves.add(new Coordinate (1, 2));
               knightMoves.add(new Coordinate (-1, 2));
               knightMoves.add(new Coordinate (-2, 1));
               knightMoves.add(new Coordinate (-2, -1));
          /* marks a square as visited and adds it the co-ord to the list */
          public void move (Coordinate newPos)
               currentPos = newPos;
               visitedBoard[newPos.getX()][newPos.getY()] = true;
               currentPath.add(newPos);
          /* when a dead end if found, the path is reversed to see if an alternate path exists */
          public void undo ()
               if(currentPath.size()-2 >= 0)
                    visitedBoard[currentPos.getX()][currentPos.getY()] = false;
                    Coordinate lastPos = currentPath.get(currentPath.size()-2);
                    currentPath.remove(currentPath.size() -1);
                    currentPos = lastPos;
          /* check the move list to see if a valid move is found */
          public List<Coordinate> getPossibleMove()
               List<Coordinate> possibleMoves = new ArrayList<Coordinate>();
               for (Coordinate c : knightMoves)
                    Coordinate futureMove = currentPos.getDelta(c);
                    if (!isCoordinateOutOfBound(futureMove) && !visitedBoard[futureMove.getX()][futureMove.getY()])
                         possibleMoves.add(futureMove);
               return possibleMoves;
          public List<Coordinate> getCurrentPath(){ return currentPath;}
          private boolean isCoordinateOutOfBound(Coordinate coor)
               return (coor.getX() < 0 || coor.getY() < 0 || coor.getX() >= visitedBoard.length || coor.getY() >= visitedBoard[0].length);
          /* has the Knight toured the board ? */
          boolean isFinish()
               for (boolean[] range: visitedBoard)
                    for (boolean column : range)
                         if (! column)
                              return false;
               return true;
     }

Answer 1

Dijkstra (and A*), doesn't in theory compute the shortest path between a source and a destination, but between a source and all the nodes. On those algorithms, once you've tested a node you know 1) it's distance to the source, 2) where the shortest path came from, so you cannot recompute a shortest path for a node.
Here you should test the node that has the lowest "distance from src + heuristic", so probably one of the node adjacent to the violets.