AI 助理
备案控制台
开发者社区 数据库 文章 正文

Java+Swing实现五子棋游戏（上）

2022-05-26 248
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
简介： Java+Swing实现五子棋游戏

一、系统介绍

1.开发环境


开发工具：Eclipse2021

JDK版本：jdk1.8

Mysql版本：8.0.13


2.技术选型


Java+Swing


3.系统功能


实现五子棋游戏，开始游戏，悔棋，认输，退出功能。


二、系统展示

1.首页


896043dcf8504c338421881c3dab0db6.jpg


2.黑棋走

98e857f1b30946e18c1f20fe42b83a80.jpg


3.白棋走


a072204df2794df4adecfa6dce01663b.jpg


三、部分代码

AI.java

package com.sjsq;
import java.util.HashMap;
public class AI implements Gobang {
  static HashMap<String, Integer> map = new HashMap<String, Integer>();
  static {
    /**
     * 权值
     */
    // 防守权值
    // 活1连
    map.put("010", 20);  //map.put(key,value) key=键 value=值
    map.put("0-10", 10);
    // 眠1连
    map.put("-110", 1);
    map.put("1-10", 1);
    // 活2连
    map.put("0110", 200);
    map.put("0-1-10", 100);
    // 眠2连
    map.put("-1110", 20);
    map.put("1-1-10", 10);
    // 活3连
    map.put("01110", 7000);
    map.put("0-1-1-10", 5000);
    // 眠3连
    map.put("-11110", 50);
    map.put("1-1-1-10", 30);
    // 活4连
    map.put("011110", 10000);
    map.put("0-1-1-1-10", 10000);
    // 眠4连
    map.put("-111110", 10000);
    map.put("1-1-1-1-10", 10000);
    // 碰壁眠4连
    map.put("11110", 10000);
    map.put("-1-1-1-10", 10000);
     //进攻权值
     //活1连
     map.put("010",10);
     map.put("0-10",20);
     //眠1连
     map.put("-110",1);
     map.put("1-10",1);
     //活2连
     map.put("0110", 100);
     map.put("0-1-10",200);
     //眠2连
     map.put("-1110",10);
     map.put("1-1-10",20);
     //活3连
     map.put("01110", 5000);
     map.put("0-1-1-10",7000);
     //眠3连
     map.put("-11110",30);
     map.put("1-1-1-10",50);
     //活4连
     map.put("011110", 10000);
     map.put("0-1-1-1-10",10000);
     //眠4连
     map.put("-111110",10000);
     map.put("1-1-1-1-10",10000);
     //碰壁眠4连
     map.put("11110", 10000);
     map.put("-1-1-1-10", 15000);
  }
  static String code;
  static Integer weight;
  public static void Quan() {
    for (int r = 0; r < array1.length; r++) {
      for (int c = 0; c < array1[r].length; c++) {
        if (array1[r][c] == 0) {// 如果该位置没有棋子则开始统计
          code = countHL(r, c);// 调用水平向左统计的方法
          weight = map.get(code);// 根据棋子相连情况获取对应的权值
          if (weight != null) {// 判断是否有该种棋子相连的情况
            weightArray[r][c] += weight;// 累加权值
          }
          // 把另外七个方向统计完毕后，就完成权值统计
          code = countHR(r, c);// 调用水平向右统计的方法
          weight = map.get(code);// 根据棋子相连情况获取对应的权值
          if (weight != null) {// 判断是否有该种棋子相连的情况
            weightArray[r][c] += weight;// 累加权值
          }
          code = countHT(r, c);// 调用水平向左统计的方法
          weight = map.get(code);// 根据棋子相连情况获取对应的权值
          if (weight != null) {// 判断是否有该种棋子相连的情况
            weightArray[r][c] += weight;// 累加权值
          }
          code = countHB(r, c);// 调用水平向左统计的方法
          weight = map.get(code);// 根据棋子相连情况获取对应的权值
          if (weight != null) {// 判断是否有该种棋子相连的情况
            weightArray[r][c] += weight;// 累加权值
          }
          code = countHZXS(r, c);// 调用水平向左统计的方法
          weight = map.get(code);// 根据棋子相连情况获取对应的权值
          if (weight != null) {// 判断是否有该种棋子相连的情况
            weightArray[r][c] += weight;// 累加权值
          }
          code = countHYXS(r, c);// 调用水平向左统计的方法
          weight = map.get(code);// 根据棋子相连情况获取对应的权值
          if (weight != null) {// 判断是否有该种棋子相连的情况
            weightArray[r][c] += weight;// 累加权值
          }
          code = countHZXX(r, c);// 调用水平向左统计的方法
          weight = map.get(code);// 根据棋子相连情况获取对应的权值
          if (weight != null) {// 判断是否有该种棋子相连的情况
            weightArray[r][c] += weight;// 累加权值
          }
          code = countHYXX(r, c);// 调用水平向左统计的方法
          weight = map.get(code);// 根据棋子相连情况获取对应的权值
          if (weight != null) {// 判断是否有该种棋子相连的情况
            weightArray[r][c] += weight;// 累加权值
          }
// 针对每种情况都进行权值分析，保证五子棋规则的完善
          // 判断两个2连在一条直线但中间有一个空位的情况
          if ((countHL(r, c) + countHR(r, c) == "01100110")
              || (countHL(r, c) + countHR(r, c) == "0-1-100-1-10")
              || (countHL(r, c) + countHR(r, c) == "-11100110")
              || (countHL(r, c) + countHR(r, c) == "1-1-100-1-10")
              || (countHL(r, c) + countHR(r, c) == "0110-1110")
              || (countHL(r, c) + countHR(r, c) == "0-1-101-1-10")
              || (countHL(r, c) + countHR(r, c) == "-1110-1110")
              || (countHL(r, c) + countHR(r, c) == "1-1-101-1-10")) {
            weightArray[r][c] = weightArray[r][c] + 5000;  
          }
          if ((countHT(r, c) + countHB(r, c) == "01100110")
              || (countHT(r, c) + countHB(r, c) == "0-1-100-1-10")
              || (countHT(r, c) + countHB(r, c) == "-11100110")
              || (countHT(r, c) + countHB(r, c) == "1-1-100-1-10")
              || (countHT(r, c) + countHB(r, c) == "0110-1110")
              || (countHT(r, c) + countHB(r, c) == "0-1-101-1-10")
              || (countHT(r, c) + countHB(r, c) == "-1110-1110")
              || (countHT(r, c) + countHB(r, c) == "1-1-101-1-10")) {
            weightArray[r][c] = weightArray[r][c] + 5000;
          }
          if ((countHZXS(r, c) + countHYXX(r, c) == "01100110")
              || (countHZXS(r, c) + countHYXX(r, c) == "0-1-100-1-10")
              || (countHZXS(r, c) + countHYXX(r, c) == "-11100110")
              || (countHZXS(r, c) + countHYXX(r, c) == "1-1-100-1-10")
              || (countHZXS(r, c) + countHYXX(r, c) == "0110-1110")
              || (countHZXS(r, c) + countHYXX(r, c) == "0-1-101-1-10")
              || (countHZXS(r, c) + countHYXX(r, c) == "-1110-1110")
              || (countHZXS(r, c) + countHYXX(r, c) == "1-1-101-1-10")) {
            weightArray[r][c] = weightArray[r][c] + 5000;
          }
          if ((countHYXS(r, c) + countHZXX(r, c) == "01100110")
              || (countHYXS(r, c) + countHZXX(r, c) == "0-1-100-1-10")
              || (countHYXS(r, c) + countHZXX(r, c) == "-11100110")
              || (countHYXS(r, c) + countHZXX(r, c) == "1-1-100-1-10")
              || (countHYXS(r, c) + countHZXX(r, c) == "0110-1110")
              || (countHYXS(r, c) + countHZXX(r, c) == "0-1-101-1-10")
              || (countHYXS(r, c) + countHZXX(r, c) == "-1110-1110")
              || (countHYXS(r, c) + countHZXX(r, c) == "1-1-101-1-10")) {
            weightArray[r][c] = weightArray[r][c] + 5000;
          }
          // 判断一个活2连和一个活1连在一条直线上但中间有一个空位的情况
          if ((countHL(r, c) + countHR(r, c) == "0100110") || (countHL(r, c) + countHR(r, c) == "0-100-1-10")
              || (countHL(r, c) + countHR(r, c) == "0110010")
              || (countHL(r, c) + countHR(r, c) == "0-1-100-10")) {
            weightArray[r][c] = weightArray[r][c] + 3000;
          }
          if ((countHT(r, c) + countHB(r, c) == "0100110") || (countHT(r, c) + countHB(r, c) == "0-100-1-10")
              || (countHT(r, c) + countHB(r, c) == "0110010")
              || (countHT(r, c) + countHB(r, c) == "0-1-100-10")) {
            weightArray[r][c] = weightArray[r][c] + 3000;
          }
          if ((countHZXS(r, c) + countHYXX(r, c) == "0100110")
              || (countHZXS(r, c) + countHYXX(r, c) == "0-100-1-10")
              || (countHZXS(r, c) + countHYXX(r, c) == "0110010")
              || (countHZXS(r, c) + countHYXX(r, c) == "0-1-100-10")) {
            weightArray[r][c] = weightArray[r][c] + 3000;
          }
          if ((countHYXS(r, c) + countHZXX(r, c) == "0100110")
              || (countHYXS(r, c) + countHZXX(r, c) == "0-100-1-10")
              || (countHYXS(r, c) + countHZXX(r, c) == "0110010")
              || (countHYXS(r, c) + countHZXX(r, c) == "0-1-100-10")) {
            weightArray[r][c] = weightArray[r][c] + 3000;
          }
          // 眠3连的一端被堵了
          // "1-1-1-10"&"010" "0-1-1-10"&"010"
          if ((countHL(r, c) + countHR(r, c) == "1-1-1-10010")
              || (countHL(r, c) + countHR(r, c) == "0101-1-1-10")
              || (countHL(r, c) + countHR(r, c) == "1-1-1-100")
              || (countHL(r, c) + countHR(r, c) == "01-1-1-10")
              || (countHL(r, c) + countHR(r, c) == "1-1-1-100110")
              || (countHL(r, c) + countHR(r, c) == "01101-1-1-10")) {
            weightArray[r][c] = 1;
          }
          if ((countHT(r, c) + countHB(r, c) == "1-1-1-10010")
              || (countHT(r, c) + countHB(r, c) == "0101-1-1-10")
              || (countHT(r, c) + countHB(r, c) == "1-1-1-100")
              || (countHT(r, c) + countHB(r, c) == "01-1-1-10")
              || (countHT(r, c) + countHB(r, c) == "1-1-1-100110")
              || (countHT(r, c) + countHB(r, c) == "01101-1-1-10")) {
            weightArray[r][c] = 1;
            ;
          }
          if ((countHZXS(r, c) + countHYXX(r, c) == "1-1-1-10010")
              || (countHZXS(r, c) + countHYXX(r, c) == "0101-1-1-10")
              || (countHZXS(r, c) + countHYXX(r, c) == "1-1-1-100")
              || (countHZXS(r, c) + countHYXX(r, c) == "01-1-1-10")
              || (countHZXS(r, c) + countHYXX(r, c) == "1-1-1-100110")
              || (countHZXS(r, c) + countHYXX(r, c) == "01101-1-1-10")) {
            weightArray[r][c] = 1;
          }
          if ((countHYXS(r, c) + countHZXX(r, c) == "1-1-1-10010")
              || (countHYXS(r, c) + countHZXX(r, c) == "0101-1-1-10")
              || (countHYXS(r, c) + countHZXX(r, c) == "1-1-1-100")
              || (countHYXS(r, c) + countHZXX(r, c) == "01-1-1-10")
              || (countHYXS(r, c) + countHZXX(r, c) == "1-1-1-100110")
              || (countHYXS(r, c) + countHZXX(r, c) == "01101-1-1-10")) {
            weightArray[r][c] = 1;
          }
          // 3连和1连在一条线上差一个棋位
          if ((countHL(r, c) + countHR(r, c) == "0-1-1-100-10")
              || (countHL(r, c) + countHR(r, c) == "0-101-1-1-10")
              || (countHL(r, c) + countHR(r, c) == "01110010")
              || (countHL(r, c) + countHR(r, c) == "010-11110")
              || (countHL(r, c) + countHR(r, c) == "0-100-1-1-10")
              || (countHL(r, c) + countHR(r, c) == "1-1-1-100-10")
              || (countHL(r, c) + countHR(r, c) == "01001110")
              || (countHL(r, c) + countHR(r, c) == "-11110010")) {
            weightArray[r][c] = weightArray[r][c] + 4000;
          }
          if ((countHT(r, c) + countHB(r, c) == "0-1-1-100-10")
              || (countHT(r, c) + countHB(r, c) == "0-101-1-1-10")
              || (countHT(r, c) + countHB(r, c) == "01110010")
              || (countHT(r, c) + countHB(r, c) == "010-11110")
              || (countHT(r, c) + countHB(r, c) == "0-100-1-1-10")
              || (countHT(r, c) + countHB(r, c) == "1-1-1-100-10")
              || (countHT(r, c) + countHB(r, c) == "01001110")
              || (countHT(r, c) + countHB(r, c) == "-11110010")) {
            weightArray[r][c] = weightArray[r][c] + 4000;
          }
          if ((countHZXS(r, c) + countHYXX(r, c) == "0-1-1-100-10")
              || (countHZXS(r, c) + countHYXX(r, c) == "0-101-1-1-10")
              || (countHZXS(r, c) + countHYXX(r, c) == "01110010")
              || (countHZXS(r, c) + countHYXX(r, c) == "010-11110")
              || (countHZXS(r, c) + countHYXX(r, c) == "0-100-1-1-10")
              || (countHZXS(r, c) + countHYXX(r, c) == "1-1-1-100-10")
              || (countHZXS(r, c) + countHYXX(r, c) == "01001110")
              || (countHZXS(r, c) + countHYXX(r, c) == "-11110010")) {
            weightArray[r][c] = weightArray[r][c] + 4000;
          }
          if ((countHYXS(r, c) + countHZXX(r, c) == "0-1-1-100-10")
              || (countHYXS(r, c) + countHZXX(r, c) == "0-101-1-1-10")
              || (countHYXS(r, c) + countHZXX(r, c) == "01110010")
              || (countHYXS(r, c) + countHZXX(r, c) == "010-11110")
              || (countHYXS(r, c) + countHZXX(r, c) == "0-100-1-1-10")
              || (countHYXS(r, c) + countHZXX(r, c) == "1-1-1-100-10")
              || (countHYXS(r, c) + countHZXX(r, c) == "01001110")
              || (countHYXS(r, c) + countHZXX(r, c) == "-11110010")) {
            weightArray[r][c] = weightArray[r][c] + 4000;
          }
        }
      }
    }
  }
  // 水平向左统计的方法
  public static String countHL(int r, int c) {
    String code = "0";
    int chess = 0;// 存储第一颗出现的棋子
    // 循环遍历
    for (int r1 = r - 1; r1 >= 0; r1--) {
      if (array1[r1][c] == 0) {// 表示空位沒有棋子
        if (r1 + 1 == r) {// 相邻
          break;
        } else {
          code = array1[r1][c] + code;// 记录棋子相连情况
          break;
        }
      } else {// 表示该位置有棋子
        if (chess == 0) {// 第一次出现棋子
          chess = array1[r1][c];// 记录棋子
          code = array1[r1][c] + code;// 记录棋子相连情况
        } else if (chess == array1[r1][c]) {
          code = array1[r1][c] + code;// 记录棋子相连情况
        } else {
          code = array1[r1][c] + code;// 记录棋子相连情况
          break;
        }
      }
    }
    return code;
  }
  // 水平向右统计的方法
  public static String countHR(int r, int c) {
    String code = "0";
    int chess = 0;// 存储第一颗出现的棋子
    // 循环遍历
    for (int r1 = r + 1; r1 < coloum; r1++) {
      if (array1[r1][c] == 0) {// 表示空位沒有棋子
        if (r1 - 1 == r) {// 相邻
          break;
        } else {
          code = array1[r1][c] + code;// 记录棋子相连情况
          break;
        }
      } else {// 表示该位置有棋子
        if (chess == 0) {// 第一次出现棋子
          chess = array1[r1][c];// 记录棋子
          code = array1[r1][c] + code;// 记录棋子相连情况
        } else if (chess == array1[r1][c]) {
          code = array1[r1][c] + code;// 记录棋子相连情况
        } else {
          code = array1[r1][c] + code;// 记录棋子相连情况
          break;
        }
      }
    }
    return code;
  }
  // 竖直向上统计的方法
  public static String countHT(int r, int c) {
    String code = "0";
    int chess = 0;// 存储第一颗出现的棋子
    // 循环遍历
    for (int c1 = c - 1; c1 >= 0; c1--) {
      if (array1[r][c1] == 0) {// 表示空位沒有棋子
        if (c1 + 1 == r) {// 相邻
          break;
        } else {
          code = array1[r][c1] + code;// 记录棋子相连情况
          break;
        }
      } else {// 表示该位置有棋子
        if (chess == 0) {// 第一次出现棋子
          chess = array1[r][c1];// 记录棋子
          code = array1[r][c1] + code;// 记录棋子相连情况
        } else if (chess == array1[r][c1]) {
          code = array1[r][c1] + code;// 记录棋子相连情况
        } else {
          code = array1[r][c1] + code;// 记录棋子相连情况
          break;
        }
      }
    }
    return code;
  }
  // 竖直向下统计的方法
  public static String countHB(int r, int c) {
    String code = "0";
    int chess = 0;// 存储第一颗出现的棋子
    // 循环遍历
    for (int c1 = c + 1; c1 < row; c1++) {
      if (array1[r][c1] == 0) {// 表示空位沒没有棋子
        if (c1 - 1 == c) {// 相邻
          break;
        } else {
          code = array1[r][c1] + code;// 记录棋子相连情况
          break;
        }
      } else {// 表示该位置有棋子
        if (chess == 0) {// 第一次出现棋子
          chess = array1[r][c1];// 记录棋子
          code = array1[r][c1] + code;// 记录棋子相连情况
        } else if (chess == array1[r][c1]) {
          code = array1[r][c1] + code;// 记录棋子相连情况
        } else {
          code = array1[r][c1] + code;// 记录棋子相连情况
          break;
        }
      }
    }
    return code;
  }
  // 左斜向上统计的方法
  public static String countHZXS(int r, int c) {
    String code = "0";
    int chess = 0;// 存储第一颗出现的棋子
    // 循环遍历
    for (int r1 = r - 1, c1 = c - 1; r1 >= 0 && c1 >= 0; r1--, c1--) {
      if (array1[r1][c1] == 0) {// 表示空位沒有棋子
        if (c1 + 1 == c && r1 + 1 == r) {// 相邻
          break;
        } else {
          code = array1[r1][c1] + code;// 记录棋子相连情况
          break;
        }
      } else {// 表示该位置有棋子
        if (chess == 0) {// 第一次出现棋子
          chess = array1[r1][c1];// 记录棋子
          code = array1[r1][c1] + code;// 记录棋子相连情况
        } else if (chess == array1[r1][c1]) {
          code = array1[r1][c1] + code;// 记录棋子相连情况
        } else {
          code = array1[r1][c1] + code;// 记录棋子相连情况
          break;
        }
      }
    }
    return code;
  }
  // 右斜向上统计的方法
  public static String countHYXS(int r, int c) {
    String code = "0";
    int chess = 0;// 存储第一颗出现的棋子
    // 循环遍历
    for (int r1 = r + 1, c1 = c - 1; c1 >= 0 && r1 < coloum; r1++, c1--) {
      if (array1[r1][c1] == 0) {// 表示空位沒有棋子
        if (r1 - 1 == r && c1 + 1 == c) {// 相邻
          break;
        } else {
          code = array1[r1][c1] + code;// 记录棋子相连情况
          break;
        }
      } else {// 表示该位置有棋子
        if (chess == 0) {// 第一次出现棋子
          chess = array1[r1][c1];// 记录棋子
          code = array1[r1][c1] + code;// 记录棋子相连情况
        } else if (chess == array1[r1][c1]) {
          code = array1[r1][c1] + code;// 记录棋子相连情况
        } else {
          code = array1[r1][c1] + code;// 记录棋子相连情况
          break;
        }
      }
    }
    return code;
  }
  // 左斜向下统计的方法
  public static String countHZXX(int r, int c) {
    String code = "0";
    int chess = 0;// 存储第一颗出现的棋子
    // 循环遍历
    for (int r1 = r - 1, c1 = c + 1; c1 < row && r1 >= 0; c1++, r1--) {
      if (array1[r1][c1] == 0) {// 表示空位沒有棋子
        if (c1 - 1 == c && r1 + 1 == r) {// 相邻
          break;
        } else {
          code = array1[r1][c1] + code;// 记录棋子相连情况
          break;
        }
      } else {// 表示该位置有棋子
        if (chess == 0) {// 第一次出现棋子
          chess = array1[r1][c1];// 记录棋子
          code = array1[r1][c1] + code;// 记录棋子相连情况
        } else if (chess == array1[r1][c1]) {
          code = array1[r1][c1] + code;// 记录棋子相连情况
        } else {
          code = array1[r1][c1] + code;// 记录棋子相连情况
          break;
        }
      }
    }
    return code;
  }
  // 右斜向下统计的方法
  public static String countHYXX(int r, int c) {
    String code = "0";
    int chess = 0;// 存储第一颗出现的棋子
    // 循环遍历
    for (int r1 = r + 1, c1 = c + 1; r1 < coloum && c1 < row; r1++, c1++) {
      if (array1[r1][c1] == 0) {// 表示空位沒有棋子
        if (c1 - 1 == c && r1 - 1 == r) {// 相邻
          break;
        } else {
          code = array1[r1][c1] + code;// 记录棋子相连情况
          break;
        }
      } else {// 表示该位置有棋子
        if (chess == 0) {// 第一次出现棋子
          chess = array1[r1][c1];// 记录棋子
          code = array1[r1][c1] + code;// 记录棋子相连情况
        } else if (chess == array1[r1][c1]) {
          code = array1[r1][c1] + code;// 记录棋子相连情况
        } else {
          code = array1[r1][c1] + code;// 记录棋子相连情况
          break;
        }
      }
    }
    return code;
  }
}


文章标签：
Java
开发工具
关系型数据库
MySQL
关键词：
Java游戏
Java swing
Java swing游戏
Java swing五子棋
Java实现
水坚石青
目录
相关文章
啦啦啦191
|
2月前
|
设计模式 人工智能 前端开发
现代 Java 实现数字华容道与石头迷阵游戏的项目实战及项目开发指南
本项目基于Java 17+，采用JavaFX与MVC架构，实战开发数字华容道/石头迷阵游戏。内容涵盖技术选型、核心逻辑、现代GUI设计、动画实现及项目打包发布，结合sealed class、record等新特性，打造简洁可维护的游戏代码结构。
啦啦啦191
98 0
青云交（Java大数据AI云原生Python）
|
3月前
|
机器学习/深度学习 存储 Java
Java 大视界 -- Java 大数据机器学习模型在游戏用户行为分析与游戏平衡优化中的应用（190）
本文探讨了Java大数据与机器学习模型在游戏用户行为分析及游戏平衡优化中的应用。通过数据采集、预处理与聚类分析，开发者可深入洞察玩家行为特征，构建个性化运营策略。同时，利用回归模型优化游戏数值与付费机制，提升游戏公平性与用户体验。
青云交（Java大数据AI云原生Python）
108 0
潜意识Java
|
9月前
|
Java
Java实现贪吃蛇游戏
本文介绍了如何使用Java实现一个简单的贪吃蛇游戏。
潜意识Java
326 4
潜意识Java
|
9月前
|
IDE Java API
Java游戏开发基础：从零开始制作一个简单的2D游戏
本文介绍了使用Java开发一个简单的2D避障游戏的基础流程。
潜意识Java
521 10
栈江湖
|
10月前
|
存储 IDE Java
漂亮不是梦！Java Swing美化攻略
Java Swing 是一个为 Java 设计的 GUI 工具包，提供文本框、按钮等组件。尽管其外观可定制，通过 Look and Feel（LAF）机制改变应用风格，如 Darcula 和 FlatLaf，但现已淡出主流视野，主要应用于 IDE 领域，如 IntelliJ IDEA 和 Eclipse。相比其他 GUI 框架，Swing 的发展前景有限。
栈江湖
336 1
nanshaws
|
12月前
|
开发框架 IDE Java
java制作游戏，如何使用libgdx，入门级别教学
本文是一篇入门级教程，介绍了如何使用libgdx游戏开发框架创建一个简单的游戏项目，包括访问libgdx官网、设置项目、下载项目生成工具，并在IDE中运行生成的项目。
nanshaws
461 1
java制作游戏，如何使用libgdx，入门级别教学
wljslmz
|
安全 Java API
“Java中哪种Swing API方法是线程安全的？
【8月更文挑战第23天】
wljslmz
189 2
项目花园范德彪
|
IDE 小程序 前端开发
详细解读java的俄罗斯方块游戏的源代码--【课程设计】
详细解读java的俄罗斯方块游戏的源代码--【课程设计】
项目花园范德彪
250 0
我不是大佬-
|
Java 定位技术 开发者
基于Java的俄罗斯方块游戏
基于Java的俄罗斯方块游戏
我不是大佬-
255 0
基于Java的俄罗斯方块游戏
科技小能手
|
Java
JAVA游戏编程之三----j2me 手机游戏入门开发--俄罗斯方块_5_使用LUA脚本写游戏
科技小能手
2184 0

热门文章

最新文章

  • 1
    阿里出手！Java 开发者狂喜！开源 AI Agent 框架 JManus 来了，初次见面就心动～
  • 2
    帮助新手快速上手的 JAVA 学习路线最详细版涵盖从入门到进阶的 JAVA 学习路线
  • 3
    Java并发编程：CountDownLatch实战解析
  • 4
    Java 转 AI 不用慌！3 周求职打卡表，帮你按天推进、高效拿 offer
  • 5
    2025 年最新 Java 实操学习路线，从入门到高级应用详细指南
  • 6
    从 Java 到 AI：三周求职冲刺打卡，步步为营拿 offer
  • 7
    最详细Java正则表达式详解
  • 8
    热门小程序源码合集：微信抖音小程序源码支持PHP/Java/uni-app完整项目实践指南
  • 9
    2025 年全新出炉的 Java 学习路线：从入门起步到实操精通的详细指南
  • 10
    终于可以解放双手了，使用Jenkins、ArgoCD 部署 Java 应用程序，最终部署在 Kubernetes 集群上
  • 1
    如何优化Java异步任务的性能？
    101
  • 2
    使用Java多态性进行数据类型转换
    48
  • 3
    从零学 Dropwizard：手把手搭轻量 Java 微服务，告别 Spring 臃肿
    57
  • 4
    2025 年 Java 从零基础小白到编程高手的详细学习路线攻略
    162
  • 5
    Java Stream API：现代集合处理与函数式编程
    171
  • 6
    Java Stream API：现代集合处理新方式
    166
  • 7
    Java记录类：简化数据载体的新选择
    162
  • 8
    Java Stream API：现代数据处理之道
    165
  • 9
    Java记录类：简化数据载体的新方式
    179
  • 10
    Java Record：简化数据载体的新选择
    146

    • 相关课程

    更多
  • Java面试疑难点解析 - 面试技巧及语言基础
  • Java面试疑难点解析 - Java Web开发
  • Java面试疑难点解析 - 系统架构及项目设计
  • Java编程入门
  • Java面向对象编程
  • Java高级编程

    • 相关电子书

    更多
  • Spring Cloud Alibaba - 重新定义 Java Cloud-Native
  • The Reactive Cloud Native Arch
  • JAVA开发手册1.5.0
    • 下一篇
    2025云栖大会，阿里云百炼邀请您的参与和见证