Java实现走迷宫

最新推荐文章于 2022-01-07 00:38:20 发布
最新推荐文章于 2022-01-07 00:38:20 发布
阅读量375 收藏
点赞数
分类专栏： ++++++++SOA++++++++++ # Java ++++++++Algorithm++++++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/SoftpaseFar/article/details/115158075
版权

在这里插入图片描述

敢于知道，因为真理使我们自由！

图形绘制-普通方法（测试）

AlgoFrame 自定义窗口类

package com.company;

import javax.swing.*;

import javax.swing.*;
import java.awt.*;

public class AlgoFrame extends JFrame {

  private int canvasWidth;
  private int canvasHeight;

  public AlgoFrame(String title, int canvasWidth, int canvasHeight) {
    super(title);
    this.canvasWidth = canvasWidth;
    this.canvasHeight = canvasHeight;

    AlgoCanvas canvas = new AlgoCanvas();
    setContentPane(canvas);
    pack();
    
    setResizable(false);
    setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
    setVisible(true);

  }

  public AlgoFrame(String title) {
    this(title, 1024, 768);
  }

  public int getCanvasWidth() {
    return canvasWidth;
  }

  public int getCanvasHeight() {
    return canvasHeight;
  }

  private class AlgoCanvas extends JPanel {
    @Override
    public void paintComponent(Graphics g) {
      super.paintComponent(g);
      g.drawOval(50, 50, 300, 300);
    }

    @Override
    public Dimension getPreferredSize() {
      return new Dimension(canvasWidth, canvasHeight);
    }
  }
}

Main 主函数逻辑

package com.company;

import java.awt.*;

public class Main {

  public static void main(String[] args) {
    EventQueue.invokeLater(() -> {
      AlgoFrame frame = new AlgoFrame("Welcome", 500, 500);
    });

  }
}

在这里插入图片描述

图形绘制-Graphics2D法（测试）

Graphics2D好处

相关代码

package com.company;

import javax.swing.*;

import javax.swing.*;
import java.awt.*;
import java.awt.geom.Ellipse2D;

public class AlgoFrame extends JFrame {

  private int canvasWidth;
  private int canvasHeight;

  public AlgoFrame(String title, int canvasWidth, int canvasHeight) {
    super(title);
    this.canvasWidth = canvasWidth;
    this.canvasHeight = canvasHeight;

    AlgoCanvas canvas = new AlgoCanvas();
    setContentPane(canvas);
    pack();

    setResizable(false);
    setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
    setVisible(true);

  }

  public AlgoFrame(String title) {
    this(title, 1024, 768);
  }

  public int getCanvasWidth() {
    return canvasWidth;
  }

  public int getCanvasHeight() {
    return canvasHeight;
  }

  private class AlgoCanvas extends JPanel {
    @Override
    public void paintComponent(Graphics g) {
      super.paintComponent(g);
      Graphics2D g2d = (Graphics2D) g;

      int strokeWidth = 5;
      g2d.setStroke(new BasicStroke(strokeWidth));

      g2d.setColor(Color.RED);
      Ellipse2D circle = new Ellipse2D.Double(50, 50, 300, 300);
      g2d.draw(circle);

      g2d.setColor(Color.BLUE);
      Ellipse2D circle2 = new Ellipse2D.Double(60, 60, 280, 280);
      g2d.fill(circle2);
    }

    @Override
    public Dimension getPreferredSize() {
      return new Dimension(canvasWidth, canvasHeight);
    }
  }
}

在这里插入图片描述

封装-工具类

AlgoVisHelper

package com.company;

import java.awt.*;
import java.awt.geom.Ellipse2D;

public class AlgoVisHelper {
  private AlgoVisHelper() {
  }

  public static void setColor(Graphics2D g2d,Color color){
    g2d.setColor(color);
  }

  public static void setStrokeWidth(Graphics2D g2d, int w) {
    int strokeWidth = w;
    g2d.setStroke(new BasicStroke(strokeWidth,BasicStroke.CAP_ROUND,BasicStroke.JOIN_ROUND));
  }

  public static void strokeCircle(Graphics2D g2d,int x,int y,int r){
    Ellipse2D circle = new Ellipse2D.Double(x-r,y-r,2*r,2*r);
    g2d.draw(circle);
  };

  public static void fillCircle(Graphics2D g2d,int x,int y,int r){
    Ellipse2D circle = new Ellipse2D.Double(x-r,y-r,2*r,2*r);
    g2d.fill(circle);
  };
}

AlgoFrame

package com.company;

import javax.swing.*;

import javax.swing.*;
import java.awt.*;
import java.awt.geom.Ellipse2D;

public class AlgoFrame extends JFrame {

  private int canvasWidth;
  private int canvasHeight;

  public AlgoFrame(String title, int canvasWidth, int canvasHeight) {
    super(title);
    this.canvasWidth = canvasWidth;
    this.canvasHeight = canvasHeight;

    AlgoCanvas canvas = new AlgoCanvas();
    setContentPane(canvas);
    pack();

    setResizable(false);
    setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
    setVisible(true);

  }

  public AlgoFrame(String title) {
    this(title, 1024, 768);
  }

  public int getCanvasWidth() {
    return canvasWidth;
  }

  public int getCanvasHeight() {
    return canvasHeight;
  }

  private class AlgoCanvas extends JPanel {
    @Override
    public void paintComponent(Graphics g) {
      super.paintComponent(g);
      Graphics2D g2d = (Graphics2D) g;

      int strokeWidth = 5;
      g2d.setStroke(new BasicStroke(strokeWidth));

      AlgoVisHelper.setColor(g2d, Color.BLUE);
      AlgoVisHelper.fillCircle(g2d, canvasWidth / 2, canvasHeight / 2, 200);

      AlgoVisHelper.setColor(g2d, Color.RED);
      AlgoVisHelper.strokeCircle(g2d, canvasWidth / 2, canvasHeight / 2, 200);

    }

    @Override
    public Dimension getPreferredSize() {
      return new Dimension(canvasWidth, canvasHeight);
    }
  }
}

在这里插入图片描述

抗锯齿

package com.company;

import javax.swing.*;

import javax.swing.*;
import java.awt.*;
import java.awt.geom.Ellipse2D;

public class AlgoFrame extends JFrame {

  private int canvasWidth;
  private int canvasHeight;

  public AlgoFrame(String title, int canvasWidth, int canvasHeight) {
    super(title);
    this.canvasWidth = canvasWidth;
    this.canvasHeight = canvasHeight;

    AlgoCanvas canvas = new AlgoCanvas();
    setContentPane(canvas);
    pack();

    setResizable(false);
    setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
    setVisible(true);

  }

  public AlgoFrame(String title) {
    this(title, 1024, 768);
  }

  public int getCanvasWidth() {
    return canvasWidth;
  }

  public int getCanvasHeight() {
    return canvasHeight;
  }

  private class AlgoCanvas extends JPanel {
    @Override
    public void paintComponent(Graphics g) {
      super.paintComponent(g);
      Graphics2D g2d = (Graphics2D) g;
      //抗锯齿
      RenderingHints hints = new RenderingHints(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
      g2d.addRenderingHints(hints);

      //具体绘制
      AlgoVisHelper.setStrokeWidth(g2d, 5);

      AlgoVisHelper.setColor(g2d, Color.BLUE);
      AlgoVisHelper.fillCircle(g2d, canvasWidth / 2, canvasHeight / 2, 200);

      AlgoVisHelper.setColor(g2d, Color.RED);
      AlgoVisHelper.strokeCircle(g2d, canvasWidth / 2, canvasHeight / 2, 200);

    }

    @Override
    public Dimension getPreferredSize() {
      return new Dimension(canvasWidth, canvasHeight);
    }
  }
}

双缓存

package com.company;

import javax.swing.*;

import javax.swing.*;
import java.awt.*;
import java.awt.geom.Ellipse2D;

public class AlgoFrame extends JFrame {

  private int canvasWidth;
  private int canvasHeight;

  public AlgoFrame(String title, int canvasWidth, int canvasHeight) {
    super(title);
    this.canvasWidth = canvasWidth;
    this.canvasHeight = canvasHeight;

    AlgoCanvas canvas = new AlgoCanvas();
    setContentPane(canvas);
    pack();

    setResizable(false);
    setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
    setVisible(true);

  }

  public AlgoFrame(String title) {
    this(title, 1024, 768);
  }

  public int getCanvasWidth() {
    return canvasWidth;
  }

  public int getCanvasHeight() {
    return canvasHeight;
  }

  private class AlgoCanvas extends JPanel {
    //双缓存
    public AlgoCanvas() {
      super(true);
    }

    @Override
    public void paintComponent(Graphics g) {
      super.paintComponent(g);
      Graphics2D g2d = (Graphics2D) g;
      //抗锯齿
      RenderingHints hints = new RenderingHints(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
      g2d.addRenderingHints(hints);

      //具体绘制
      AlgoVisHelper.setStrokeWidth(g2d, 5);

      AlgoVisHelper.setColor(g2d, Color.BLUE);
      AlgoVisHelper.fillCircle(g2d, canvasWidth / 2, canvasHeight / 2, 200);

      AlgoVisHelper.setColor(g2d, Color.RED);
      AlgoVisHelper.strokeCircle(g2d, canvasWidth / 2, canvasHeight / 2, 200);

    }

    @Override
    public Dimension getPreferredSize() {
      return new Dimension(canvasWidth, canvasHeight);
    }
  }
}

实现测试用例

Main

package com.company;

import java.awt.*;

public class Main {
  public static void main(String[] args) {

    int sceneWidth = 800;
    int sceneHeight = 800;

    int N = 10;
    Circle[] circles = new Circle[N];
    int R = 50;

    for (int i = 0; i < N; i++) {
      int x = (int) Math.random() * (sceneWidth - 2 * R) + R;
      int y = (int) Math.random() * (sceneHeight - 2 * R) + R;
      int vx = (int) (Math.random() * 11 - 5);
      int vy = (int) (Math.random() * 11 - 5);
      circles[i] = new Circle(x, y, R, vx, vy);
    }

    EventQueue.invokeLater(() -> {
      AlgoFrame frame = new AlgoFrame("Welcome", sceneWidth, sceneHeight);
      new Thread(() -> {
        while (true) {
          //绘制数据
          frame.render(circles);
          AlgoVisHelper.pause(20);
          //更新数据
          for (Circle circle : circles) {
            circle.move(0, 0, sceneWidth, sceneHeight);
          }
        }
      }).start();

    });

  }
}

Circle

package com.company;

import com.sun.org.apache.bcel.internal.generic.IF_ACMPEQ;

public class Circle {
  public int x, y;
  private int r;

  public int getR() {
    return r;
  }

  public void setR(int r) {
    this.r = r;
  }


  public int vx, vy;

  public Circle(int x, int y, int r, int vx, int vy) {
    this.x = x;
    this.y = y;
    this.setR(r);
    this.vx = vx;
    this.vy = vy;
  }

  public void move(int minx, int miny, int maxx, int maxy) {
    x += vx;
    y += vy;
    checkCollision(minx, miny, maxx, maxy);
  }

  private void checkCollision(int minx, int miny, int maxx, int maxy) {
    if (x - r < minx) {
      x = r;
      vx = -vx;
    }
    if (x + r >= maxx) {
      x = maxx - r;
      vx = -vx;
    }
    if (y - r < miny) {
      y = r;
      vy = -vy;
    }
    if (y + r >= maxy) {
      y = maxy - r;
      vy = -vy;
    }
  }

}

AlgoVisHelper

package com.company;

import java.awt.*;
import java.awt.geom.Ellipse2D;

public class AlgoVisHelper {
  private AlgoVisHelper() {
  }

  public static void setColor(Graphics2D g2d,Color color){
    g2d.setColor(color);
  }

  public static void setStrokeWidth(Graphics2D g2d, int w) {
    int strokeWidth = w;
    g2d.setStroke(new BasicStroke(strokeWidth,BasicStroke.CAP_ROUND,BasicStroke.JOIN_ROUND));
  }

  public static void strokeCircle(Graphics2D g2d,int x,int y,int r){
    Ellipse2D circle = new Ellipse2D.Double(x-r,y-r,2*r,2*r);
    g2d.draw(circle);
  };

  public static void fillCircle(Graphics2D g2d,int x,int y,int r){
    Ellipse2D circle = new Ellipse2D.Double(x-r,y-r,2*r,2*r);
    g2d.fill(circle);
  };

  public static void pause(int t){
    try{
      Thread.sleep(t);
    }catch (InterruptedException e){
      System.out.println("Error in sleeping!");
    }
  }
}

AlgoFrame

package com.company;

import javax.swing.*;

import javax.swing.*;
import java.awt.*;
import java.awt.geom.Ellipse2D;

public class AlgoFrame extends JFrame {

  private int canvasWidth;
  private int canvasHeight;

  public AlgoFrame(String title, int canvasWidth, int canvasHeight) {
    super(title);
    this.canvasWidth = canvasWidth;
    this.canvasHeight = canvasHeight;

    AlgoCanvas canvas = new AlgoCanvas();
    setContentPane(canvas);
    pack();

    setResizable(false);
    setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
    setVisible(true);

  }

  public AlgoFrame(String title) {
    this(title, 1024, 768);
  }

  public int getCanvasWidth() {
    return canvasWidth;
  }

  public int getCanvasHeight() {
    return canvasHeight;
  }

  private Circle[] circles;

  public void render(Circle[] circles) {
    this.circles = circles;
    repaint();
  }

  private class AlgoCanvas extends JPanel {
    //双缓存
    public AlgoCanvas() {
      super(true);
    }

    @Override
    public void paintComponent(Graphics g) {
      super.paintComponent(g);
      Graphics2D g2d = (Graphics2D) g;
      //抗锯齿
      RenderingHints hints = new RenderingHints(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
      g2d.addRenderingHints(hints);

      //具体绘制
      AlgoVisHelper.setStrokeWidth(g2d, 1);
      AlgoVisHelper.setColor(g2d, Color.RED);
      for (Circle circle : circles) {
        AlgoVisHelper.strokeCircle(g2d, circle.x, circle.y, circle.getR());
      }
    }

    @Override
    public Dimension getPreferredSize() {
      return new Dimension(canvasWidth, canvasHeight);
    }
  }
}

在这里插入图片描述

MVC应用（修改和新建类 ）

Main

package com.company;

import java.awt.*;

public class Main {
  public static void main(String[] args) {

    int sceneWidth = 800;
    int sceneHeight = 800;

    int N = 10;

    AlgoVisualizer visualizer = new AlgoVisualizer(sceneWidth, sceneHeight, N);

  }
}

AlgoVisualizer

package com.company;

import java.awt.*;

public class AlgoVisualizer {
  private Circle[] circles;
  private AlgoFrame frame;

  public AlgoVisualizer(int sceneWidth, int sceneHeight, int N) {
    circles = new Circle[N];
    int R = 50;

    for (int i = 0; i < N; i++) {
      int x = (int) Math.random() * (sceneWidth - 2 * R) + R;
      int y = (int) Math.random() * (sceneHeight - 2 * R) + R;
      int vx = (int) (Math.random() * 11 - 5);
      int vy = (int) (Math.random() * 11 - 5);
      circles[i] = new Circle(x, y, R, vx, vy);
    }

    EventQueue.invokeLater(() -> {
      frame = new AlgoFrame("Welcome", sceneWidth, sceneHeight);
      new Thread(() -> {
        run();
      }).start();

    });
  }

  //动画逻辑
  private void run() {
    while (true) {
      //绘制数据
      frame.render(circles);
      AlgoVisHelper.pause(20);
      //更新数据
      for (Circle circle : circles) {
        circle.move(0, 0, frame.getCanvasWidth(), frame.getCanvasHeight());
      }
    }
  }

}

键盘事件（去掉Main类）

键盘按空格暂停/继续

package com.company;

import java.awt.*;
import java.awt.event.KeyAdapter;
import java.awt.event.KeyEvent;

public class AlgoVisualizer {
  private Circle[] circles;
  private AlgoFrame frame;
  private boolean isAnimated = true;

  public AlgoVisualizer(int sceneWidth, int sceneHeight, int N) {
    circles = new Circle[N];
    int R = 30;

    for (int i = 0; i < N; i++) {
      int x = (int) Math.random() * (sceneWidth - 2 * R) + R;
      int y = (int) Math.random() * (sceneHeight - 2 * R) + R;
      int vx = (int) (Math.random() * 11 - 5);
      int vy = (int) (Math.random() * 11 - 5);
      circles[i] = new Circle(x, y, R, vx, vy);
    }

    EventQueue.invokeLater(() -> {
      frame = new AlgoFrame("Welcome", sceneWidth, sceneHeight);
      frame.addKeyListener(new AlgoKeyListener());
      new Thread(() -> {
        run();
      }).start();

    });
  }

  //动画逻辑
  private void run() {
    while (true) {
      //绘制数据
      frame.render(circles);
      AlgoVisHelper.pause(20);
      //更新数据
      if (isAnimated) {
        for (Circle circle : circles) {
          circle.move(0, 0, frame.getCanvasWidth(), frame.getCanvasHeight());
        }
      }

    }
  }

  private class AlgoKeyListener extends KeyAdapter {
    @Override
    public void keyReleased(KeyEvent event) {
      if (event.getKeyChar() == ' ') {
        isAnimated = !isAnimated;
      }
    }
  }

  public static void main(String[] args) {

    int sceneWidth = 500;
    int sceneHeight = 500;

    int N = 10;

    AlgoVisualizer visualizer = new AlgoVisualizer(sceneWidth, sceneHeight, N);

  }

}

鼠标事件

Circle

package com.company;

import java.awt.*;

public class Circle {
  public int x, y;
  private int r;
  public boolean isFilled = false;

  public int getR() {
    return r;
  }

  public void setR(int r) {
    this.r = r;
  }


  public int vx, vy;

  public Circle(int x, int y, int r, int vx, int vy) {
    this.x = x;
    this.y = y;
    this.setR(r);
    this.vx = vx;
    this.vy = vy;
  }

  public void move(int minx, int miny, int maxx, int maxy) {
    x += vx;
    y += vy;
    checkCollision(minx, miny, maxx, maxy);
  }

  private void checkCollision(int minx, int miny, int maxx, int maxy) {
    if (x - r < minx) {
      x = r;
      vx = -vx;
    }
    if (x + r >= maxx) {
      x = maxx - r;
      vx = -vx;
    }
    if (y - r < miny) {
      y = r;
      vy = -vy;
    }
    if (y + r >= maxy) {
      y = maxy - r;
      vy = -vy;
    }


  }

  public boolean contain(Point p) {
    return (x - p.x) * (x - p.x) + (y - p.y) * (y - p.y) <= r * r;
  }

}

AlgoVisHelper

package com.company;

import java.awt.*;
import java.awt.geom.Ellipse2D;

public class AlgoVisHelper {
  private AlgoVisHelper() {
  }

  public static void setColor(Graphics2D g2d,Color color){
    g2d.setColor(color);
  }

  public static void setStrokeWidth(Graphics2D g2d, int w) {
    int strokeWidth = w;
    g2d.setStroke(new BasicStroke(strokeWidth,BasicStroke.CAP_ROUND,BasicStroke.JOIN_ROUND));
  }

  public static void strokeCircle(Graphics2D g2d,int x,int y,int r){
    Ellipse2D circle = new Ellipse2D.Double(x-r,y-r,2*r,2*r);
    g2d.draw(circle);
  };

  public static void fillCircle(Graphics2D g2d,int x,int y,int r){
    Ellipse2D circle = new Ellipse2D.Double(x-r,y-r,2*r,2*r);
    g2d.fill(circle);
  };

  public static void pause(int t){
    try{
      Thread.sleep(t);
    }catch (InterruptedException e){
      System.out.println("Error in sleeping!");
    }
  }
}

AlgoVisualizer

package com.company;

import java.awt.*;
import java.awt.event.KeyAdapter;
import java.awt.event.KeyEvent;
import java.awt.event.MouseAdapter;
import java.awt.event.MouseEvent;

public class AlgoVisualizer {
  private Circle[] circles;
  private AlgoFrame frame;
  private boolean isAnimated = true;

  public AlgoVisualizer(int sceneWidth, int sceneHeight, int N) {
    circles = new Circle[N];
    int R = 30;

    for (int i = 0; i < N; i++) {
      int x = (int) Math.random() * (sceneWidth - 2 * R) + R;
      int y = (int) Math.random() * (sceneHeight - 2 * R) + R;
      int vx = (int) (Math.random() * 11 - 5);
      int vy = (int) (Math.random() * 11 - 5);
      circles[i] = new Circle(x, y, R, vx, vy);
    }

    EventQueue.invokeLater(() -> {
      frame = new AlgoFrame("Welcome", sceneWidth, sceneHeight);
      frame.addKeyListener(new AlgoKeyListener());
      frame.addMouseListener(new AlgoMouseListener());
      new Thread(() -> {
        run();
      }).start();

    });
  }

  //动画逻辑
  private void run() {
    while (true) {
      //绘制数据
      frame.render(circles);
      AlgoVisHelper.pause(20);
      //更新数据
      if (isAnimated) {
        for (Circle circle : circles) {
          circle.move(0, 0, frame.getCanvasWidth(), frame.getCanvasHeight());
        }
      }

    }
  }

  private class AlgoMouseListener extends MouseAdapter{
    @Override
    public void mousePressed(MouseEvent event) {
      event.translatePoint(0,-(frame.getBounds().height-frame.getCanvasHeight()));
      for(Circle circle:circles){
        if(circle.contain(event.getPoint())){
          circle.isFilled = !circle.isFilled;
        }
      }
    }
  }


  private class AlgoKeyListener extends KeyAdapter {
    @Override
    public void keyReleased(KeyEvent event) {
      if (event.getKeyChar() == ' ') {
        isAnimated = !isAnimated;
      }
    }
  }

  public static void main(String[] args) {

    int sceneWidth = 500;
    int sceneHeight = 500;

    int N = 10;

    AlgoVisualizer visualizer = new AlgoVisualizer(sceneWidth, sceneHeight, N);

  }

}

AlgoFrame

package com.company;

import javax.swing.*;

import java.awt.*;

public class AlgoFrame extends JFrame {

  private int canvasWidth;
  private int canvasHeight;

  public AlgoFrame(String title, int canvasWidth, int canvasHeight) {
    super(title);
    this.canvasWidth = canvasWidth;
    this.canvasHeight = canvasHeight;

    AlgoCanvas canvas = new AlgoCanvas();
    setContentPane(canvas);
    pack();

    setResizable(false);
    setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
    setVisible(true);

  }

  public AlgoFrame(String title) {
    this(title, 1024, 768);
  }

  public int getCanvasWidth() {
    return canvasWidth;
  }

  public int getCanvasHeight() {
    return canvasHeight;
  }

  private Circle[] circles;

  public void render(Circle[] circles) {
    this.circles = circles;
    repaint();
  }

  private class AlgoCanvas extends JPanel {
    //双缓存
    public AlgoCanvas() {
      super(true);
    }

    @Override
    public void paintComponent(Graphics g) {
      super.paintComponent(g);
      Graphics2D g2d = (Graphics2D) g;
      //抗锯齿
      RenderingHints hints = new RenderingHints(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
      g2d.addRenderingHints(hints);

      //具体绘制
      AlgoVisHelper.setStrokeWidth(g2d, 1);
      AlgoVisHelper.setColor(g2d, Color.RED);
      for (Circle circle : circles) {
        if (!circle.isFilled) {
          AlgoVisHelper.strokeCircle(g2d, circle.x, circle.y, circle.getR());

        } else {
          AlgoVisHelper.fillCircle(g2d, circle.x, circle.y, circle.getR());

        }
      }
    }

    @Override
    public Dimension getPreferredSize() {
      return new Dimension(canvasWidth, canvasHeight);
    }
  }
}

持续更新中…

赵延超
关注
专栏目录
java学习--走迷宫
weixin_44466545的博客
02-18 308
走迷宫问题 public class MiGong { public static void main(String[] args) { //思路 //1.先创建迷宫，用二维数组表示 int[][]map=new int[8][7] //2.先规定map数组的元素值：0表示可以走 1表示障碍物 int [][]map = new int[8][7]; //3.将最上面的一行和最下面的一行，全部设置为1 for(int i=0;i<7;i++){ map[0][i
java 走迷宫_Java简单走迷宫
weixin_36285826的博客
02-18 310
import java.math.;import java.util.;import javax.swing.text.ChangedCharSetException;class Point{public int x;public int y;public int getx() {return x;}public int gety() {return y;}}class Game{Stackpos...
走迷宫 java_Java --- 走迷宫
weixin_27207591的博客
02-20 150
走迷宫需要考虑大量的实验和错误：沿着一条路径走，当不能再向前走时回溯，然后尝试另一条以前没尝试过的选择。可是使用递归算法。//**********************************************************// MaseSearch.java//**********************************************************p...
走迷宫的java实现
12-10
在设计迷宫游戏时，编写了两个Java源文件Maze.java和MazeGrid.java。Maze.java中main类实现弹出游戏耗时窗口功能，createMap类用于实现生成迷宫功能，goMaze类用于实现走迷宫功能，refreshMap类实现刷新迷宫地图功能；MazeGrid.java实现确定正确行走路径的功能。
用JAVA实现走迷宫
bingo_pwb的博客
01-07 1607
一个迷宫，他有一个入口和一个出口，试寻找一条从入口到出口的路径。 import java.util.Stack; public class Maze { //保存迷宫 private int[][] maze; //入口与出口 private Location in; private Location out; //保存路径 private Stack<Location> stack; //初始化 public Maz
Java实现走迷宫回溯算法
08-28
Java实现走迷宫回溯算法 Java 实现走迷宫回溯算法是一种常用的路径搜索算法，通过回溯法来解决迷宫问题。下面是对该算法的详细介绍和实现。 算法介绍 走迷宫回溯算法是一种基于栈的搜索算法，通过模拟人走迷宫的...
java实现走迷宫
03-14
本文通过详细解析Java实现走迷宫的算法，不仅介绍了其实现原理和技术细节，还深入探讨了核心数据结构和关键逻辑。这种基于深度优先搜索的递归算法能够有效解决迷宫问题，并且通过适当的优化可以应用于更复杂的情况。...
JAVA实现走迷宫借鉴.pdf
11-04
《JAVA实现走迷宫程序详解》 在编程领域，实现迷宫求解是一个经典的问题，而使用Java语言来实现这一功能则提供了丰富的工具和结构。本文将深入解析一个基于Java的走迷宫程序的设计和实现，主要关注MazeWindow类及其...
JAVA实现走迷宫.doc
10-03
JAVA实现走迷宫.doc
走迷宫游戏（java）
12-09
走迷宫游戏： 程序开始运行时显示一个迷宫地图，迷宫中央有一只老鼠，迷宫的右下方有一个粮仓。游戏的任务是使用键盘上的方向键操纵老鼠在规定的时间内走到粮仓处，老鼠只能按照上下左右四个方向行走。 1）图形化的界面，要求有计时、计数等方面的功能； 2）迷宫地图随机产生，地图布局用系统文件的形式保存，系统提供存盘和读出等功能； 3）走迷宫可以手工行走，按键与cs相同，也可以系统自动寻找。 4) 老鼠形象可辨认，可用键盘操纵老鼠上下左右移动； 5) 迷宫的墙足够结实，老鼠不能穿墙而过； 6) 正确检测结果，若老鼠在规定时间内走到粮仓处，提示成功，否则提示失败； 7) 添加编辑迷宫功能，可修改当前迷宫，修改内容：墙变路、路变墙； 8) 找出走出迷宫的所有路径，以及最短路径。
Java 走迷宫
11-06
用Java写的一个走迷宫的小游戏~ 有图形界面撒~ 可以用键盘控制撒~ 完全可行撒~
走迷宫java编写的
01-09
附带排行榜的 走迷宫 源码 很棒 。
java 走迷宫_JAVA实现走迷宫
weixin_39608613的博客
02-22 339
1、MazeWindow 主类import javax.swing.*;import java.awt.*;import java.awt.event.*;import java.io.*;import java.util.Hashtable;import javax.swing.filechooser.*;public class MazeWindow extends JFrame implem...
java走迷宫求指教
qq_39499285的博客
03-17 280
import java.util.Stack;class Step{    int x,y,d;    public Step(int x,int y,int d) {        this.x = x;//横坐标        this.y = y;//纵坐标        this.d = d;//方向    }}public class Maze {public static void m...
利用Java解决走迷宫问题
HSBhuang的博客
12-18 6974
利用Java解决走迷宫问题 概述 假设有一个如下图所示的迷宫，灰色部分是墙壁不可走，白色部分是可以走的路，蓝色位置为迷宫的入口，绿色位置为出口。从入口出发，规定只能通过向上、向下、向左和向右方向进行走动，问如何才能找到一条到达出口的通路。 思路 可以用一个二维矩阵来模拟迷宫地图，0代表灰色部分的墙壁，1代表白色部分可走的路 当每走过一个位置后，把改位置的值标记为-1，如果该位置标记为-1，则不可以重复走 判断当前位置是否有路可走，根据向右、向下、向左、向上的顺序判断该位置的下一步是否有路可走
java 走迷宫
weixin_45508707的博客
04-05 605
java 走迷宫 ```import java.util.*; public class MiGong{ public static void main(String [] args){ int[][] array = { {1,1,1,1,1,1,1,1,1}, {0,1,0,0,0,0,0,1,0}, {1,1,1,0,0,0,0,1,0}, {1,1,0,0,0,0,0,1,0}, {1,1,0,0,0,0,0,1,0}, {0,1,1,1,1,0,0,1,0
java小游戏——走迷宫
weixin_40656052的博客
10-24 1126
main类 public class Main { public static void main(String[] args){ new PreviousSynopsis(); } } PreviousSynopsis类 //导入要用到的包中的类接口 import java.awt.Image; import java.awt.event.ActionEv...
java实现走迷宫游戏代码
最新发布
04-07
你好，以下是 Java 实现走迷宫游戏的代码： ```java import java.util.*; public class MazeSolver { private int[][] maze; // 迷宫 private int[] start; // 起点坐标 private int[] end; // 终点坐标 ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值