Java课程设计个人博客

最新推荐文章于 2023-06-13 21:52:26 发布
最新推荐文章于 2023-06-13 21:52:26 发布
阅读量125 收藏
点赞数
分类专栏： java 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_60899623/article/details/128621758
版权
本文介绍了使用JavaSwing和Socket实现的联机五子棋游戏，个人任务包括棋盘的多线程处理、五子棋算法实现以及部分图形用户界面（GUI）的设计。五子棋算法检查棋局中是否有五子连珠，棋盘多线程确保游戏的同步更新，GUI展示棋盘并处理用户交互。尽管游戏已具备基本功能，但仍有改进空间，如增加聊天室和计时器，目前仅支持局域网内联机，图形界面还有待美化。
摘要由CSDN通过智能技术生成

1.项目简介

本次课程设计我们以五子棋这一有趣、益智棋类游戏为题，使用 java swing、socket 实现了可联机的五子棋对战游戏。

团队博客：基于socket的联机五子棋_林仕峰的博客-CSDN博客

2.个人任务

棋盘多线程、五子棋算法、部分GUI的实现

3.功能详解

（1）棋子类定义

/**
 * 白棋
 **/

public class ChessWhite extends Canvas{

    /**
     * 白棋所在棋盘
     **/
    ChessBoard chessBoard;

    public ChessWhite (ChessBoard chessBoard) {
        this.chessBoard = chessBoard;
    }

    public void paint(Graphics g) {
        //画棋子
        g.setColor(Color.WHITE);
        g.fillOval(0,0,30,30);
    }
}
/**
 * 黑棋
 **/

public class ChessBlack extends Canvas {

    /**
     * 黑棋所在棋盘
     **/
    ChessBoard chessBoard;

    public ChessBlack (ChessBoard chessBoard) {
        this.chessBoard = chessBoard;
    }

    @Override
    public void paint(Graphics g){
        //画棋子
        g.setColor(Color.BLACK);
        g.fillOval(0,0,30,30);
    }
}

（2）五子棋算法实现

    /**
    * 五子棋核心算法
    * */
    public boolean checkVicStatus(int xPos, int yPos, int chessColor) {
        //连接的棋子数
        int chessLinkedCount;
        //用于比较是否要继续遍历一个棋子的相邻网格
        int chessLinkedCompare = 1;
        //要比较的棋子在数组中的索引位置
        int chessToCompareIndex;
        //相邻网格的位置
        int closeGrid;

        //当落子为黑棋时
        if(chessColor == 1) {
            //将该棋子自身算入的话，初始连接数为1
            chessLinkedCount = 1;
            //以下每对for循环语句为一组，因为下棋的位置能位于中间而非两端

            //遍历相邻4个网格
            //判断当前下的棋子的右边4个棋子是否都为黑棋
            for(closeGrid = 1; closeGrid <= 4; closeGrid++) {
                //遍历棋盘上所有黑棋子
                for(chessToCompareIndex = 0; chessToCompareIndex <= chessBlackCount; chessToCompareIndex++) {
                    if(((xPos + closeGrid) * dis == chessBlack_XPOS[chessToCompareIndex])
                            && ((yPos * dis) == chessBlack_YPOS[chessToCompareIndex])) {
                        //连接数加1
                        chessLinkedCount = chessLinkedCount + 1;
                        //五子相连时，胜利
                        if (chessLinkedCount == 5) {
                            return true;
                        }
                    }
                }
                if(chessLinkedCount == (chessLinkedCompare + 1)) {
                    chessLinkedCompare++;
                    //若中间有一个棋子非黑棋，则会进入此分支，此时无需再遍历
                } else {
                    break;
                }
            }
            // 判断当前下的棋子的左边4个棋子是否都为黑棋
            for (closeGrid = 1; closeGrid <= 4; closeGrid++) {
                for (chessToCompareIndex = 0; chessToCompareIndex <= chessBlackCount; chessToCompareIndex++) {
                    if (((xPos - closeGrid) * dis == chessBlack_XPOS[chessToCompareIndex])
                            && (yPos * dis == chessBlack_YPOS[chessToCompareIndex])) {
                        chessLinkedCount++;
                        if (chessLinkedCount == 5) {
                            return true;
                        }
                    }
                }
                if (chessLinkedCount == (chessLinkedCompare + 1)) {
                    chessLinkedCompare++;
                } else {
                    break;
                }
            }

            // 进入新的一组for循环时要将连接数等重置
            chessLinkedCount = 1;
            chessLinkedCompare = 1;
            // 判断当前下的棋子的上边4个棋子是否都为黑棋
            for (closeGrid = 1; closeGrid <= 4; closeGrid++) {
                for (chessToCompareIndex = 0; chessToCompareIndex <= chessBlackCount; chessToCompareIndex++) {
                    if ((xPos * dis == chessBlack_XPOS[chessToCompareIndex])
                            && ((yPos + closeGrid) * dis == chessBlack_YPOS[chessToCompareIndex])) {
                        chessLinkedCount++;
                        if (chessLinkedCount == 5) {
                            return true;
                        }
                    }
                }
                if (chessLinkedCount == (chessLinkedCompare + 1)) {
                    chessLinkedCompare++;
                } else {
                    break;
                }
            }

            // 判断当前下的棋子的下边4个棋子是否都为黑棋
            for (closeGrid = 1; closeGrid <= 4; closeGrid++) {
                for (chessToCompareIndex = 0; chessToCompareIndex <= chessBlackCount; chessToCompareIndex++) {
                    if ((xPos * dis == chessBlack_XPOS[chessToCompareIndex])
                            && ((yPos - closeGrid) * dis == chessBlack_YPOS[chessToCompareIndex])) {
                        chessLinkedCount++;
                        if (chessLinkedCount == 5) {
                            return true;
                        }
                    }
                }
                if (chessLinkedCount == (chessLinkedCompare + 1)) {
                    chessLinkedCompare++;
                } else {
                    break;
                }
            }

            chessLinkedCount = 1;
            chessLinkedCompare = 1;
            for (closeGrid = 1; closeGrid <= 4; closeGrid++) {
                for (chessToCompareIndex = 0; chessToCompareIndex <= chessBlackCount; chessToCompareIndex++) {
                    // 判断当前下的棋子的左上方向4个棋子是否都为黑棋
                    if (((xPos - closeGrid) * dis == chessBlack_XPOS[chessToCompareIndex])
                            && ((yPos + closeGrid) * dis == chessBlack_YPOS[chessToCompareIndex])) {
                        chessLinkedCount++;
                        if (chessLinkedCount == 5) {
                            return true;
                        }
                    }
                }
                if (chessLinkedCount == (chessLinkedCompare + 1)) {
                    chessLinkedCompare++;
                } else {
                    break;
                }
            }
            for (closeGrid = 1; closeGrid <= 4; closeGrid++) {
                for (chessToCompareIndex = 0; chessToCompareIndex <= chessBlackCount; chessToCompareIndex++) {
                    // 判断当前下的棋子的右下方向4个棋子是否都为黑棋
                    if (((xPos + closeGrid) * dis == chessBlack_XPOS[chessToCompareIndex])
                            && ((yPos - closeGrid) * dis == chessBlack_YPOS[chessToCompareIndex])) {
                        chessLinkedCount++;
                        if (chessLinkedCount == 5) {
                            return true;
                        }
                    }
                }
                if (chessLinkedCount == (chessLinkedCompare + 1)) {
                    chessLinkedCompare++;
                } else {
                    break;
                }
            }

            chessLinkedCount = 1;
            chessLinkedCompare = 1;
            // 判断当前下的棋子的右上方向4个棋子是否都为黑棋
            for (closeGrid = 1; closeGrid <= 4; closeGrid++) {
                for (chessToCompareIndex = 0; chessToCompareIndex <= chessBlackCount; chessToCompareIndex++) {
                    if (((xPos + closeGrid) * dis == chessBlack_XPOS[chessToCompareIndex])
                            && ((yPos + closeGrid) * dis == chessBlack_YPOS[chessToCompareIndex])) {
                        chessLinkedCount++;
                        if (chessLinkedCount == 5) {
                            return true;
                        }
                    }
                }
                if (chessLinkedCount == (chessLinkedCompare + 1)) {
                    chessLinkedCompare++;
                } else {
                    break;
                }
            }

            // 判断当前下的棋子的左下方向4个棋子是否都为黑棋
            for (closeGrid = 1; closeGrid <= 4; closeGrid++) {
                for (chessToCompareIndex = 0; chessToCompareIndex <= chessBlackCount; chessToCompareIndex++) {
                    if (((xPos - closeGrid) * dis == chessBlack_XPOS[chessToCompareIndex])
                            && ((yPos - closeGrid) * dis == chessBlack_YPOS[chessToCompareIndex])) {
                        chessLinkedCount++;
                        if (chessLinkedCount == 5) {
                            return true;
                        }
                    }
                }
                if (chessLinkedCount == (chessLinkedCompare + 1)) {
                    chessLinkedCompare++;
                } else {
                    break;
                }
            }

        //当落子为白棋时
        } else if (chessColor == -1) {
            chessLinkedCount = 1;
            // 判断当前下的棋子的右边4个棋子是否都为白棋
            for (closeGrid = 1; closeGrid <= 4; closeGrid++) {
                for (chessToCompareIndex = 0; chessToCompareIndex <= chessWhiteCount; chessToCompareIndex++) {
                    if (((xPos + closeGrid) * dis == chessWhite_XPOS[chessToCompareIndex])
                            && (yPos * dis == chessWhite_YPOS[chessToCompareIndex])) {
                        chessLinkedCount++;
                        if (chessLinkedCount == 5) {
                            return true;
                        }
                    }
                }
                if (chessLinkedCount == (chessLinkedCompare + 1)) {
                    chessLinkedCompare++;
                } else {
                    break;
                }
            }

            // 判断当前下的棋子的左边4个棋子是否都为白棋
            for (closeGrid = 1; closeGrid <= 4; closeGrid++) {
                for (chessToCompareIndex = 0; chessToCompareIndex <= chessWhiteCount; chessToCompareIndex++) {
                    if (((xPos - closeGrid) * dis == chessWhite_XPOS[chessToCompareIndex])
                            && (yPos * dis == chessWhite_YPOS[chessToCompareIndex])) {
                        chessLinkedCount++;
                        if (chessLinkedCount == 5) {
                            return true;
                        }
                    }
                }
                if (chessLinkedCount == (chessLinkedCompare + 1)) {
                    chessLinkedCompare++;
                } else {
                    break;
                }
            }

            chessLinkedCount = 1;
            chessLinkedCompare = 1;
            // 判断当前下的棋子的上边4个棋子是否都为白棋
            for (closeGrid = 1; closeGrid <= 4; closeGrid++) {
                for (chessToCompareIndex = 0; chessToCompareIndex <= chessWhiteCount; chessToCompareIndex++) {
                    if ((xPos * dis == chessWhite_XPOS[chessToCompareIndex])
                            && ((yPos + closeGrid) * dis == chessWhite_YPOS[chessToCompareIndex])) {
                        chessLinkedCount++;
                        if (chessLinkedCount == 5) {
                            return true;
                        }
                    }
                }
                if (chessLinkedCount == (chessLinkedCompare + 1)) {
                    chessLinkedCompare++;
                } else {
                    break;
                }
            }

            // 判断当前下的棋子的下边4个棋子是否都为白棋
            for (closeGrid = 1; closeGrid <= 4; closeGrid++) {
                for (chessToCompareIndex = 0; chessToCompareIndex <= chessWhiteCount; chessToCompareIndex++) {
                    if ((xPos * dis == chessWhite_XPOS[chessToCompareIndex])
                            && ((yPos - closeGrid) * dis == chessWhite_YPOS[chessToCompareIndex])) {
                        chessLinkedCount++;
                        if (chessLinkedCount == 5) {
                            return true;
                        }
                    }
                }
                if (chessLinkedCount == (chessLinkedCompare + 1)) {
                    chessLinkedCompare++;
                } else {
                    break;
                }
            }

            chessLinkedCount = 1;
            chessLinkedCompare = 1;
            // 判断当前下的棋子的左上方向4个棋子是否都为白棋
            for (closeGrid = 1; closeGrid <= 4; closeGrid++) {
                for (chessToCompareIndex = 0; chessToCompareIndex <= chessWhiteCount; chessToCompareIndex++) {
                    if (((xPos - closeGrid) * dis == chessWhite_XPOS[chessToCompareIndex])
                            && ((yPos + closeGrid) * dis == chessWhite_YPOS[chessToCompareIndex])) {
                        chessLinkedCount++;
                        if (chessLinkedCount == 5) {
                            return true;
                        }
                    }
                }
                if (chessLinkedCount == (chessLinkedCompare + 1)) {
                    chessLinkedCompare++;
                } else {
                    break;
                }
            }

            // 判断当前下的棋子的右下方向4个棋子是否都为白棋
            for (closeGrid = 1; closeGrid <= 4; closeGrid++) {
                for (chessToCompareIndex = 0; chessToCompareIndex <= chessWhiteCount; chessToCompareIndex++) {
                    if (((xPos + closeGrid) * dis == chessWhite_XPOS[chessToCompareIndex])
                            && ((yPos - closeGrid) * dis == chessWhite_YPOS[chessToCompareIndex])) {
                        chessLinkedCount++;
                        if (chessLinkedCount == 5) {
                            return true;
                        }
                    }
                }
                if (chessLinkedCount == (chessLinkedCompare + 1)) {
                    chessLinkedCompare++;
                } else {
                    break;
                }
            }

            chessLinkedCount = 1;
            chessLinkedCompare = 1;
            // 判断当前下的棋子的右上方向4个棋子是否都为白棋
            for (closeGrid = 1; closeGrid <= 4; closeGrid++) {
                for (chessToCompareIndex = 0; chessToCompareIndex <= chessWhiteCount; chessToCompareIndex++) {
                    if (((xPos + closeGrid) * dis == chessWhite_XPOS[chessToCompareIndex])
                            && ((yPos + closeGrid) * dis == chessWhite_YPOS[chessToCompareIndex])) {
                        chessLinkedCount++;
                        if (chessLinkedCount == 5) {
                            return true;
                        }
                    }
                }
                if (chessLinkedCount == (chessLinkedCompare + 1)) {
                    chessLinkedCompare++;
                } else {
                    break;
                }
            }

            // 判断当前下的棋子的左下方向4个棋子是否都为白棋
            for (closeGrid = 1; closeGrid <= 4; closeGrid++) {
                for (chessToCompareIndex = 0; chessToCompareIndex <= chessWhiteCount; chessToCompareIndex++) {
                    if (((xPos - closeGrid) * dis == chessWhite_XPOS[chessToCompareIndex])
                            && ((yPos - closeGrid) * dis == chessWhite_YPOS[chessToCompareIndex])) {
                        chessLinkedCount++;
                        if (chessLinkedCount == 5) {
                            return (true);
                        }
                    }
                }
                if (chessLinkedCount == (chessLinkedCompare + 1)) {
                    chessLinkedCompare++;
                } else {
                    break;
                }
            }
        }
        return false;
    }

（3）棋盘多线程

    /**
     * 处理取得的信息
     **/
    public void dealWithMsg(String msgReceived){
        //收到的信息为下棋
        if(msgReceived.startsWith("/chess")){
            StringTokenizer userMsgToken = new StringTokenizer(msgReceived, " ");
            // 表示棋子信息的数组、0索引为：x坐标；1索引位：y坐标；2索引位：棋子颜色
            String[] chessInfo = { "-1", "-1", "0" };
            // 标志位
            int i = 0;
            String chessInfoToken;
            while (userMsgToken.hasMoreTokens()) {
                chessInfoToken = userMsgToken.nextToken(" ");
                if (i >= 1 && i <= 3) {
                    chessInfo[i - 1] = chessInfoToken;
                }
                i++;
            }
            thisBoard.paintNetChessPoint(Integer.parseInt(chessInfo[0]), Integer
                    .parseInt(chessInfo[1]), Integer.parseInt(chessInfo[2]));
            // 收到的信息为改名
        } else if (msgReceived.startsWith("/yourname ")) {
            thisBoard.chessSelfName = msgReceived.substring(10);
            // 收到的为错误信息
        } else if ("/error".equals(msgReceived)) {
            thisBoard.statusText.setText("用户不存在，请重新加入!!!");
        }
    }

    /**
     * 发送信息
     **/
    public void sendMessage(String sentMessage){
        try {
            thisBoard.outputData.writeUTF(sentMessage);
        } catch (Exception ea) {
            ea.printStackTrace();
        }
    }

    @Override
    public void run(){
        String msgReceived;
        try {
            //等待信息输入
            while(true){
                msgReceived = thisBoard.inputData.readUTF();
                dealWithMsg(msgReceived);
            }
        } catch (IOException ignored) {
        }
    }

（4）部分GUI实现

   /**
    * 画棋盘
    * */
    public void paint(Graphics g) {
        for (int i = 40; i <= 580; i = i + 30) {
            g.drawLine(40, i, 580, i);
        }

        for (int j = 40; j <= 580; j = j + 30) {
            g.drawLine(j, 40, j, 580);
        }
        g.fillOval(127, 127, 8, 8);
        g.fillOval(487, 127, 8, 8);
        g.fillOval(127, 487, 8, 8);
        g.fillOval(487, 487, 8, 8);
        g.fillOval(307, 307, 8, 8);
    }

4.心得体会

（1）在本次课程设计中，我们掌握了不少在课堂上未曾学到或是常常被我们忽略的编程技巧与知识，更学会了如何用git管理我们的代码。团队成员的编程能力得到了一定程度的提高。

（2）我们的五子棋游戏实现了联机对战功能，但仍有很多功能有待完善，如：聊天室、棋局计时等。且只能实现同一局域网内的联机。

（3）由于本次课设时间有限，我们的图形界面美观度还不够高，后期还可以加入图片、动画等进行完善。

m0_60899623
关注
专栏目录
java课程设计及答案.pdf
09-30
java课程设计及答案.pdf
Java课程设计【学生信息管理系统】
热门推荐
振华OPPO的博客世界
06-01 7万+
这次课程设计总体来说是一次非常有意义的任务，因为在这次课程设计中我学会了很多GUI编程和流类的知识，提高了编程的能力，也增加了对编程的兴趣。虽然这是一个小项目，但是能把它做好也是有很大的满足感。虽然一开始遇到很多问题，但自己都咬牙克服、迎难而上，每天都在钻研程序，然后将自己的思想与同学们交流。可以说，没有付出就没有回报，只要你肯付出，就会有收获。一件事，你只要用心去做了，将它做好，无论结果如何，你都不会留有遗憾的。
[内附完整源码和文档] 基于Java的考勤管理系统
LEMFOooO的博客
09-18 6780
摘 要 该考勤信息管理系统用于实现学校对在校学生的考勤信息的管理，是典型的管理信息系统。学生考勤信息的手工登记查询，是一项非常繁重而枯燥的劳动。在计算机技术飞速发展的今天，应用数据库技术实现学生考勤信息统计的管理是行之有效的。 本报告系统地介绍了一个基于java的学生考勤信息管理系统，论述了一个基于java的学生/老师考勤信息管理系统的设计原理、设计思想及具体的实现过程，对部分架构及设计思想和设计过程作了详细阐述。系统具有师生个人信息查询、请假、随堂点到等功能，信息管理模块、考勤管理模块和考勤系统模块。 本
Java课程设计/大作业合集
weixin_45344924的博客
06-18 2万+
JavaSE、JavaEE课程设计/大作业/毕业设计，汽车租赁系统、员工管理系统、超市管理系统、网上购物商城
JAVA语言课程设计——扫雷小游戏
weixin_61149547的博客
01-24 1万+
1.设计内容 设计一个界面为10*10的扫雷程序，雷的个数不少于10个。功能如Windows系统给定的扫雷游戏。 效果如图：扫雷界面 2.设计要求 界面美观，鼠标的左右键好用。左键：直接显示有几个雷，如果该区域本身就是雷，游戏结束。右键：设置该区域为雷，如果设为雷区，再点右键则该区域返回没点开状态。双击：如果一个区域四周设置的雷数=该区域显示的个数，双击则可以直接显示该区域四周的数字。 3.设计思想 定义一个类B，继承于JButton，该类有4个变量整型变量num、x、y和boole..
java课程设计 个人博客网站).rar
12-12
【Java课程设计：个人博客网站】是一个典型的Java技术实践项目，旨在锻炼学生的编程能力，理解Web应用程序的开发流程。这个项目包含完整的源代码和相关报告，对于学习Java Web开发的学生或者初学者来说，是一个很好...
java设计并实现个人博客系统（包含数据库）.rar
01-11
个人博客系统主要用于发表个人博客，记录个人生活日常，学习心得，技术分享等，供他人浏览，查阅，评论等。本系统结构如下： （1）博主端： 登录模块：登入后台管理系统：首先进入登录页面，需要输入账号和密码。它...
java毕设之个人博客系统的设计与实现
03-22
《Java毕设：个人博客系统的设计与实现》 在当今数字化时代，个人博客系统作为自我表达和信息分享的重要平台，其设计与实现是许多计算机专业学生毕业设计的热门选择。本项目采用Java技术栈，提供了完整的前后端源码...
课程设计基于Java开发的个人博客前端+服务端源码.zip
11-14
课程设计基于Java开发的个人博客前端+服务端源码.zip课程设计基于Java开发的个人博客前端+服务端源码.zip课程设计基于Java开发的个人博客前端+服务端源码.zip课程设计基于Java开发的个人博客前端+服务端源码.zip课程...
javaweb项目个人博客管理系统jsp+servlet+mysql-java课程设计毕业设计
最新发布
10-16
本资源为一款JavaWeb项目个人博客管理系统，采用了JSP+Servlet+MySQL技术栈，适用于Java课程设计和毕业设计参考资料。该系统功能完善，包括用户注册登录、文章管理、分类管理、评论功能等模块，实现了博客的动态数据...
Java 课程设计
08-10
1. 输出50—100间的所有素数，其中判断一个数是否为素数用函数完成。 2. 设计一个学生成绩管理系统，能输入学生的学号、姓名和成绩等数据，能按成绩从高到低进行排序，并能将排序的结果输出。 提示： 设计一个学生类student，包含三个私有数据成员，即学号sno、姓名sname和成员score； 在学生类student中再设计三个方法 setdata、display和getscore，分别用于完成输入学生信息、输出学生信息、返回某个学生成绩的功能； 定义一个manage类，它有一个student类型的私有数据成员s[num],其中num表示学生人数； 在manage类中分别定义三个方法input、output、sort,分别用于完成输入、输出和排序功能。 3.一个电子产品商店里卖各种电子产品，以下是几种产品类信息。 产品Product 的属性信息包括： 产品号（number） 种类（category） 名称（name） 价格（price ） 计算机Computer除具有产品基本信息外，还可能具有下面的属性： 内存（memory） 处理器（processorName） 　　笔记本电脑Laptop 除具有产品基本信息外，还可能具有下面的属性： 厚度（thickness） 重量（weight） 根据以上信息，首先抽象出类Product，它派生出子类Computer，Computer又派生出它的子类Laptop，实现以上三个类的定义，定义相应的构造方法，声明一个测试类，生成类对象，并把打印结果显示在屏幕上。
Java课程设计
01-15
已知10个篮子一字排开，从左到右分别标号：1,2,…,10，10个球也有标号，分别也是1,2,…,10。现要将这10个球全部放入这10个篮子中，每个篮子放置1个球，要求球的号不能与其所在的篮子的号相同，在相邻篮子内的球的球号不能相邻。例如，如果在相邻两个篮子内的球的球号分别为9和10，则是不允许的。 要求输出所有符合要求的放球方式。对于每种符合要求的放球方式，都应输出在每个篮子中的球号。
java课程设计
03-15
java的课程报告及代码，菜鸟级，功能简单
Java课程设计-学生成绩管理系统
计算机源码之家的博客
12-14 1万+
????作者主页：疯狂行者???? ????简介：Java领域新星创作者????、【计算机源码之家】公号作者✌ 简历模板、学习资料、面试题库【关注我，都给你】???? ????文末获取源码联系???? 工具下载链接????????????： JDK版本下载 Eclipse下载链接 Mysql下载链接 tomcat下载链接 向日葵远程工具 Maven下载链接 计算机课程设计|毕业设计之学生成绩管理系统代码-基于JavaWeb的学生成绩管理系统 文章目录计算机课程设计|毕业设计之学生成绩管理系统代码-基于Ja
【Java课程设计】基于Java Swing 的图书管理系统
知识记录
12-26 1万+
本次课程设计基于教材《Java基础案例教程(第二版)》中的第十三章，对课程源码的整理和分享。整个课程设计，我整理了mysql数据库的两个版本：5.7和8.0，方便各位码友们的学习❤
面向对象程序设计(Java)课程设计——学生信息管理系统(GUI+文件)
m0_75075973的博客
06-13 2706
本项目由我们二人共同合作完成，该系统可实现学生信息的增加，删除，修改，查询，筛选的功能。该系统没有利用数据库，是使用文件来存储学生数据，有基本的 UI 界面，操作友好，项目运行没有问题。首先是根据学生基本信息，声明变量，给出无参构造器以及有参构造器，随之给出相应的set，get方法，并创建fileString方法，返回基本信息。6.删除信息(输入存在的学号后，点击删除信息)负责模块：增加，删除，修改以及查询功能的实现。5.查询信息(输入学号后，点击查询信息)7.修改信息(输入学号后，点击修改信息)
高分SpringBoot+mysql个人博客系统课程设计源码
综上所述，该资源对于学习Java后端开发、想要了解个人博客系统实现的人员，以及寻找毕业设计或课程设计项目的大学生等，都是一份不可多得的学习材料。通过研究和实践该项目，学习者可以提升自己的编程技能，对实际...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值