Java代码实现骑士游历问题是指，在国际象棋的棋盘（8行*8列）上，一个马要遍历棋盘，即走到棋盘上的每一格，并且每隔只到达一次。设码在棋盘的某一位置（x,y）上，按照“走马日”的规则，下一步有8个方向走，如图所示。若给定起始位置（x0,y0）,使用站和队列探索出一条马遍历棋盘的路径

以下是Java代码实现骑士游历问题：

import java.awt.Point;
import java.util.LinkedList;
import java.util.Queue;

public class KnightTour {
    private static final int BOARD_SIZE = 8;
    private int[][] visited;
    private int[] dx = {1, 2, 2, 1, -1, -2, -2, -1};
    private int[] dy = {2, 1, -1, -2, -2, -1, 1, 2};

    public KnightTour() {
        visited = new int[BOARD_SIZE][BOARD_SIZE];
        for (int i = 0; i < BOARD_SIZE; i++) {
            for (int j = 0; j < BOARD_SIZE; j++) {
                visited[i][j] = -1;
            }
        }
    }

    public void findTour(Point start) {
        Queue<Point> queue = new LinkedList<>();
        queue.offer(start);
        visited[start.x][start.y] = 0;

        while (!queue.isEmpty()) {
            Point current = queue.poll();
            for (int i = 0; i < 8; i++) {
                int nextX = current.x + dx[i];
                int nextY = current.y + dy[i];
                if (isValidMove(nextX, nextY) && visited[nextX][nextY] == -1) {
                    visited[nextX][nextY] = visited[current.x][current.y] + 1;
                    queue.offer(new Point(nextX, nextY));
                }
            }
        }
    }

    private boolean isValidMove(int x, int y) {
        return x >= 0 && x < BOARD_SIZE && y >= 0 && y < BOARD_SIZE;
    }

    public void printTour() {
        for (int i = 0; i < BOARD_SIZE; i++) {
            for (int j = 0; j < BOARD_SIZE; j++) {
                System.out.print(visited[i][j] + "\t");
            }
            System.out.println();
        }
    }

    public static void main(String[] args) {
        KnightTour kt = new KnightTour();
        kt.findTour(new Point(0, 0));
        kt.printTour();
    }
}

在主函数中，我们创建了一个KnightTour对象kt，并调用其findTour方法，传入起始位置(0,0)。该方法使用BFS算法来遍历棋盘，并记录每个位置的访问顺序。最后，我们调用kt的printTour方法来打印访问顺序矩阵。