devbox
你好赵伟
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

用Java实现拼图小游戏_导入图片拼图游戏

作者：你好赵伟 | 2024-05-17 16:50:23

赞

踩

导入图片拼图游戏

用JAVA实现拼图小游戏

目录

一、项目简介

          用JAVA的JFrame,JButton等工具实现拼图小游戏，包括拼图功能，更换图片功能，重新开始功能等等。

一、界面搭建和菜单搭建

          首先创建一个名为GameJframe的类，通过setSize()方法以及setTitle()等方法来初始化一个JFrame窗口，并设置标题为“拼图单机版”，通过setAlwaysOnTop()方法设置窗口置顶，并通过setLocationRelativeTo()方法设置窗口居中，而为使玩家可以通过关闭游戏窗口而关闭整个进程，我们则需设置默认关闭模式，当setDefaultCloseOperation()中参数为3即可。

  1. //设置窗口宽、高
  2.         this.setSize(603, 680);
  3.         //设置窗口标题
  4.         this.setTitle("拼图单机版");
  5.         //设置窗口置顶
  6.         this.setAlwaysOnTop(true);
  7.         //设置窗口置中
  8.         this.setLocationRelativeTo(null);
  9.         //设置窗口关闭模式
  10.                 /*
  11.         setDefaultCloseOperation()里的参数为0时，窗口不可关闭
  12.         为1时，则为默认关闭模式
  13.         为2时，则需关闭所有窗口才可完全关闭虚拟机
  14.         为3时，则只需关闭一个窗口即可完全关闭虚拟机
  15.         */
  16.         this.setDefaultCloseOperation(3);

          为搭建菜单，需通过创建JMenuBar和JMenu对象实现，通过其中的add()方法将需要的菜单选项添加到窗口中即可。

  1.         //创建整个菜单对象
  2.         JMenuBar jmb = new JMenuBar();
  3.  
  4.         //创建菜单下三个选项对象
  5.         JMenu functionjm = new JMenu("菜单");
  6.         JMenu aboutjm = new JMenu("关于我");
  7.  
  8.         JMenu changeimage = new JMenu("更换图片");

二、添加和打乱图片

        拼图游戏自然要有图片以供我们拼接，为此我们需准备好相应的图片资源，并复制粘贴至项目所在的文件夹中，通过创建JLabel对象和ImageIcon对象来管理图片，通过其中的成员方法setBounds()来设置图片大小以及setBorder()方法来设置图片格式，方法中参数为0时表示让图片凸出来，参数为1则表示让图片凹进去，为美观，我们选择将参数设为1，然后通过getContentpane()方法来添加进去。

  1. //创建一个JLabel管理容器
  2.                 JLabel jl = new JLabel(new ImageIcon(path+temppath+temp+"\\"+count+".jpg"));
  3.                 //设置图片位置以及大小
  4.                 jl.setBounds(105*j+83,105*i+134,105,105);
  5.                 //给图片设置边框
  6.                 //参数为0时表示让图片凸出来
  7.                 //参数为1时表示让图片凹进去
  8.                 jl.setBorder(new BevelBorder(1));
  9.                 this.getContentPane().add(jl);

        在添加完图片后，为打乱图片，我们可以将图片分为16份，15份索引和一份空白图片，所以我们只需创建一个如下的4行4列的二维数组，将随机打乱后的位置索引存储进去，在添加图片时按照打乱后的索引进行添加即可。

111154
31059
8267
0121413

  1.     //存储打乱后的索引
  2.     private int[][] data = new int[4][4];
  3.     int[] arr = {0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15};
  4.     //数组随机索引
  5.     int temp = 0;
  6.     Random r = new Random();
  7.     //打乱数组元素
  8.     for (int i = 0; i < arr.length; i++) {
  9.         int index = r.nextInt(arr.length);
  10.         temp = arr[i];
  11.         arr[i] = arr[index];
  12.         arr[index] = temp;
  13.     }
  14.   	//给二位数组添加打乱后的元素
  15.     for (int i = 0; i < arr.length; i++) {
  16.         //若当前元素为空白元素，则令x和y为当前元素的位置
  17.         if (arr[i] == 0){
  18.             x = i / 4;
  19.             y = i % 4;
  20.         }
  21.         data[i / 4][i % 4] = arr[i];
  22.     }

三、添加事件和美化图片

        在我们玩游戏时，需要对图片进行操作，这时候就需要用到监听这个接口了，比如在编写图片移动功能时，我们就要对键盘进行监听，当我们按到w键或者上箭头时，空白格子下方的图片就会向上移动一格，所以我们要实现KeyListener接口，并重写keyRelease()方法即可。

  1. if (code == 37 || code == 65){
  2.            System.out.println("向左移动");
  3.            //实现空白图片右方的图片向左移动
  4.            if (y == 3){
  5.                return;
  6.            }
  7.            data[x][y] = data[x][y+1];
  8.            data[x][y+1] = 0;
  9.            y++;
  10.            step++;
  11.            //调用方法按照最新的数字加载图片
  12.            initimage();
  13.        }

        为美化图片，使玩家获得更好游戏体验，只需为图片添加一个背景即可。

  1.         //添加背景图片
  2.         JLabel jb = new JLabel(new ImageIcon("image\\background.png"));
  3.         jb.setBounds(40,40,508,560);
  4.         this.getContentPane().add(jb);

四、计步和菜单业务实现

        为了实现计步功能，只需定义一个成员变量来储存步数，当移动一次时，步数加一，当选择重新开始游戏或者更换图片时，步数清零即可。而菜单业务则与上文的移动功能类似，也需实现监听接口，当鼠标点击该功能按钮时，就要进行相应的操作。

  1. Object obj = e.getSource();
  2.         if (obj == restartjmi){
  3.             System.out.println("重新游戏");
  4.             //计步器清零
  5.             step = 0;
  6.             //初始化数据
  7.             initdata();
  8.             //初始化图片
  9.             initimage();
  10.         }
  11.         else if(obj == closejmi){
  12.             System.out.println("关闭游戏");
  13.             //关闭虚拟机
  14.             System.exit(0);
  15.         }else if(obj == accountjmi){
  16.             System.out.println("名片");
  17.  
  18.             JDialog jdi = new JDialog();
  19.             JLabel jb = new JLabel(new ImageIcon("image\\mingpian.jpg"));
  20.             //设置位置
  21.             jb.setBounds(0,0,300,299);
  22.             jdi.getContentPane().add(jb);
  23.             //设置弹框大小
  24.             jdi.setSize(344,344);
  25.             //设置弹框置顶
  26.             jdi.setAlwaysOnTop(true);
  27.             //设置弹框居中
  28.             jdi.setLocationRelativeTo(null);
  29.             //设置弹框不关闭无法继续
  30.             jdi.setModal(true);
  31.             //设置弹框可视化
  32.             jdi.setVisible(true);
  33.         }else if (obj == girl) {
  34.             System.out.println("更换美女图片");
  35.             //计步器清零
  36.             step = 0;
  37.             //初始化数据
  38.             initdata();
  39.             //随机图片库
  40.             temppath = "\\girl\\girl";
  41.             changei();
  42.         }else if (obj == animal) {
  43.             System.out.println("更换动物图片");
  44.             //计步器清零
  45.             step = 0;
  46.             //初始化数据
  47.             initdata();
  48.             //随机图片库
  49.             temppath = "\\animal\\animal";
  50.             changei();
  51.         }else if (obj == sport) {
  52.             System.out.println("更换运动图片");
  53.             //计步器清零
  54.             step = 0;
  55.             //初始化数据
  56.             initdata();
  57.             //随机图片库
  58.             temppath = "\\sport\\sport";
  59.             changei();
  60.         }

五、最终代码实现以及结果展示

 完整代码：

  1. import javax.swing.*;
  2. import javax.swing.border.BevelBorder;
  3. import java.awt.event.ActionEvent;
  4. import java.awt.event.ActionListener;
  5. import java.awt.event.KeyEvent;
  6. import java.awt.event.KeyListener;
  7. import java.util.Random;
  8.  
  9. public class GameJFrame extends JFrame implements KeyListener, ActionListener {
  10.     //存储打乱后的索引
  11.     private int[][] data = new int[4][4];
  12.     //创建选项下的条目对象
  13.     JMenuItem restartjmi = new JMenuItem("重新开始");
  14.     //JMenuItem relogjmi = new JMenuItem("重新登录");
  15.     JMenuItem closejmi = new JMenuItem("关闭游戏");
  16.     JMenuItem girl = new JMenuItem("美女");
  17.     JMenuItem animal = new JMenuItem("动物");
  18.     JMenuItem sport = new JMenuItem("运动");
  19.     JMenuItem accountjmi = new JMenuItem("名片");
  20.     //记录空白图片在二维数组中的位置
  21.     private int x = 0;
  22.     private int y = 0;
  23.     //定义路径
  24.     String path = "image";
  25.     String temppath = "\\girl\\girl";
  26.  
  27.     int temp = 1;
  28.  
  29.     //String path = "image";
  30.     //定义一个胜利数组
  31.     private int[][] win = new int[][]{
  32.             {1,2,3,4},
  33.             {5,6,7,8},
  34.             {9,10,11,12},
  35.             {13,14,15,0}
  36.     };
  37.     //定义变量来统计步数
  38.     private int step = 0;
  39.  
  40.     //判断data数组中的值是否跟win数组中的值完全相同
  41.     //相同则胜利，返回true。不同则继续，返回false
  42.     public boolean victory(){
  43.         //判断data数组元素与win数组元素是否全部相同
  44.         for (int i = 0; i < data.length; i++) {
  45.             for (int j = 0; j < data[i].length; j++) {
  46.                 if (data[i][j] != win[i][j]){
  47.                     return false;
  48.                 }
  49.             }
  50.         }
  51.         //遍历结束，全部相同返回true
  52.         return true;
  53.     }
  54.  
  55.     public GameJFrame() {
  56.         //初始化窗口
  57.         initjf();
  58.  
  59.         //初始化菜单
  60.         initjmbar();
  61.  
  62.         //初始化数据
  63.         initdata();
  64.  
  65.         //初始化图片
  66.         initimage();
  67.  
  68.  
  69.  
  70.  
  71.  
  72.  
  73.  
  74.         //设置窗口可视化
  75.         this.setVisible(true);
  76.     }
  77.  
  78.     private void initdata() {
  79.         int[] arr = {0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15};
  80.         //数组随机索引
  81.         int temp = 0;
  82.         Random r = new Random();
  83.         //打乱数组元素
  84.         for (int i = 0; i < arr.length; i++) {
  85.             int index = r.nextInt(arr.length);
  86.             temp = arr[i];
  87.             arr[i] = arr[index];
  88.             arr[index] = temp;
  89.         }
  90.         //给二维数组添加打乱后的索引
  91. //        int index = 0;
  92. //        for (int i = 0; i < 4; i++) {
  93. //            for (int j = 0; j < 4; j++) {
  94. //                data[i][j] = arr[index];
  95. //                index++;
  96. //            }
  97. //        }
  98.         //给二位数组添加打乱后的元素
  99.         for (int i = 0; i < arr.length; i++) {
  100.             //若当前元素为空白元素，则令x和y为当前元素的位置
  101.             if (arr[i] == 0){
  102.                 x = i / 4;
  103.                 y = i % 4;
  104.             }
  105.             data[i / 4][i % 4] = arr[i];
  106.         }
  107.     }
  108.  
  109.     private void initimage(){
  110.         //删除所有图片
  111.         this.getContentPane().removeAll();
  112.  
  113.         //调用victory方法判断是否胜利
  114.         if (victory()) {
  115.             JLabel win = new JLabel(new ImageIcon("image\\win.png"));
  116.             //JLabel win = new JLabel(new ImageIcon("image\\win.png"));
  117.             win.setBounds(203,283,197,73);
  118.             this.getContentPane().add(win);
  119.         }
  120.  
  121.         JLabel jbstep = new JLabel("步数: "+step);
  122.         jbstep.setBounds(50,30,100,20);
  123.         this.getContentPane().add(jbstep);
  124.  
  125.  
  126.  
  127.         for (int i = 0; i < data.length; i++) {
  128.             for (int j = 0; j < data[i].length; j++) {
  129.                 int count = data[i][j];
  130.                 //创建一个JLabel管理容器
  131.                 JLabel jl = new JLabel(new ImageIcon(path+temppath+temp+"\\"+count+".jpg"));
  132.                 //设置图片位置以及大小
  133.                 jl.setBounds(105*j+83,105*i+134,105,105);
  134.                 //给图片设置边框
  135.                 //参数为0时表示让图片凸出来
  136.                 //参数为1时表示让图片凹进去
  137.                 jl.setBorder(new BevelBorder(1));
  138.                 this.getContentPane().add(jl);
  139.             }
  140.         }
  141.  
  142.         //添加背景图片
  143.         JLabel jb = new JLabel(new ImageIcon("image\\background.png"));
  144.         jb.setBounds(40,40,508,560);
  145.         this.getContentPane().add(jb);
  146.  
  147.         //刷新加载图片
  148.         this.getContentPane().repaint();
  149.     }
  150.  
  151.     private void changei(){
  152.  
  153.         Random r = new Random();
  154.  
  155.         if ((path+temppath).equals("image\\girl\\girl")){
  156.             temp = r.nextInt(13)+1;
  157.             initimage();
  158.         }else if((path+temppath).equals("image\\animal\\animal")){
  159.             temp = r.nextInt(8)+1;
  160.             initimage();
  161.         }else if((path+temppath).equals("image\\sport\\sport")){
  162.             temp = r.nextInt(10)+1;
  163.             initimage();
  164.         }
  165.  
  166.     }
  167.  
  168.     private void initjmbar() {
  169.  
  170.         //创建整个菜单对象
  171.         JMenuBar jmb = new JMenuBar();
  172.  
  173.         //创建菜单下三个选项对象
  174.         JMenu functionjm = new JMenu("菜单");
  175.         JMenu aboutjm = new JMenu("关于我");
  176.  
  177.         JMenu changeimage = new JMenu("更换图片");
  178.  
  179.         //添加条目对象到选项对象中
  180.         functionjm.add(changeimage);
  181.         functionjm.add(restartjmi);
  182.         //functionjm.add(relogjmi);
  183.         functionjm.add(closejmi);
  184.         aboutjm.add(accountjmi);
  185.  
  186.         changeimage.add(girl);
  187.         changeimage.add(animal);
  188.         changeimage.add(sport);
  189.  
  190.         //给条目绑定事件
  191.         restartjmi.addActionListener(this);
  192.         //relogjmi.addActionListener(this);
  193.         closejmi.addActionListener(this);
  194.         accountjmi.addActionListener(this);
  195.         girl.addActionListener(this);
  196.         animal.addActionListener(this);
  197.         sport.addActionListener(this);
  198.  
  199.         //将选项对象添加到菜单对象中
  200.         jmb.add(functionjm);
  201.         jmb.add(aboutjm);
  202.  
  203.         //给整个界面设置菜单
  204.         this.setJMenuBar(jmb);
  205.     }
  206.  
  207.     private void initjf(){
  208.         //设置窗口宽、高
  209.         this.setSize(603, 680);
  210.  
  211.         //设置窗口标题
  212.         this.setTitle("拼图单机版");
  213.  
  214.         //设置窗口置顶
  215.         this.setAlwaysOnTop(true);
  216.  
  217.         //设置窗口置中
  218.         this.setLocationRelativeTo(null);
  219.  
  220.         //设置窗口关闭模式
  221.                 /*
  222.         setDefaultCloseOperation()里的参数为0时，窗口不可关闭
  223.         为1时，则为默认关闭模式
  224.         为2时，则需关闭所有窗口才可完全关闭虚拟机
  225.         为3时，则只需关闭一个窗口即可完全关闭虚拟机
  226.         */
  227.         this.setDefaultCloseOperation(3);
  228.  
  229.         //添加键盘监听指针
  230.         this.addKeyListener(this);
  231.  
  232.         //只有取消居中，才可以将图片放到指定位置
  233.         this.setLayout(null);
  234.     }
  235.  
  236.     @Override
  237.     public void keyTyped(KeyEvent e) {
  238.  
  239.     }
  240.  
  241.     //按下A键不松开时会调用此方法实现图片还原功能
  242.     @Override
  243.     public void keyPressed(KeyEvent e) {
  244.         int code = e.getKeyCode();
  245.         if (code == 73){
  246.             //将界面中的图片全部删除
  247.             this.getContentPane().removeAll();
  248.             //加载一张完整图片
  249.             JLabel jb = new JLabel(new ImageIcon(path+temppath+temp+"\\"+"all.jpg"));
  250.             jb.setBounds(83,134,420,420);
  251.             this.getContentPane().add(jb);
  252.             //加载背景图片
  253.             JLabel jb1 = new JLabel(new ImageIcon("image\\background.png"));
  254.             jb1.setBounds(40,40,508,560);
  255.             this.getContentPane().add(jb1);
  256.             //刷新界面
  257.             this.getContentPane().repaint();
  258.         }
  259.     }
  260.  
  261.     @Override
  262.     public void keyReleased(KeyEvent e) {
  263.        int code = e.getKeyCode();
  264.        //判断游戏是否胜利，胜利则直接结束，不用执行下面的代码
  265.         if (victory()) {
  266.             return;
  267.         }
  268.        if (code == 37 || code == 65){
  269.            System.out.println("向左移动");
  270.            //实现空白图片右方的图片向左移动
  271.            if (y == 3){
  272.                return;
  273.            }
  274.            data[x][y] = data[x][y+1];
  275.            data[x][y+1] = 0;
  276.            y++;
  277.            step++;
  278.            //调用方法按照最新的数字加载图片
  279.            initimage();
  280.        }else if(code == 38 || code == 87){
  281.            System.out.println("向上移动");
  282.            //实现空白图片下方的图片向上移动
  283.            if (x == 3){
  284.                return;
  285.            }
  286.            data[x][y] = data[x+1][y];
  287.            data[x+1][y] = 0;
  288.            x++;
  289.            step++;
  290.            //调用方法按照最新的数字加载图片
  291.            initimage();
  292.        }else if(code == 39 || code == 68)
  293.        {
  294.            System.out.println("向右移动");
  295.            //实现空白图片左方的图片向右移动
  296.            if (y == 0){
  297.                return;
  298.            }
  299.            data[x][y] = data[x][y-1];
  300.            data[x][y-1] = 0;
  301.            y--;
  302.            step++;
  303.            //调用方法按照最新的数字加载图片
  304.            initimage();
  305.        }else if(code == 40 || code == 83){
  306.            System.out.println("向下移动");
  307.            //实现空白图片上方的图片向下移动
  308.            if (x == 0){
  309.                return;
  310.            }
  311.            data[x][y] = data[x-1][y];
  312.            data[x-1][y] = 0;
  313.            x--;
  314.            step++;
  315.            //调用方法按照最新的数字加载图片
  316.            initimage();
  317.        }else if(code == 73){
  318.            //当松开I键时，初始化界面
  319.            initimage();
  320.        }else if(code == 66){
  321.            //当按下键为B时，作弊
  322.            data = new int[][]{
  323.                    {1,2,3,4},
  324.                    {5,6,7,8},
  325.                    {9,10,11,12},
  326.                    {13,14,15,0}
  327.            };
  328.            initimage();
  329.        }
  330.     }
  331.  
  332.     @Override
  333.     public void actionPerformed(ActionEvent e) {
  334.         Object obj = e.getSource();
  335.         if (obj == restartjmi){
  336.             System.out.println("重新游戏");
  337.             //计步器清零
  338.             step = 0;
  339.             //初始化数据
  340.             initdata();
  341.             //初始化图片
  342.             initimage();
  343.         }
  344. //        else if(obj == relogjmi){
  345. //            System.out.println("重新登录");
  346. //            //关闭当前游戏界面
  347. //            this.setVisible(false);
  348. //            //打开登陆界面
  349. //            new LoginJFrame();
  350. //        }
  351.         else if(obj == closejmi){
  352.             System.out.println("关闭游戏");
  353.             //关闭虚拟机
  354.             System.exit(0);
  355.         }else if(obj == accountjmi){
  356.             System.out.println("名片");
  357.  
  358.             JDialog jdi = new JDialog();
  359.             JLabel jb = new JLabel(new ImageIcon("image\\mingpian.jpg"));
  360.             //设置位置
  361.             jb.setBounds(0,0,300,299);
  362.             jdi.getContentPane().add(jb);
  363.             //设置弹框大小
  364.             jdi.setSize(344,344);
  365.             //设置弹框置顶
  366.             jdi.setAlwaysOnTop(true);
  367.             //设置弹框居中
  368.             jdi.setLocationRelativeTo(null);
  369.             //设置弹框不关闭无法继续
  370.             jdi.setModal(true);
  371.             //设置弹框可视化
  372.             jdi.setVisible(true);
  373.         }else if (obj == girl) {
  374.             System.out.println("更换美女图片");
  375.             //计步器清零
  376.             step = 0;
  377.             //初始化数据
  378.             initdata();
  379.             //随机图片库
  380.             temppath = "\\girl\\girl";
  381.             changei();
  382.         }else if (obj == animal) {
  383.             System.out.println("更换动物图片");
  384.             //计步器清零
  385.             step = 0;
  386.             //初始化数据
  387.             initdata();
  388.             //随机图片库
  389.             temppath = "\\animal\\animal";
  390.             changei();
  391.         }else if (obj == sport) {
  392.             System.out.println("更换运动图片");
  393.             //计步器清零
  394.             step = 0;
  395.             //初始化数据
  396.             initdata();
  397.             //随机图片库
  398.             temppath = "\\sport\\sport";
  399.             changei();
  400.         }
  401.     }
  402. }

成品展示：

 

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/你好赵伟/article/detail/584409
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号