正文
java迷宫游戏代码注释,java迷宫游戏代码注释大全
小程序:扫一扫查出行
【扫一扫了解最新限行尾号】
复制小程序
【扫一扫了解最新限行尾号】
复制小程序
求大佬讲解一下这段java代码
//直译了哦,只有片面的代码,只能靠推测,其他你自己补充下:
//这个主要是对一个图像控件设置了键盘侦听事件,按下键盘时候对其进行坐标移位操作
//必须知道:ImageView图像控件,显示图片或者其他;num是一个二位数组,这里可以理解成矩阵地图;
public void control(int[][] num, ImageView iv) {
//对控件设置键盘侦听,
iv.setOnKeyPressed(e - {
//设置一个变量,从下面使用看,这个应该是一个图像步进单位
int m = 30;
//以下为:try catch封装的键盘四向按键判断
try {
//字面意义推测:row应该是行,col应该是列,这是用二维数组画了一个矩阵地图,0不能走,1可以走;
//如果键盘按下的键是s,并且"行+1"小于地图中的行的个数,并且:地图[row+1行][col列]的值不等于0
if (e.getCode() == KeyCode.S row + 1 num.length num[row + 1][col] != 0) {
//就设置图像y坐标(在原有坐标的基础上进行一个步进单位的叠加)
iv.setY(iv.getY() + m);
//行递增1:row=row+1;
row++;
}
//其实这里与下面与上面都是一个道理,仅仅判断的条件与按键不同罢了
if (e.getCode() == KeyCode.W row - 1 = 0 num[row - 1][col] != 0) {
iv.setY(iv.getY() - m);
//行递减1
row--;
}
//同上
if (e.getCode() == KeyCode.A col - 1 = 0 num[row][col - 1] != 0) {
iv.setX(iv.getX() - m);
//列递减1
col--;
}
//同上
if (e.getCode() == KeyCode.D col + 1 num[0].length num[row][col + 1] != 0) {
iv.setX(iv.getX() + m);
//列递增1
col++;
}
}catch (Exception n) {}
//如果行等于地图"行"的最大的索引值,并且列等于第一行数组的最大索引值
if (row == num.length - 1 col == num[0].length - 1) {
//就调用win函数;
win();
}
});
}
请帮忙用数据结构(java版)的知识解决这道迷宫问题的程序代码。
我这是用c写的。你可以看看,希望能帮助到你。
#include"stdlib.h"
#include"stdio.h"
#define N 50
#define M 50
int X;
int maze[N+2][M+2];
struct point{
int row,col,predecessor;
}queue[512];
int head=0,tail=0;
void shoudong_maze(int m,int n){
int i,j;
printf("\n\n");
printf("请按行输入迷宫,0表示通路,1表示障碍:\n\n");
for(i=0;im;i++)
for(j=0;jn;j++)
scanf("%d",maze[i][j]);
}
void zidong_maze(int m,int n){
int i,j;
printf("\n迷宫生成中……\n\n");
system("pause");
for(i=0;im;i++)
for(j=0;jn;j++)
maze[i][j]=rand()%2;
//由于rand()产生的随机数是从0到RAND_MAX
//RAND_MAX是定义在stdlib.h中的,其值至少为32767)
//要产生从X到Y的数,只需要这样写:k=rand()%(Y-X+1)+X;
}
void print_maze(int m,int n){
int i,j;
printf("\n迷宫生成结果如下:\n\n");
printf("迷宫入口\n");
printf("↓");
for(i=0;im;i++)
{printf("\n");
for(j=0;jn;j++)
{if(maze[i][j]==0) printf("□");
if(maze[i][j]==1) printf("■");}
}
printf("→迷宫出口\n");
}
void result_maze(int m,int n)
{ int i,j;
printf("迷宫通路(用☆表示)如下所示:\n\t");
for(i=0;im;i++)
{ printf("\n");
for(j=0;jn;j++)
{if(maze[i][j]==0||maze[i][j]==2) printf("□");
if(maze[i][j]==1) printf("■");
if(maze[i][j]==3) printf("☆");
}
}
}
void enqueue(struct point p)
{ queue[tail]=p;
tail++;
}
struct point dequeue()
{ head++;
return queue[head-1];
}
int is_empty()
{ return head==tail;
}
void visit(int row,int col,int maze[52][52])
{ struct point visit_point={row,col,head-1};
maze[row][col]=2;
enqueue(visit_point);
}
int mgpath(int maze[52][52],int m,int n)
{ X=1;
struct point p={0,0,-1};
if(maze[p.row][p.col]==1)
{ printf("\n===============================================\n");
printf("此迷宫无解\n\n");X=0;return 0;}
maze[p.row][p.col]=2;
enqueue(p);
while(!is_empty())
{p=dequeue();
if((p.row==m-1)(p.col==n-1)) break;
if((p.col+1n)(maze[p.row][p.col+1]==0)) visit(p.row,p.col+1,maze);
if((p.row+1m)(maze[p.row+1][p.col]==0)) visit(p.row+1,p.col,maze);
if((p.col-1=0)(maze[p.row][p.col-1]==0)) visit(p.row,p.col-1,maze);
if((p.row-1=0)(maze[p.row-1][p.col]==0)) visit(p.row-1,p.col,maze);
}
if(p.row==m-1p.col==n-1)
{printf("\n==================================================================\n");
printf("迷宫路径为:\n");
printf("(%d,%d)\n",p.row,p.col);
maze[p.row][p.col]=3;
while(p.predecessor!=-1)
{p=queue[p.predecessor];
printf("(%d,%d)\n",p.row,p.col);
maze[p.row][p.col]=3;
}
}
else {printf("\n=============================================================\n");
printf("此迷宫无解!\n\n");X=0;}
return 0;
}
int main()
{int i,m,n,cycle=0;
while(cycle!=(-1))
{
printf("********************************************************************************\n");
printf(" ☆欢迎进入迷宫求解系统☆\n");
printf(" 设计者:尹旭 林静波(信息2班)\n");
printf("********************************************************************************\n");
printf(" 手动生成迷宫 请按:1\n");
printf(" 自动生成迷宫 请按:2\n");
printf(" 退出 请按:3\n\n");
printf("********************************************************************************\n");
printf("\n");
printf("请选择你的操作:\n");
scanf("%d",i);
switch(i)
{case 1:printf("\n请输入行数:");
scanf("%d",m);
printf("\n");
printf("请输入列数:");
scanf("%d",n);
while((m=0||m50)||(n=0||n50))
{ printf("\n抱歉,你输入的行列数超出预设范围(0-50,0-50),请重新输入:\n\n");
printf("请输入行数:");
scanf("%d",m);
printf("\n");
printf("请输入列数:");
scanf("%d",n);
}
shoudong_maze(m,n);
print_maze(m,n);
mgpath(maze,m,n);
if(X!=0)
result_maze(m,n);
printf("\n\nPress Enter Contiue!\n");
getchar();
while(getchar()!='\n');
break;
case 2:printf("\n请输入行数:");
scanf("%d",m);
printf("\n");
printf("请输入列数:");
scanf("%d",n);
while((m=0||m50)||(n=0||n50))
{printf("\n抱歉,你输入的行列数超出预设范围(0-50,0-50),请重新输入:\n\n");
printf("请输入行数:");
scanf("%d",m);
printf("\n");
printf("请输入列数:");
scanf("%d",n);
}
zidong_maze(m,n);
print_maze(m,n);
mgpath(maze,m,n);
if(X!=0)
result_maze(m,n);
printf("\n\nPress Enter Contiue!\n");getchar();while(getchar()!='\n');break;
case 3:cycle=(-1);
break;
default:printf("\n");
printf("你的输入有误!\n");
printf("\nPress Enter Contiue!\n");
getchar();
while(getchar()!='\n');break;
}
}
}
c++编写一个迷宫游戏,求完整代码。最好能有适当的注释。
#include stdio.h
#include iostream
#include conio.h
#include windows.h
#include time.h
using namespace std;
#define Height 25//高度,必须为奇数
#define Width 25 //宽度,必须为奇数
#define Wall 1 //用1表示墙
#define Road 0 //用0表示路
#define Start 2
#define End 3
#define up 72
#define down 80
#define left 75
#define right 78
#define flag 5
int map[Height+2][Width+2];
int x=2,y=1; //玩家当前位置,刚开始在入口处
class Migong
{
public:
void gotoxy(int x,int y); //移动坐标的函数声明
void shengcheng(int x,int y); //随机生成迷宫的函数声明
void display(int x,int y); //显示迷宫的函数声明
void chushi(); //初始化迷宫的函数声明
};
class Wanjia:public Migong //玩家类由迷宫类派生来
{
public:
void gonglue(int x,int y);
void shang(int x,int y);
void xia(int x,int y);
void zuo(int x,int y);
void you(int x,int y);
void game(); //游戏运行包括移动的函数声明
};
void Migong::gotoxy(int x,int y) //移动坐标 这是使光标 到(x,y)这个位置的函数.调用 COORD 需要#include.
{
COORD coord;
coord.X=x;
coord.Y=y;
SetConsoleCursorPosition( GetStdHandle( STD_OUTPUT_HANDLE ), coord );
}
void Migong::shengcheng(int x,int y) //随机生成迷宫
{
int c[4][2]={0,1,1,0,0,-1,-1,0}; //四个方向 //数组c 0 1 向右
// 1 0 向下
// -1 0 向上
// 0 -1 向左
int i,j,t;
//将方向打乱
for(i=0;i4;i++)
{
j=rand()%4; //随机生成j
t=c[i][0];c[i][0]=c[j][0];c[j][0]=t; //将c[i][0]和c[j][0]交换
t=c[i][1];c[i][1]=c[j][1];c[j][1]=t; //类似上
}
map[x][y]=Road; //当前位置设为路
for(i=0;i4;i++) //沿四个方向设置
if(map[x+2*c[i][0]][y+2*c[i][1]]==Wall) //沿c[i][0]、c[i][1]方向前2步如果是墙
{
map[x+c[i][0]][y+c[i][1]]=Road; //让该方向前一步设为路
shengcheng(x+2*c[i][0],y+2*c[i][1]); //在该方向前两步继续生成地图 因为这里是递归函数,当执行到最后一点发现都不能走的时候,
//会返回到上一个函数,也就是上一个点,再次判断是否可以产生地图 ,知道地图上所有点被遍历完。
}
}
void Migong::display(int x,int y) //显示迷宫
{
gotoxy(2*y-2,x-1);
switch(map[x][y])
{
case Start:
cout"入";break; //显示入口
case End:
cout"出";break; //显示出口
case Wall:
cout"■";break; //显示墙
case Road:
cout" ";break; //显示路
case up:
cout"↑";break; //在攻略中的标记 下同
case down:
cout"↓";break;
case left:
cout"←";break;
case right:
cout"→";break;
case flag:
cout" ";break; //标记,防止攻略遍历时候无线循环
}
}
void Migong::chushi()
{
int i,j;
srand((unsigned)time(NULL)); //初始化随机种子
for(i=0;i=Height+1;i++)
for(j=0;j=Width+1;j++)
if(i==0||i==Height+1||j==0||j==Width+1) //初始化迷宫 默认四周是路
map[i][j]=Road;
else map[i][j]=Wall;
shengcheng(2*(rand()%(Height/2)+1),2*(rand()%(Width/2)+1)); //从随机一个点开始生成迷宫,该点行列都为偶数
for(i=0;i=Height+1;i++) //边界处理 把最开始默认为路的堵上,以免跑出迷宫
{
map[i][0]=Wall;
map[i][Width+1]=Wall;
}
for(j=0;j=Width+1;j++) //边界处理
{
map[0][j]=Wall;
map[Height+1][j]=Wall;
}
map[2][1]=Start; //给定入口
map[Height-1][Width]=End; //给定出口
for(i=1;i=Height;i++) //i初始为1,结束为height,以免画出外围
for(j=1;j=Width;j++) //画出迷宫 同上
display(i,j);
}
void Wanjia::game()
{
int x=2,y=1; //玩家当前位置,刚开始在入口处
int c; //用来接收按键
while(1)
{
gotoxy(2*y-2,x-1);
cout"☆"; //画出玩家当前位置
if(map[x][y]==End) //判断是否到达出口
{
gotoxy(30,24); //到达此坐标
cout"到达终点,按任意键结束";
getch();
break;
c=getch();
}
if(c!=-32)
{
c=getch();
switch(c)
{
case 72: //向上走
if(map[x-1][y]!=Wall)
{
display(x,y);
x--;
}
break;
case 80: //向下走
if(map[x+1][y]!=Wall)
{
display(x,y);
x++;
}
break;
case 75: //向左走
if(map[x][y-1]!=Wall)
{
display(x,y);
y--;
}
break;
case 77: //向右走
if(map[x][y+1]!=Wall)
{
display(x,y);
y++;
}
break;
case 112: //按下P
gonglue(2,1);break; //如果按下P执行攻略函数
}
}
}
}
void Wanjia::shang(int x,int y)
{
if(map[x][y]==End) //判断是否到达出口
{
gotoxy(52,20); //到达此坐标
cout"到达终点,按任意键结束";
getch();
exit(0);
}
if(map[x-1][y]!=Wallmap[x-1][y]!=upmap[x-1][y]!=downmap[x-1][y]!=leftmap[x-1][y]!=rightmap[x-1][y]!=flag)
{ //当移动后的下一个位置没有被走过且不是墙
map[x][y]=up;
display(x,y);
x--;
gonglue(x,y); //递归,攻略下一个点
}
}
void Wanjia::xia(int x,int y)
{
if(map[x][y]==End) //判断是否到达出口
{
gotoxy(52,20); //到达此坐标
cout"到达终点,按任意键结束";
getch();
exit(0);
}
if(map[x+1][y]!=Wallmap[x+1][y]!=upmap[x+1][y]!=downmap[x+1][y]!=leftmap[x+1][y]!=rightmap[x+1][y]!=flag) //当移动后的下一个位置没有被走过且不是墙
{
map[x][y]=down;
display(x,y);
x++;
gonglue(x,y); //递归,攻略下一个点
}
}
void Wanjia::zuo(int x,int y)
{
if(map[x][y]==End) //判断是否到达出口
{
gotoxy(52,20); //到达此坐标
cout"到达终点,按任意键结束";
getch();
exit(0);
}
if(map[x][y-1]!=Wallmap[x][y-1]!=upmap[x][y-1]!=downmap[x][y-1]!=leftmap[x][y-1]!=rightmap[x][y-1]!=flag) //当移动后的下一个位置没有被走过且不是墙
{
map[x][y]=left;
display(x,y);
y--;
gonglue(x,y); //递归,攻略下一个点
}
}
void Wanjia::you(int x,int y)
{
if(map[x][y]==End) //判断是否到达出口
{
gotoxy(52,20); //到达此坐标
cout"到达终点,按任意键结束";
getch();
exit(0);
}
if(map[x][y+1]!=Wallmap[x][y+1]!=upmap[x][y+1]!=downmap[x][y+1]!=leftmap[x][y+1]!=rightmap[x][y+1]!=flag) //当移动后的下一个位置没有被走过且不是墙
{
map[x][y]=right;
display(x,y);
y++;
gonglue(x,y); //递归,攻略下一个点
}
}
void Wanjia::gonglue (int x,int y)
{
gotoxy(2*y-2,x-1);
cout"☆"; //画出玩家当前位置
if(map[x][y]==End) //判断是否到达出口
{
gotoxy(52,20); //到达此坐标
cout"到达终点,按任意键结束";
getch();
exit(0);
}
shang(x,y); //上下左右
xia(x,y);
zuo(x,y);
you(x,y);
map[x][y]=flag; //当上下左右都无法走的时候,即为死路,因为递归函数开始向后,所以讲死路点值置为flag,变成无形之墙。
display(x,y);
}
int main()
{
cout" 移动迷宫 "endl;
cout"--------------------"endl;
cout"欢迎来到移动迷宫游戏"endl;
cout"--------------------"endl;
cout"游戏说明:给定一出口和入口"endl;
cout"玩家控制一个五角星(☆)从入口走到出口"endl;
cout"系统会记录你所走的步数"endl;
cout"按回车进入游戏";
cout"(按下P键可以获得攻略。)";
getch();
system("cls"); //清屏函数 ,清除开始界面
Wanjia w1;
w1.chushi();
w1.game(); //开始游戏
// w1.gonglue(2,1); //功略显示
getch();
return 0;
}
————————————————
版权声明:本文为CSDN博主「失落之风」的原创文章,遵循 CC 4.0 BY-SA 版权协议,转载请附上原文出处链接及本声明。
原文链接:
喜欢的源码拿走,把小赞赞留下
关于Java走迷宫的问题。我已经有相关代码了,但是我看不懂。麻烦高手帮忙注释一下,然后再修改点儿。
package 走迷宫;
import java.awt.BorderLayout;
import java.awt.Color;
import java.awt.GridLayout;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;
import java.util.TimerTask;
import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JOptionPane;
import javax.swing.JPanel;
// 迷宫
public class Maze extends JFrame implements ActionListener {
private JPanel panel;
private JPanel northPanel;
private JPanel centerPanel;
private MazeGrid grid[][];
private JButton restart;
private JButton dostart;
private int rows;// rows 和cols目前暂定只能是奇数
private int cols;
private ListString willVisit;
private ListString visited;
private LinkedListString comed;
private long startTime;
private long endTime;
public Maze() {
rows = 25;
cols = 25;
willVisit = new ArrayListString();
visited = new ArrayListString();
comed = new LinkedListString();
init();
this.setTitle("回溯法--走迷宫");
this.add(panel);
this.pack();
this.setVisible(true);
this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
}
public void init() {
panel = new JPanel();
northPanel = new JPanel();
centerPanel = new JPanel();
panel.setLayout(new BorderLayout());
restart = new JButton("重新生成迷宫");
dostart = new JButton("开始走迷宫");
grid = new MazeGrid[rows][cols];
centerPanel.setLayout(new GridLayout(rows, cols, 1, 1));
centerPanel.setBackground(new Color(0, 0, 0));
northPanel.add(restart);
northPanel.add(dostart);
dostart.addActionListener(this);
restart.addActionListener(this);
for (int i = 0; i grid.length; i++)
for (int j = 0; j grid[i].length; j++) {
if (j % 2 == 0 i % 2 == 0)
grid[i][j] = new MazeGrid(true, 20, 20);
else
grid[i][j] = new MazeGrid(false, 20, 20);
}
grid[0][0].setVisited(true);
grid[0][0].setPersonCome(true);
grid[0][0].setStart(true);
visited.add("0#0");
grid[rows - 1][cols - 1].setEnd(true);
grid = createMap(grid, 0, 0);
for (int i = 0; i grid.length; i++)
for (int j = 0; j grid[i].length; j++) {
grid[i][j].repaint();
centerPanel.add(grid[i][j]);
}
panel.add(northPanel, BorderLayout.NORTH);
panel.add(centerPanel, BorderLayout.CENTER);
}
/**
* 生成迷宫
*
* @param mazeGrid
* @param x
* @param y
* @return
*/
public MazeGrid[][] createMap(MazeGrid mazeGrid[][], int x, int y) {
int visitX = 0;
int visitY = 0;
if (x - 2 = 0) {
if (!mazeGrid[x - 2][y].isVisited()) {
willVisit.add((x - 2) + "#" + y);
}
}
if (x + 2 cols) {
if (!mazeGrid[x + 2][y].isVisited()) {
willVisit.add((x + 2) + "#" + y);
}
}
if (y - 2 = 0) {
if (!mazeGrid[x][y - 2].isVisited()) {
willVisit.add(x + "#" + (y - 2));
}
}
if (y + 2 rows) {
if (!mazeGrid[x][y + 2].isVisited()) {
willVisit.add(x + "#" + (y + 2));
}
}
if (!willVisit.isEmpty()) {
int visit = (int) (Math.random() * willVisit.size());
String id = willVisit.get(visit);
visitX = Integer.parseInt(id.split("#")[0]);
visitY = Integer.parseInt(id.split("#")[1]);
mazeGrid[(visitX + x) / 2][(visitY + y) / 2].setMark(true);
mazeGrid[visitX][visitY].setVisited(true);
if (!visited.contains(id)) {// 将这个点加到已访问中去
visited.add(id);
}
willVisit.clear();
createMap(mazeGrid, visitX, visitY);
} else {
if (!visited.isEmpty()) {
String id = visited.remove(visited.size() - 1);// 取出最后一个元素
visitX = Integer.parseInt(id.split("#")[0]);
visitY = Integer.parseInt(id.split("#")[1]);
mazeGrid[visitX][visitY].setVisited(true);
createMap(mazeGrid, visitX, visitY);
}
}
return mazeGrid;
}
/**
* 走迷宫
*
* @param mazeGrid
* @param x
* @param y
*/
public String goMaze(MazeGrid mazeGrid[][], int x, int y) {
int comeX = 0;
int comeY = 0;
// left
if (x - 1 = 0) {
if (mazeGrid[x - 1][y].isMark()) {
if (!comed.contains((x - 1) + "#" + y))
willVisit.add((x - 1) + "#" + y);
}
}
// right
if (x + 1 cols) {
if (mazeGrid[x + 1][y].isMark()) {
if (!comed.contains((x + 1) + "#" + y))
willVisit.add((x + 1) + "#" + y);
}
}
// up
if (y - 1 = 0) {
if (mazeGrid[x][y - 1].isMark()) {
if (!comed.contains(x + "#" + (y - 1)))
willVisit.add(x + "#" + (y - 1));
}
}
// down
if (y + 1 rows) {
if (mazeGrid[x][y + 1].isMark()) {
if (!comed.contains(x + "#" + (y + 1)))
willVisit.add(x + "#" + (y + 1));
}
}
if (!willVisit.isEmpty()) {
int visit = (int) (Math.random() * willVisit.size());
String id = willVisit.get(visit);
comeX = Integer.parseInt(id.split("#")[0]);
comeY = Integer.parseInt(id.split("#")[1]);
mazeGrid[x][y].setPersonCome(false);
mazeGrid[comeX][comeY].setPersonCome(true);
mazeGrid[x][y].repaint();
mazeGrid[comeX][comeY].repaint();
willVisit.clear();
comed.add(x + "#" + y);
} else {
if (!comed.isEmpty()) {
String id = comed.removeLast();
comeX = Integer.parseInt(id.split("#")[0]);
comeY = Integer.parseInt(id.split("#")[1]);
mazeGrid[x][y].setPersonCome(false);
mazeGrid[comeX][comeY].setPersonCome(true);
mazeGrid[x][y].repaint();
mazeGrid[comeX][comeY].repaint();
comed.addFirst(x + "#" + y);
}
}
return comeX + "#" + comeY;
}
int comeX = 0;
int comeY = 0;
public void actionPerformed(ActionEvent e) {
if (e.getActionCommand().equals("重新生成迷宫")) {
refreshMap(grid);
} else if (e.getActionCommand().equals("开始走迷宫")) {
startTime = System.currentTimeMillis();
dostart.setVisible(false);
restart.setText("禁止刷新");
int delay = 1000;
int period = 500;// 循环间隔
java.util.Timer timer = new java.util.Timer();
timer.scheduleAtFixedRate(new TimerTask() {
public void run() {
if (grid[rows - 1][cols - 1].isPersonCome()) {
endTime = System.currentTimeMillis();
JOptionPane.showMessageDialog(null, "已经走出迷宫,耗时"
+ (endTime - startTime) / 1000 + "秒", "消息提示",
JOptionPane.ERROR_MESSAGE);
this.cancel();
restart.setText("重新生成迷宫");
} else {
String id = goMaze(grid, comeX, comeY);
comeX = Integer.parseInt(id.split("#")[0]);
comeY = Integer.parseInt(id.split("#")[1]);
}
}
}, delay, period);
}
}
/**
* 刷新地图
*/
public void refreshMap(MazeGrid mazeGrid[][]) {
comeX = 0;
comeY = 0;
willVisit.clear();
visited.clear();
comed.clear();
this.remove(panel);
init();
this.add(panel);
this.pack();
this.setVisible(true);
}
public static void main(String args[]) {
long start = System.currentTimeMillis();
new Maze();
long end = System.currentTimeMillis();
System.out.println("使用ArrayList生成迷宫耗时:" + (end - start) + "毫秒");
}
}
java迷宫move类意思
这个没啥含义啊,一个对象类
private int x;
private int y;
两个属性,从字面意义上说x是横坐标,y是纵坐标。
public Move(){
}无参数的构造方法
public Move(int x, int y){
this.x = x;
this.y = y;
}有参数的构造方法
下面那些get方法时用来访问对象属性的,set方法是给对象属性赋值的。
给你举个例子你就知道了
Move m1=new Move();这里声明了一个Move类的对象,调用的是无参数的构造方法,也就是说m1的x和y都是没有赋值的。但是呢,int类型默认值是0;
然后你可以通过set方法去给属性赋值m1.setX(2),然后通过get方法取值m1.getX()这个时候就能取到2了。
而有参数的构造方法就是在声明对象的时候直接赋值给元素
Move m2=new Move(1,2);这个时候你再用get方法去取,就会有x=1,y=2了,就是省掉了用set方法赋值的一步。
你还是先看看什么是对象,什么是构造函数,还有get,set方法的作用吧
急需一java高手帮忙写一迷宫程序
给你代码,你给出的那两个类,不能满足,我的需要,我就没有使用。
你看一下吧。
----------------------------------------
package stackpackage;
import java.io.BufferedReader;
import java.io.FileReader;
import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;
public class Maze {
// 上
private static Point directionTop = new Point(-1, 0);
// 下
private static Point directionBottom = new Point(1, 0);
// 左
private static Point directionLeft = new Point(0, -1);
// 右
private static Point directionRight = new Point(0, 1);
private static Point[] directions = { directionTop, directionRight,
directionBottom, directionLeft };
private static boolean isStop = false;
private static int row = 0;
private static int col = 0;
private static Point startPoint = new Point();
public static void main(String[] args) throws Exception {
FileReader fr = new FileReader("data.txt");
BufferedReader br = new BufferedReader(fr);
int rowIndex = 1;
int[][] maze = null;
while (br.ready()) {
String line = br.readLine();
Scanner sc = new Scanner(line);
if (rowIndex == 1) {
row = sc.nextInt();
col = sc.nextInt();
maze = new int[row][col];
} else {
if (rowIndex row + 2) {
for (int i = 0; i col; i++) {
maze[rowIndex - 2][i] = sc.nextInt();
}
} else {
startPoint.x = sc.nextInt();
startPoint.y = sc.nextInt();
}
}
rowIndex++;
}
ListPoint route = new ArrayListPoint();
route.add(startPoint);
findNext(startPoint);
puzzle(maze, startPoint, route);
System.out.println(route);
}
private static void puzzle(int[][] maze, Point p, ListPoint route) {
if (isStop) {
return;
}
Point[] nextDirections = p.nextDirections;
for (int i = 0; i nextDirections.length; i++) {
if (isStop) {
return;
}
Point direction = nextDirections[i];
Point newP = new Point(p.x + direction.x, p.y + direction.y);
if (newP.isEffective() maze[newP.x][newP.y] == 0
!route.contains(newP)) {
newP.before = p;
findNext(newP);
route.add(newP);
if (isExit(newP)) {
isStop = true;
break;
}
puzzle(maze, newP, route);
}
}
if (isStop) {
return;
}
route.remove(route.size() - 1);
}
private static void findNext(Point p) {
int index = 0;
Point[] nextDirections = new Point[3];
for (int i = 0; i nextDirections.length; i++) {
nextDirections[i] = new Point(0, 0);
}
for (int i = 0; i directions.length; i++) {
Point direction = directions[i];
Point newP = new Point(p.x + direction.x, p.y + direction.y);
if (newP.isEffective() !newP.equals(p.before) newP.x row
newP.y col) {
nextDirections[index++] = direction;
}
}
p.nextDirections = nextDirections;
}
private static boolean isExit(Point p) {
if (startPoint.equals(p)) {
return false;
}
for (int i = 0; i directions.length; i++) {
Point direction = directions[i];
Point newP = new Point(p.x + direction.x, p.y + direction.y);
if (!newP.equals(p.before)
(newP.x = row || newP.y = col || newP.x 0 || newP.y 0)) {
return true;
}
}
return false;
}
}
class Point {
int x = 0;
int y = 0;
Point[] nextDirections = null;
Point before = null;
public Point() {
}
public Point(int x, int y) {
this.x = x;
this.y = y;
}
public String toString() {
return "" + x + "," + y + "";
}
public boolean isEffective() {
return x = 0 y = 0;
}
public boolean equals(Object obj) {
return equals((Point) obj);
}
public boolean equals(Point p) {
if (p == null) {
return false;
}
return this.x == p.x this.y == p.y;
}
}