java实现给定8×8大小的棋盘，棋盘上仅有一只马，马的初始位置随机，要求不能重复经过棋牌上的同一个点，求马可以有多少途径遍历棋盘上所有点

这是一个典型的深度优先搜索问题，可以使用回溯算法来解决。

具体思路如下：

1. 定义一个二维数组表示棋盘，记录每个点是否已经走过。

2. 定义一个数组表示马在棋盘上的移动方向，一共有8个方向可以选择。

3. 从任意一个点开始，按照某个方向移动，如果移动到了棋盘的边界或者已经走过的点，则回溯到上一个点，重新选择方向。

4. 如果走过了棋盘上所有的点，则记录一次遍历的路径。

5. 继续从下一个没有遍历过的点开始遍历，直到遍历完所有的点。

6. 统计所有遍历路径的个数即为所求。

下面是Java代码实现：

public class KnightTour {

    private static int[][] board;  // 棋盘
    private static int[] dx = {1, 2, 2, 1, -1, -2, -2, -1};  // 马的行走方向
    private static int[] dy = {2, 1, -1, -2, -2, -1, 1, 2};
    private static int count = 0;  // 记录遍历路径的个数

    public static void main(String[] args) {
        board = new int[8][8];
        int startX = (int) (Math.random() * 8);
        int startY = (int) (Math.random() * 8);
        knightTour(startX, startY, 1);
        System.out.println("共有" + count + "种遍历路径。");
    }

    private static void knightTour(int x, int y, int step) {
        board[x][y] = step;  // 标记当前点已走过
        if (step == 64) {  // 已经遍历完所有点
            printTour();
            board[x][y] = 0;  // 回溯
            return;
        }
        // 尝试从当前点继续遍历
        for (int i = 0; i < 8; i++) {
            int nextX = x + dx[i];
            int nextY = y + dy[i];
            if (nextX >= 0 && nextX < 8 && nextY >= 0 && nextY < 8 && board[nextX][nextY] == 0) {
                knightTour(nextX, nextY, step + 1);
            }
        }
        board[x][y] = 0;  // 回溯
    }

    private static void printTour() {
        for (int i = 0; i < 8; i++) {
            for (int j = 0; j < 8; j++) {
                System.out.print(board[i][j] + "\t");
            }
            System.out.println();
        }
        System.out.println();
        count++;
    }
}

这里采用了递归实现回溯算法，用一个二维数组记录棋盘上每个点的状态，并在递归前后进行标记和回溯。在遍历完所有点的时候，输出遍历路径并统计个数。