第一次发布时间：2020年12月27日 01:58
第二次发布时间：2020年12月27日 18:46
第三次发布时间：2021年01月02日 15:34
演示视频表格操作界面：
单界面学生管理系统演示过程
演示视频：完整视频（少了演示修改和全部删除）
学生管理系统CRUD单界面版演示过程
源码链接：https://download.csdn.net/download/preston555/14011034
文章一共分为三大部分：初级、进阶、图形界面化三个阶段。此为1.0版
目标是进阶到：
2.0版综合应用程序
3.0版javaweb网站开发
4.0版maven项目管理SSM技术的综合应用
文章目录：
1.学生管理系统的初级阶段01
主要知识点：控制语句结构及数组的应用
2.学生管理系统的初级阶段02
主要知识点：面向对象的综合应用
3.学生管理系统的初级阶段03
主要知识点：图形用户化界面、表格组件、以及数据库的简单使用
1.学生管理系统的初级阶段01
1.总体设计：
（1）首先输入学生人数和学科数目
（2）其次输入各学科名称和各学生姓名
（3）输入各学生各学科成绩
（4）最后显示所有学生所有科目信息以及平均分、总分和排名
2.代码实现与分析：
（1）输入需要一个Scanner类创建的对象，获取键盘输入内容
Scanner input=new Scanner(System.in);//表示创建一个读取从控制台输入内容的流对象
（2）输入学生人数和学生科目，使用上述对象读取从控制台输入的字符即可
int studentNum=input.nextInt();//表示读取的是一个整数，非整数将报错，这里是学生人数
int subjectNum=input.nextInt();//表示读取的是一个整数，非整数将报错，这里是科目总数
（3）输入学生的姓名及各科名称、以及各个学生的各科成绩。使用数组的思想遍历输入
String[] studentName=new String[studentNum];//创建一个指定学生人数的数组，记录学生的姓名
String[] subjectName=new String[subjectNum];//创建一个指定科目总数的数组，记录科目的名称
String[] stuInfo=new String[studentNum];//创建一个指定学生人数的数组，记录各个学生的姓名、科目成绩信息
int[] scoreSum=new int[studentNum];//创建一个指定学生人数的数组，记录各个学生的各科成绩总和
String header="序号"+"\t"+"姓名"+"\t";//输出的列名称
（4）输入学生的姓名及各科名称、以及各个学生的各科成绩。使用循环遍历输入
//1.输入学生的姓名，同时更新学生的信息
for(int i=0;i<studentName.length;i++){
System.out.println("请输入第 "+(i+1)+" 位学生的姓名：");
String name=input.next();//输入学生的姓名
studentName[i]=name;//更新存储学生姓名数组
stuInfo[i] = name+"\t";//更新学生信息数组
}
//2.输入各个科目的，同时更新列名的信息
for(int i=0;i<subjectName.length;i++){
System.out.println("请输入第 "+(i+1)+" 科的科目名称：");
String name=input.next();//输入科目的名称
subjectName[i]=name;//更新存储科目名称数组
stuInfo[i] += name+"\t";//更新学生信息数组
}
//3.输入各个学生的各科科目的成绩，同时更新学生的信息和计算他们的总分
for(int i=0;i<studentName.length;i++){
int sum=0;//记录学生的各科成绩之和
for(int j=0;j<subjectName.length;j++){
System.out.println("请输入学生"+studentName[i]+"的"+subjectName[j]+"科目成绩：");
int score=input.nextInt();//输入科目的成绩
sum += score;//计算总分
stuInfo[i] += score+"\t";//更新学生的信息
}
scoreSum[i]=sum;//更新学生总分的信息
double avg=sum*1.0/subjectName.length;//计算平均分
DecimalFormat df=new DecimalFormat("0.00");//格式不严格处理，保留两位小数
avg=Double.valueOf(df.format(avg));//转换为double型
stuInfo[i] +=sum +"\t"+avg+"\t";
}
//4.所有输入结束，关闭流
input.close();
（5）根据总分排序
//5.根据总分对学生进行排名(使用选择排序从高分到低分，同时更新学生信息数组）
for (int i = 0; i < scoreSum.length-1; i++) {
for (int j = i+1; j < scoreSum.length-1; j++) {
if(scoreSum[i]<scoreSum[j]){
//交换比较值
int temp=scoreSum[i];
scoreSum[i]=scoreSum[j];
scoreSum[j]=temp;
//同时信息也交换,实现信息跟着总分排序
String str=stuInfo[i];
stuInfo[i]=stuInfo[j];
stuInfo[j]=str;
}
}
}
//6.输出结果
System.out.println(header+"总分\t平均分\t排名");//输出列名
for (int i = 0; i < stuInfo.length; i++) {
System.out.println(stuInfo[i]+"第"+(i+1)+"名");//输出最后结果
}
====================================测试过程==============================================
请输入学生的总人数：
3
请输入科目的总数：
3
请输入第 1 位学生的姓名：
语程峰
请输入第 2 位学生的姓名：
杨慧慧
请输入第 3 位学生的姓名：
刘子琪
请输入第 1 科的科目名称：
语文
请输入第 2 科的科目名称：
数学
请输入第 3 科的科目名称：
英语
请输入学生语程峰的语文科目成绩：
98
请输入学生语程峰的数学科目成绩：
98
请输入学生语程峰的英语科目成绩：
96
请输入学生杨慧慧的语文科目成绩：
98
请输入学生杨慧慧的数学科目成绩：
92
请输入学生杨慧慧的英语科目成绩：
96
请输入学生刘子琪的语文科目成绩：
96
请输入学生刘子琪的数学科目成绩：
98
请输入学生刘子琪的英语科目成绩：
90
序号 姓名 语文 数学 英语 总分 平均分 排名
1 语程峰 98 98 96 292 97.33 第1名
2 杨慧慧 98 92 96 286 95.33 第2名
3 刘子琪 96 98 90 284 94.67 第3名
Process finished with exit code 0
==================================================================================================================================================================================
2.学生管理系统的初级阶段02
1.总体设计要求与目的
（1）先规定学生的人数
（2）实现学生的添加和查找
（3）根据学生编号更新学生信息和删除学生
（4）根据学生编号输入学生各门成绩
（5）根据某门成绩或总分排名
（6）上述所有操作均可循环操作
2.巩固知识点：控制语句结构及数组知识，对象及类的综合使用
3.总体设想与设计
（1）系统的上限人数由控制台输入人数决定
（2）整个小实验是分为三大类：
封装类Student，包含学生的基本信息，包括科目名称与成绩。
主程序是实现循环操作的项目选择
方法实现类实现的各个操作的具体方法
（3）所有输入内容进行验证，查看是否符合要求
（4）执行顺序大致可以分为：主程序操作选择--->调用处理方法---->调用封装类获取相关对象的数据
（5）初步学习阶段尽可能少用系统工具类
4.具体实现步骤与思路分析：
（1）主程序部分实现的是学生人数的输入，这就限定了这个管理系统的学生人数上限，使用输入流获取
//1.创建输入流对象
Scanner input=new Scanner(System.in);
//2.输入学生总人数和科目的总数
System.out.println("请输入学生的总人数：");
int studentNum=input.nextInt();
//3.创建一个指定人数的学生类数组
Student[] stu=new Student[studentNum];
//4.创建执行方法类对象
StudentService stuService=new StudentServiceImpl(stu);
（2）主程序部分实现的操作的循环使用，使用一个while循环实现，直至选择退出程序才结束
//5.执行选择操作
while (true) {
System.out.println("请选择要执行的操作：");
System.out.println("00：添加一个学生");
System.out.println("01：根据学号修改学生信息");
System.out.println("02：根据学号查找学生");
System.out.println("03：根据性别查找学生");
System.out.println("04：根据平均分查找学生");
System.out.println("05：根据学号删除学生");
System.out.println("06：删除所有学生");
System.out.println("07：显示所有学生的所有信息");
System.out.println("08：根据某门成绩进行降序排列显示");
System.out.println("88：退出系统");
String choose=input.next();
if(choose.equals("00")){
}else if(choose.equals("01")){
}else if(choose.equals("02")){
}else if(choose.equals("03")){
}else if(choose.equals("04")){
}else if(choose.equals("05")){
}else if(choose.equals("06")){
}else if(choose.equals("07")){
}else if(choose.equals("08")){
}else if(choose.equals("88")){
System.out.println("谢谢使用学生管理系统，再见！");
System.exit(0);
}else{
System.out.println("抱歉，没有该选项，请重新选择！");
}
}
（3）封装类设计：Student.java
属性有：String型 stu_ID，stu_name,stu_gender，rank; Double型 scoreAvg;
Integer型 stu_age,java,phython,computer,scoreSum
以及一个处理平均数格式的属性：DecimalFormat df=new DecimalFormat("0.00");
重写其toString方法，使用"\t"分隔
（4）主类设计：StudentAdmin.java,就是（1）（2）的主要内容，还有一个方法，实现学生信息修改选项：private String updateStudentByChoosing();
（5）接口设计：接口：StudentService.java；就是把要执行的方法全部列举一遍
（6）实现类设计：StudentServiceImpl.java；实现具体的方法
（7）工具类设计1：Condition.java；各种输入判断以及部分条件判断，以确保执行操作是在合理的要求内实现
（8）工具类设计2：Regex.java；正则表达式类
==================================================================================================================================================================================
5.接口类：StudentService.java
//1.添加学生的方法
void addStudentInformation();
//2.根据学号修改学生信息
void updateStudentInformationByStu_ID(String stu_ID);
//3.根据学号查找学生信息
void queryStudentInformationByStu_ID(String stu_ID);
//4.根据性别查找学生
void queryStudentInformationByStu_gender(String stu_gender);
//5.根据平均分查找学生
void queryStudentInformationByScoreAvg(String level,Double scoreAvg);
//6.根据学号删除学生
void deleteStudentInformationByStu_ID(String stu_ID);
//7.删除所有学生
void deleteAllStudentInformation();
//8.显示所有学生的所有信息
void queryAllStudentInformation();
//9.根据某门成绩进行升序排列显示学生信息
void queryStudentInformationBySubject(String subject);
==================================================================================================================================================================================
6.接口实现类：StudentServiceImpl.java；逐步实现上面的方法
（1）添加学生分析：
1）添加的前提条件：数组里面有空位，即至少有一个元素的值是null；
2）添加的实现原则是：必须是在前一项已经成功添加之后才能添加下一项，如要添加姓名，必须先有学号。依次添加所有对象属性完毕之后，进行总分求和，平均分求值，添加到数组中，更新数组排名，最后打印添加成功的对象信息；
3）在实现属性添加过程中，实现所有输入的验证，不符合条件的值不允许执行，只能返回主菜单或者退出程序；
（01）添加学生实现过程：
001.前提条件判断（创建一个判断类，包含所有的方法执行前的判断条件：BeforeAction.java)：
该类具有两个私有属性：private Student[] stu; private Scanner input;
该类具有一个有参构造：参数是Student[] stu,Scanner input
方法：public boolean isArrayHasEmpty();
//1.首先数组为空判断
if(stu !=null){
for(Student student:stu){
if(student==null)
return true;//有空位返回true
}
}else{
return true;//有空位返回true
}
return false;//没有空位
002.进入添加程序时，正式执行添加操作：
方法：public void addStudentInformation();
//1.创建一个学生对象，用于存储添加的学生信息
Student student=new Student();
//2.添加学号（要求1：学号必须是2020开头，后接任意4位数字；要求2：学号是唯一不可重复）
//2.0.输入提示信息
System.out.println("请输入学生的学号：");
String inStr=input.next();
//2.1.使用循环，确保一定是在结束该方法或者该程序或者满足条件下才退出循环
while(true){
//2.2.判断是否符合输入要求，即必须是2020开头，后接任意4位数字。使用Regex.java类，该类主要进行正则表达式的判断，即判断输入是否符合要求。
/*
* 判断学号是否符合输入要求：
* //1.正则表达式，表示以2020开头，后面是4位任意数字（后面列正则表达式）
* String regex="2020[0-9]{4}";
* //2.返回结果值（该方法通用）
* return inStr.matches(regex)==true ? true : false;
*
*/
if(Regex.isRequiredStuID(inStr)){//符合输入条件
//2.3.判断学号是否重复(该方法可以抽取出来）
boolean flag=true;
if(stu !=null){
for(Student student1:stu){
if(studnet1 !=null && student1.getStu_ID.equals(inStr)){
flag=false;
break;
}
}
}
//学号没有重复给予赋值
if(flag){
student.setStu_ID(inStr);
}else{//学号重复提示消息，询问返回上一级菜单还是退出程序，还是继续输入
System.out.println("学号重复，是否继续，返回上一级菜单输入：00；退出程序输入：88；继续输入其它任意键");
String choose=input.next();
if(choose.equals("00"){
return;
}else if(choose.equals("88")){
System.out.println("谢谢使用学生管理系统，再见！");
input.close();//关闭流对象
System.exit(0);//退出程序
}
}
}else{//学号不符合要求，询问返回上一级菜单还是退出程序，还是继续输入
System.out.println("学号输入不符合要求（要求2020开头，后接4位任意数字），是否继续，返回上一级菜单输入：00；退出程序输入：88；继续输入其它任意键");
String choose=input.next();
if(choose.equals("00"){
return;
}else if(choose.equals("88")){
System.out.println("谢谢使用学生管理系统，再见！");
input.close();//关闭流对象
System.exit(0);//退出程序
}
}
//循环不退出，重新输入学号验证
System.out.println("请重新输入学号：");
inStr=input.next();
}
//3.添加姓名、性别、年龄、分数的方法同上，只是没有重复值判断，只有正则表达式判断，以下列举对应的正则表达式：
//01.姓名正则表达式，表示中文字符，且长度在[2,5]
String regex = "[\\u4e00-\\u9fa5]{2,5}";
//02.年龄正则表达式，表示范围[3,60]
String regex="[3-9]|[1-5][0-9]|60";
//03.性别正则表达式，表示男或女
String regex="男|女";
//04.分数正则表达式，表示范围[0,100]
String regex="[0-9]|[1-9][0-9]|100";
//4.总分设置和平均分设置（可以在封装类中处理，也可以单独创建方法，建议使用后者）
//总分
int sum=student.getJava()+student.getPython()+student.getComputer();
student.setScoreSum(sum);
//平均分
DecimalFormat df=new DecimalFormat("0.00");//格式设置（该方法有弊端）
String value=df.format((sum*1.0/3));//获取字符串型的平均数值
double avg=Double.parseDouble(value);//转成double型数值
student.setScoreAvg(avg);
//5.更新数组
for(int i=0;i<stu.length;i++){
if(stu[i] ==null){
stu[i]=student;
break;
}
}
//6.根据总分更新排序（分数由高到低降序）
//重新排序(选择排序）
if (stu != null) {
for (int i = 0; i < stu.length-1; i++) {
if(stu[i] !=null) {
for (int j = i + 1; j < stu.length - 1; j++) {
if(stu[j] !=null) {
if (stu[i].getScoreSum() < stu[j].getScoreSum()) {
Student temp = stu[i];
stu[i] = stu[j];
stu[j] = temp;
}
}
}
}
}
}
//7.名次设置
if (stu != null) {
int ranks=1;
for (int i = 0; i < stu.length; i++) {
if(stu[i] !=null){
stu[i].setRank("第"+ranks+"名");
ranks++;
}
}
}
//8.添加学生程序结束
（02）总结分析：
（1）上述的各个属性设置均可单独抽取成独立的方法，方便复用。
（2）在（1）的基础上，可以对学号、姓名、性别、年龄、各科分数的输入判断方法进行更加简洁的优化。如果我们设置的提示信息一样的话，那么就可以简化成如下方法：
//获取符合要求的返回值，action表示执行哪一样操作，inStr是初始输入判断
public String getRequiredStringMessage(String action,String inStr);
while(true){
if(this.returnRegexBoolean(action,inStr){
if(action.equals("学号")){
//判断学号是否重复（单独抽取成方法，内容和上面01列举的一样）
if(this.existSameStuID(inStr)){//重复学号信息提示
//信息提示结果处理，判断是否返回上一级菜单（内容和01列举的一样）
if(this.returnChooseResult())
return "return";//表示结束方法的执行，返回上一级菜单
}
}else{
return inStr;//返回符合结果的值
}
}else{//输入不符合要求信息提示
//信息提示结果处理，判断是否返回上一级菜单
if(this.returnChooseResult())
return "return";//表示结束方法的执行，返回上一级菜单
}
//默认执行的命令
System.out.println("请重新输入"+action+":");
inStr=input.next();
}
//获取正则表达式的结果值
private boolean returnRegexBoolean(String action,String inStr){
if(action.equals("学号"))
return Regex.isRequiredStuID(inStr);
else if(action.equals("姓名"))
return Regex.isRequiredStuName(inStr);
else if(action.equals("性别"))
return Regex.isRequiredStuGender(inStr);
else if(action.equals("年龄"))
return Regex.isRequiredStuAge(inStr);
else
return Regex.isRequiredStuScore(inStr);
}
（3）调用方法修改：
//2.0.输入提示信息
System.out.println("请输入学生的学号：");
String inStr=input.next();
//结果返回
String resultStr=this.getRequiredStringMessage("学号",inStr);
if(resultStr.equals("return"))
return;//返回上一级菜单
else
student.setStu_ID(resultStr);
//继续下一个属性的添加，完全类似。修改方法中同样用此种方法
----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
（2）根据学号修改学生信息分析：
1）修改的前提条件：数组不为空，且数组中有该学号的学生信息，所以需对上述两个条件判断，符合才执行修改操作命令；
2）修改的实现原则是：学号不允许修改，进入修改程序，首先询问修改的项目，根据项目执行修改功能，所有修改都执行更新信息。如果是修改科目分数，则进行总分、平均分更新以及排名更新；
3）在实现属性修改过程中，实现所有输入的验证，不符合条件的值不允许执行，只能返回上一级菜单或者退出程序；
4）目标实现的是可以通过命令询问实现循环修改；
（01）修改学生信息实现过程：
//1.根据传进来的学生编号获取对应的元素对象（也可以把数组中的学生对象传进来做参数）
Student student=null;
if(stu !=null){
for(int i=0;i<stu.length;i++){
if(stu[i] !=null &&stu[i].getStu_ID().equals(inStr)){
student=stu[i];
break;
}
}
}
//2.询问修改项
if(student !=null){
//3.实现循环修改选择
while(true){
//4.选择修改的具体项（当然也可以设置默认的从头到尾除学号之外的修改）
System.out.println("请输入你要修改的项目：00-姓名；11-性别；22-年龄；33-java；44-Python；55-computer）
String choose=input.next();
//5.开始修改
if(choose.equals("00")){//修改姓名
System.out.println("请输入学生的学号：");
String inStr=input.next();
//结果返回
String resultStr=this.getRequiredStringMessage("学号",inStr);
if(resultStr.equals("return")==false)
student.setStu_ID(resultStr);
}
....
else{
//除学号之外从头开始修改
}
//6.更新对应数组元素（是不是可以优化成传进来下标，直接修改数组元素呢？）
if(stu !=null){
for(int i=0;i<stu.length;i++){
if(stu[i] !=null &&stu[i].getStu_ID().equals(inStr)){
stu[i]=student;
break;
}
}
}
//7.更新排名（同添加中一样，也可以考虑使用插入的方法，因为之前均都排好序了，只需修改一部分元素的位置即可）
//8.设置名次（同添加中一样，如果始终保存前面没有空元素，可以在实现排名的时候就设置它的名次，同时更新其它元素的名次）
}
}
以下的（3）到（9）实现方法过于简单或与前面内容几乎重复，不再重复列举。
----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
（3）根据学号查找学生信息分析：
1）查找的前提条件：数组不为空，且数组中有该学号的学生信息，所以需对上述两个条件判断，符合才执行修改操作命令；
2）查找的实现原则是：当进入查找程序时，先去数组中查找对应学号的元素，找到打印出来并结束查找程序，找不到给出提示信息；
----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
（4）根据性别查找学生信息分析：
1）查找的前提条件：数组不为空，且输入的性别是符合要求的，所以需对上述两个条件判断，符合才执行修改操作命令；
2）查找的实现原则是：当进入查找程序时，先去数组中查找对应性别的元素，找到打印出来，找不到给出提示信息；
----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
（5）根据平均分查找学生信息分析：
1）查找的前提条件：数组不为空，且输入的平均分是符合要求的，所以需对上述两个条件判断，符合才执行修改操作命令；
2）查找的实现原则是：当进入查找程序时，首先询问查找的具体条件（大于、小于、等于），然后根据条件遍历数组，如果对象不为空且对象的平均分满足条件，就打印出来，如果找不到给出提示信息
----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
（6）根据学号删除学生信息分析：
1）删除的前提条件：数组不为空，且输入的学号是符合要求的，在数组中是存在的才执行；
2）删除的实现原则是：当进入删除程序时，遍历数组，找到学号相等的元素，将元素的值赋值为null即可，将删除信息打印出来，同时提示删除结果
----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
（7）删除所有学生信息分析：
1）删除所有学生信息的前提条件：数组不为空；
2）删除的实现原则是：当进入删除程序时，直接将数组设置为null即可，删除结束给出提示。
----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
（8）显示所有学生的所有信息分析：
1）前提条件：数组不为空；
2）实现原则是：当进入程序时，直接遍历数组，将不为null值的元素打印出来即可，如若没有给出提示
----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
（9）根据某门成绩进行升序排列显示学生信息分析：
1）前提条件：数组不为空；
2）实现原则是：当进入程序时，首先询问选择的科目，然后对根据科目进行排序（分数由低到高），最后显示出来即可。
演示视频如下：学生管理系统无界面1.0版详细演示过程
源码链接：https://download.csdn.net/download/preston555/13944070
3.学生管理系统的初级阶段03
一、设计思路如下：
1.登陆界面：具有注册、登陆、记住密码、自动登录、找回账户、找回密码、取消功能。需要输入用户名、密码、验证码方可点击登陆
（1）注册：同意条款方可注册；注册要求用户名唯一性，设置找回密码的问题三个
（2）登陆：信息填写完全方可验证登陆
（3）记住密码：如果选择记住密码则将登陆账号信息存到本地中，否则只保存账号信息
（4）找回账户：通过回答两个注册问题正确回答方可找回
（5）找回密码：通过账号和两个注册问题正确回答方可找回
（6）取消：退出
2.操作界面：设计为左右界面，左界面显示日历及时间、右界面分上下界面，上界面CRUD命令、下界面表格显示数据
（1）日历设置：可以查询1900年到2100年任一月的显示（同时显示二十四节气在对应日期下面）
（2）时间设置：实时系统时间（单行设置，字符串形式：xxxx年xx月xx日 xx:xx:xx
（3）右界面上部分：CRUD操作指令，其中查找设置为多条件查询，分别有：学号、姓名、年龄、科目分数，平均分、总分，大于、小于，等于条件选择（只针对数值型），什么都没选，默认是查询所有
（4）添加第一结束之后，询问是否继续添加，继续则不退出添加界面、修改第一次修改结束后可以选择学号继续修改，不选择默认退出
（5）删除只有根据学号或全部删除两项选择。
（6）下界面设计，表格是允许进行增删改查的，统一提交时对结果进行判断，存在错误不提交，否则全部提交。
（7）表格内容允许导入与导出，导入部分若不和数据库的数据表设计一样，则弹出保存对话框选择保存到本地，若是一样的，弹出对话框询问保存至何处（本地还是数据库），判断条件，符合要求存储到数据库中二、代码实现过程的简单分析
1.登陆系统
（1）进入登陆界面：采用BorderLayout布局，中间是一个标签，南边是一个进度条
package com.study.main;
......
public class EnterLogin extends JWindow implements Runnable {
JProgressBar progress;
JLabel jll;
int width, height;
public static void main(String[] args) {
new Thread(new EnterLogin()).start();
}
public EnterLogin() {
// 需要保证图片文件在src目录下
jll = new JLabel(new ImageIcon("image\\index.png"));
progress = new JProgressBar();
progress.setStringPainted(true);
progress.setIndeterminate(false);
progress.setBorderPainted(false);
progress.setBackground(Color.darkGray);
this.add(jll, BorderLayout.NORTH);
this.add(progress, BorderLayout.SOUTH);
this.setSize(400, 263);
width = Toolkit.getDefaultToolkit().getScreenSize().width;
height = Toolkit.getDefaultToolkit().getScreenSize().height;
this.setLocation(width / 2 - 200, height / 2 - 150);
this.setVisible(true);
}
@Override
public void run() {
// 1.数字变换,进度条显示
for (int i = 0; i < 101; i++) {
try {
Thread.sleep(20);// 2.进度条的数字显示时间间隔
} catch (Exception e) {
}
progress.setValue(i);// 显示进度条
}
// 3.进入登录界面，同时关闭该窗口
new LoginStudentAdmin();
this.dispose();
}
}
（2）实现登陆界面的设计：登录界面布局为BorderLayout布局，北中南。北为图片显示、中间是登陆信息输入界面、南是记住密码与操作组件界面。实现鼠标和键盘的接口监听。
package com.study.myPage;
import com.study.bean.User;
import com.study.dialog.FindName;
import com.study.dialog.FindPassword;
import com.study.dialog.RegisterDialog;
import com.study.service.LoginService;
import com.study.service.VerifyCode;
import com.study.utils.DataUtils;
import com.study.utils.MyFont;
import javax.swing.*;
import java.awt.*;
import java.awt.event.KeyEvent;
import java.awt.event.KeyListener;
import java.awt.event.MouseEvent;
import java.awt.event.MouseListener;
public class LoginStudentAdmin extends JFrame implements MouseListener,KeyListener {
//图片界面
private JPanel imageJPanel;
//代替图片标签
private JLabel jb_image;
//输入界面
private JPanel loginJPanel;
//登陆信息标签和输入框
private JLabel jb_name,jb_password,jb_verify;
private JTextField jtf_name,jtf_verify,jtf_showCode;
private JPasswordField jpf_password;
private JList jlist;
//找回账号密码标签、验证码切换
private JLabel jb_findName,jb_findPassword,jb_changeCode;
//显示未输入内容提示标签
private JLabel jb_messageName,jb_messagePassword,jb_messageVerify;
//记住密码和自动登陆
private JCheckBox jcb_remember,jcb_autoLogin;
//下部分界面
private JPanel buttonJPanel;
//登陆、注册、取消按钮
private JButton bt_login,bt_register,bt_cancle;
private String codeShow="";
private String codeStr="";
private LoginService loginService=new LoginService();
//记录初始化信息
private String[][] datas=null;
private String[] data_name=null;
//记住密码的状态
boolean rememberPassword=false;
//记录自动登陆状态信息
// private boolean autoLogin;
/**
* 生成验证码及初始化信息
*/
{
String code[] =VerifyCode.readVerifyCode();
codeShow=code[0];
codeStr=code[1];
String[] stringsData=DataUtils.readLoginMessage();
if (stringsData != null) {
datas=new String[stringsData.length][2];
data_name=new String[stringsData.length];
for (int i = 0; i < stringsData.length; i++) {
String ss[]=stringsData[i].split(",");
if(ss.length==1){
datas[i][0]=ss[0];
datas[i][1]="";
}else if(ss.length==2){
datas[i][0]=ss[0];
datas[i][1]=ss[1];
}
data_name[i]=ss[0];
}
}
// autoLogin=DataUtils.readAutoLoginMessage();
}
/**
* 无参构造执行窗口创建方法
*/
public LoginStudentAdmin(){
this.initJFrame();
}
/**
* 上部分图片显示面板
*/
private void initImageJPanel(){
imageJPanel=new JPanel();
jb_image=new JLabel(new ImageIcon("F:\\studyNote\\java\\20201226\\studentsys1.0\\stuedentsys1.0-3\\image\\top.png"));
jb_image.setSize(this.getWidth(),100);
imageJPanel.add(jb_image);
}
/**
* 中间部分输入登陆信息界面
*/
private void initLoginJPanel(){
loginJPanel=new JPanel();
loginJPanel.setLayout(null);
jb_name=new JLabel("账 号：");
if(datas !=null){//保存有账户名
jtf_name=new JTextField(datas[datas.length-1][0]);
}else{
jtf_name=new JTextField();
}
jb_findName=new JLabel("<html><u>找回账号</u></html>");
jb_messageName=new JLabel();
jlist=new JList(data_name);
jb_name.setBounds(50,10,80,30);
jb_name.setFont(MyFont.font5);
jtf_name.setBounds(130,10,150,30);
jb_findName.setBounds(285,10,100,30);
jb_findName.setForeground(Color.BLUE);
jb_messageName.setBounds(175,35,120,25);
jb_messageName.setFont(MyFont.font9);
jb_messageName.setForeground(Color.RED);
jlist.setBounds(130,40,130,120);
jlist.setVisible(false);
loginJPanel.add(jb_name);
loginJPanel.add(jtf_name);
loginJPanel.add(jb_findName);
loginJPanel.add(jb_messageName);
loginJPanel.add(jlist);
jb_password=new JLabel("密 码：");
if(datas !=null && datas[datas.length-1][1].equals("")==false){//最后一个是记住密码的状态
rememberPassword=true;//记住密码的状态
jpf_password=new JPasswordField(datas[datas.length-1][1]);
}else{
jpf_password=new JPasswordField();
}
jb_findPassword=new JLabel("<html><u>找回密码</u></html>");
jb_messagePassword=new JLabel();
jb_password.setBounds(50,60,80,30);
jb_password.setFont(MyFont.font5);
jpf_password.setBounds(130,60,150,30);
jb_findPassword.setBounds(285,60,100,30);
jb_findPassword.setForeground(Color.BLUE);
jb_messagePassword.setBounds(175,85,120,25);
jb_messagePassword.setFont(MyFont.font9);
jb_messagePassword.setForeground(Color.RED);
loginJPanel.add(jb_password);
loginJPanel.add(jpf_password);
loginJPanel.add(jb_findPassword);
loginJPanel.add(jb_messagePassword);
jb_verify=new JLabel("验证码：");
jtf_verify=new JTextField("");
jtf_showCode=new JTextField(codeShow);
jtf_showCode.setFont(MyFont.font9);
jtf_showCode.setEditable(false);
jtf_showCode.setHorizontalAlignment(JTextField.CENTER);
jb_changeCode=new JLabel("<html><u>更换一张</u></html>");
jb_messageVerify=new JLabel();
jb_verify.setBounds(50,110,80,30);
jb_verify.setFont(MyFont.font5);
jtf_verify.setBounds(130,110,70,30);
jtf_showCode.setBounds(210,110,70,30);
jb_changeCode.setBounds(285,110,100,30);
jb_changeCode.setForeground(Color.BLUE);
jb_messageVerify.setBounds(175,135,120,25);
jb_messageVerify.setFont(MyFont.font9);
jb_messageVerify.setForeground(Color.RED);
loginJPanel.add(jb_verify);
loginJPanel.add(jtf_verify);
loginJPanel.add(jtf_showCode);
loginJPanel.add(jb_changeCode);
loginJPanel.add(jb_messageVerify);
}
/**
* 添加监听事件
*/
private void addListener(){
//找回账号与密码监听
jb_findName.addMouseListener(this);
jb_findPassword.addMouseListener(this);
jb_changeCode.addMouseListener(this);
//复选框按钮监听
jcb_remember.addMouseListener(this);
// jcb_autoLogin.addMouseListener(this);
//按钮监听
bt_login.addMouseListener(this);
bt_register.addMouseListener(this);
bt_cancle.addMouseListener(this);
//键盘监听
jtf_name.addKeyListener(this);
jpf_password.addKeyListener(this);
jtf_verify.addKeyListener(this);
jtf_name.addMouseListener(this);
jpf_password.addMouseListener(this);
jtf_verify.addMouseListener(this);
jlist.addMouseListener(this);
this.addMouseListener(this);
}
/**
* 下部分选择登陆取消注册界面
*/
private void initButtonJPanel(){
buttonJPanel=new JPanel();
buttonJPanel.setLayout(null);
jcb_remember=new JCheckBox("记住密码");
jcb_remember.setSelected(rememberPassword);
// jcb_autoLogin=new JCheckBox("自动登陆");
// jcb_autoLogin.setSelected(autoLogin);
jcb_remember.setBounds(80,10,100,30);
// jcb_autoLogin.setBounds(230,10,100,30);
buttonJPanel.add(jcb_remember);
//buttonJPanel.add(jcb_autoLogin);
bt_login=new JButton("登 陆");
bt_register=new JButton("注 册");
bt_cancle=new JButton("取 消");
bt_login.setBounds(60,80,80,30);
bt_register.setBounds(155,80,80,30);
bt_cancle.setBounds(250,80,80,30);
buttonJPanel.add(bt_login);
buttonJPanel.add(bt_register);
buttonJPanel.add(bt_cancle);
}
/**
* 界面容器设置
*/
private void initJFrame(){
this.initImageJPanel();
this.initLoginJPanel();
this.initButtonJPanel();
this.addListener();
GridLayout gridLayout = new GridLayout(3, 1);
this.setLayout(gridLayout);
this.add(imageJPanel,0);
this.add(loginJPanel,1);
this.add(buttonJPanel,2);
this.setTitle("学生管理系统登陆界面");
this.setSize(450,500);
int width = Toolkit.getDefaultToolkit().getScreenSize().width;
int height = Toolkit.getDefaultToolkit().getScreenSize().height;
this.setLocation(width / 2 - 200, height / 2-400);
this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
this.setVisible(true);
// this.autoLogin();
}
// /**
// * 进入自动登陆程序
// */
// private void autoLogin(){
// if(jcb_autoLogin.isSelected()==true){
// this.loginStudentAdminsys();
// }
// }
@Override
public void mouseClicked(MouseEvent e) {
if(e.getSource()==bt_login){//登陆
jlist.setVisible(false);
if(this.codeIsEmpty())
this.loginStudentAdminsys();
else
jtf_verify.requestFocus(true);
}else if(e.getSource()==bt_register){//注册
jlist.setVisible(false);
new RegisterDialog(jtf_name,jpf_password,loginService);
}else if(e.getSource()==bt_cancle){//取消
jlist.setVisible(false);
System.exit(0);
}else if(e.getSource()==jb_findName){//找回账号
jlist.setVisible(false);
jb_findName.setForeground(Color.GRAY);
new FindName(jb_findName,loginService);
}else if(e.getSource()==jb_findPassword){//找回密码
jlist.setVisible(false);
jb_findPassword.setForeground(Color.GRAY);
new FindPassword(jb_findPassword,loginService);
}else if(e.getSource()==jb_changeCode){
jlist.setVisible(false);
this.updateVerifyCode();
}else if(e.getSource()==jpf_password){
jlist.setVisible(false);
if(this.nameIsEmpty()==false)
jtf_name.requestFocus(true);
else
jb_messageName.setText("");
}else if(e.getSource()==jtf_verify){
jlist.setVisible(false);
if(this.nameIsEmpty())
if(this.passwordIsEmpty()==false)
jpf_password.requestFocus(true);
else
jb_messagePassword.setText("");
else
jtf_name.requestFocus(true);
}else if(e.getSource()==jtf_name){
jlist.setVisible(true);
}else if(e.getSource()==jlist){
String value = (String) jlist.getSelectedValue();
jtf_name.setText(value);
if (datas != null) {
for (int i = 0; i < datas.length; i++) {
if(datas[i][0].equals(value)){
if(datas[i][1].equals("")==false){
jpf_password.setText(datas[i][1]);
break;
}
}
}
}
jlist.setVisible(false);
System.out.println(jlist.getSelectedValue());
}else if(e.getSource() == this){
jlist.setVisible(false);
}
}
@Override
public void mousePressed(MouseEvent e) {
}
@Override
public void mouseReleased(MouseEvent e) {
}
@Override
public void mouseEntered(MouseEvent e) {
}
@Override
public void mouseExited(MouseEvent e) {
}
/**
* 用户名获取焦点
*/
private void nameGetFocus(){
if(jtf_name.getFocusTraversalKeysEnabled())
jpf_password.requestFocus();//密码框获取光标
}
/**
* 密码框获取焦点
*/
private void passwordGetFocus(){
if(jpf_password.getFocusTraversalKeysEnabled()){
if(this.nameIsEmpty())
jtf_verify.requestFocus();//验证码框获取光标
else
jtf_name.requestFocus(true);
}
}
/**
* 验证码获取焦点
*/
private void verifyGetFocus(){
if(jtf_verify.getFocusTraversalKeysEnabled())
if(this.passwordIsEmpty())
if(this.codeIsEmpty())
this.loginStudentAdminsys();
else
jtf_verify.requestFocus(true);
else
jpf_password.requestFocus(true);
}
@Override
public void keyTyped(KeyEvent e) {
}
@Override
public void keyPressed(KeyEvent e) {
if(e.getSource()==jtf_name&&e.getKeyCode()==KeyEvent.VK_ENTER) {
jlist.setVisible(false);
this.nameGetFocus();
}else if(e.getSource()==jpf_password&&e.getKeyCode()==KeyEvent.VK_ENTER) {
this.passwordGetFocus();
} else if(e.getSource()==jtf_verify&&e.getKeyCode()==KeyEvent.VK_ENTER) {
this.verifyGetFocus();
}
}
@Override
public void keyReleased(KeyEvent e) {
}
/**
* 验证码更新
*/
private void updateVerifyCode() {
String[] code =VerifyCode.readVerifyCode();
codeShow=code[0];
jtf_showCode.setText(codeShow);
codeStr=code[1];
}
/**
* 实行登陆操作
*/
private void loginStudentAdminsys(){
if(this.booleanLoginMessage()){
//1.获取登录名
String name=jtf_name.getText();
//2.获取密码
String password=this.getLoginPassword(jpf_password.getPassword());
//3.保存登陆信息
this.saveLoginInformationToFile(name,password);
//4.清空提示信息
this.clearMessage();
//5.登陆进新页面
new StudentAdmin();
//6.关闭当前窗口
this.dispose();
}else{
JOptionPane.showMessageDialog(null,"登陆失败，请查找原因！");
}
}
/**
* 登陆所有基本条件的判断(所有文本域不为空）
*
* @return 均不为空且正确返回结果值true，否则返回false
*/
private boolean booleanLoginMessage(){
if(this.nameIsEmpty()){//姓名符合
//创建对象
User user=new User();
//获取姓名
user.setName(jtf_name.getText());
if(this.passwordIsEmpty()){//密码不为空
//获取密码
user.setPassword(this.getLoginPassword(jpf_password.getPassword()));
if(loginService.queryUser(user)){//用户存在
return true;
}else{
jb_messagePassword.setText("密码不正确！");
return false;
}
}
}
return false;
}
/**
* 用户名判断
* @return 返回的结果字符串：“false”表示不符合，否则符合要求
*/
private boolean nameIsEmpty(){
//1.获取字符串
String name= jtf_name.getText();
//2.判断是否符合条件
if(name != null && name.equals("")==false){
if(loginService.queryUserByName(name)==false){
jb_messageName.setText("");
return true;
}else{
jb_messageName.setText("该用户名不存在！");
this.updateVerifyCode();
return false;
}
}
jb_messageName.setText("用户名不能为空");
this.updateVerifyCode();
return false;
}
/**
* 密码判断是否为空值
* @return 获取结果值，true为真，否则为false
*/
private boolean passwordIsEmpty(){
String password=this.getLoginPassword(jpf_password.getPassword());
//3.判断是否符合条件
if(password != null && password.equals("")==false){
jb_messagePassword.setText("");
return true;
}
jb_messagePassword.setText("密码不能为空！");
this.updateVerifyCode();
return false;
}
/**
* 密码获取
* @return 返回的结果字符串
*/
private String getLoginPassword(char[] chars){
String password="";
if (chars != null) {
for (char aChar : chars) {
password +=aChar;
}
}
return password;
}
/**
* 判断验证码是否符合
* @return 返回的结果字符串：“false”表示不符合，否则符合要求
*/
private boolean codeIsEmpty(){
//1.获取字符串
String code=jtf_verify.getText();
//2.判断是否符合条件
if(code !=null && code.equals("")==false){
if(code.equals(codeStr)){
jb_messageVerify.setText("");
return true;
}else{
jb_messageVerify.setText("验证码输入错误");
this.updateVerifyCode();
return false;
}
}
jb_messageVerify.setText("验证码不能为空");
this.updateVerifyCode();
return false;
}
/**
* 保存登陆状态信息
* @param name 用户名
* @param password 密码
*/
private void saveLoginInformationToFile(String name,String password){
//1.记住用户名
String str=name+",";
//2.判断是否记住密码
if(jcb_remember.isSelected()==true){//记住密码
str += password;//保存密码
}
//3.保存记录信息：仅用户名、用户名和密码两种状态
String[] strings = DataUtils.readLoginMessage();
DataUtils.saveLoginMessage(strings,str);
// //4.判断是否自动登陆
// if(jcb_autoLogin.isSelected()==true){//记住自动登陆状态
// DataUtils.saveAutoLoginMessage("true");
// }else{//不自动登陆
// DataUtils.saveAutoLoginMessage("false");
// }
}
/**
* 成功登录清空提示信息
*/
private void clearMessage(){
jb_messageName.setText("");
jb_messagePassword.setText("");
jb_messageVerify.setText("");
}
}
（3）找回账户和密码界面
package com.study.dialog;
import com.study.bean.User;
import com.study.service.LoginService;
import com.study.utils.MyFont;
import com.study.utils.Regex;
import javax.swing.*;
import java.awt.*;
import java.awt.event.*;
public class FindNameAndPassword extends JDialog implements MouseListener,KeyListener,WindowListener {
//标签
private JLabel jb_header,jb_name,jb_question1, jb_question2, jb_question3,jb_result;
private JLabel jb_messageName,jb_messageQ1,jb_messageQ2,jb_messageQ3;
private JTextField jtf_name,jtf_question1, jtf_question2, jtf_question3;
public JTextField jtf_result;
private JButton bt_submit,bt_cancle;
private String action;
private LoginService loginService;
private JLabel jb_findAccount;
public FindNameAndPassword(String action,JLabel jb_findPassword, LoginService loginService){
this.action=action;
this.jb_findAccount=jb_findPassword;
this.loginService=loginService;
this.initJDialog();
}
private void initComponent(){
//标题
jb_header=new JLabel("请完成如下信息的填写：");
jb_header.setBounds(20,20,260,30);
jb_header.setFont(MyFont.font5);
this.add(jb_header);
//账号部分
if("name".equals(action)){
jb_name=new JLabel("请根据以下问题完成账号的查找");
jb_name.setBounds(50,80,200,30);
} else if ("password".equals(action)) {
jb_name=new JLabel("输入账号：");
jtf_name=new JTextField();
jb_messageName=new JLabel();
jb_name.setBounds(50,80,70,30);
jtf_name.setBounds(120,80,130,30);
jb_messageName.setBounds(110,110,260,30);
this.add(jtf_name);
this.add(jb_messageName);
}
this.add(jb_name);
//问题回答部分
jb_question1=new JLabel("Question1：你就读的小学是哪一所？");
jtf_question1=new JTextField();
jb_messageQ1=new JLabel();
jb_messageQ1.setFont(MyFont.font11);
jb_messageQ1.setForeground(Color.RED);
jb_question1.setBounds(50,140,260,30);
jtf_question1.setBounds(70,170,200,30);
jb_messageQ1.setBounds(275,170,200,30);
jb_question2=new JLabel("Question2：你目前最敬佩的人是谁？");
jtf_question2=new JTextField();
jb_messageQ2=new JLabel();
jb_messageQ2.setFont(MyFont.font11);
jb_messageQ2.setForeground(Color.RED);
jb_question2.setBounds(50,220,260,30);
jtf_question2.setBounds(70,250,200,30);
jb_messageQ2.setBounds(275,250,200,30);
jb_question3=new JLabel("Question3：你目前的人生目标是啥？");
jtf_question3=new JTextField();
jb_messageQ3=new JLabel();
jb_messageQ3.setFont(MyFont.font11);
jb_messageQ3.setForeground(Color.RED);
jb_question3.setBounds(50,300,260,30);
jtf_question3.setBounds(70,330,200,30);
jb_messageQ3.setBounds(275,330,200,30);
this.add(jb_question1);this.add(jb_question2);this.add(jb_question3);
this.add(jtf_question1);this.add(jtf_question2);this.add(jtf_question3);
this.add(jb_messageQ1);this.add(jb_messageQ2);this.add(jb_messageQ3);
//结果及按钮
jb_result=new JLabel("查询结果:");
jtf_result=new JTextField();
jtf_result.setEnabled(false);
jb_result.setBounds(70,380,60,30);
jtf_result.setBounds(130,380,140,30);
this.add(jb_result);this.add(jtf_result);
bt_submit=new JButton("提 交");
bt_cancle=new JButton("取 消");
bt_submit.setBounds(70,430,80,30);
bt_cancle.setBounds(180,430,80,30);
this.add(bt_submit);this.add(bt_cancle);
}
private void addListener(){
if("password".equals(action))
jtf_name.addKeyListener(this);
jtf_question1.addKeyListener(this);
jtf_question2.addKeyListener(this);
jtf_question3.addKeyListener(this);
jtf_question1.addMouseListener(this);
jtf_question2.addMouseListener(this);
jtf_question3.addMouseListener(this);
bt_submit.addMouseListener(this);
bt_cancle.addMouseListener(this);
}
private void initJDialog(){
this.setLayout(null);
this.initComponent();
this.addListener();
if("name".equals(action)) {
this.setTitle("找回账号");
}else if("password".equals(action)) {
this.setTitle("找回密码");
}
this.setSize(360,520);
this.setLocation(300,200);
this.setResizable(false);
this.setDefaultCloseOperation(JDialog.DISPOSE_ON_CLOSE);
this.setVisible(true);
this.addWindowListener(this);
}
@Override
public void keyTyped(KeyEvent e) {
}
@Override
public void keyPressed(KeyEvent e) {
if("password".equals(action)&&e.getSource()==jtf_name&&e.getKeyCode()==KeyEvent.VK_ENTER){
this.jtextFileNameGetFocus();
}else if(e.getSource()==jtf_question1&&e.getKeyCode()==KeyEvent.VK_ENTER){
this.jtextFileQuestion1GetFocus();
}else if(e.getSource()==jtf_question2&&e.getKeyCode()==KeyEvent.VK_ENTER){
this.jtextFileQuestion2GetFocus();
}else if(e.getSource()==jtf_question3&&e.getKeyCode()==KeyEvent.VK_ENTER){
this.jtextFileQuestion3GetFocus();
}
}
@Override
public void keyReleased(KeyEvent e) {
}
/**
* 账号焦点改变执行的方法
*/
private void jtextFileNameGetFocus(){
if(jtf_name.getFocusTraversalKeysEnabled()){
//判断姓名的合法性
if(this.isRequiredName())
jtf_question1.requestFocus();//密码框获取光标
else
jtf_name.requestFocus(true);
}
}
/**
* 第一个问题光标移到到下一处时执行的方法
*/
private void jtextFileQuestion1GetFocus(){
if(jtf_question1.getFocusTraversalKeysEnabled()){
if(this.isRequiredQuestion(jtf_question1,jb_messageQ1))
jtf_question2.requestFocus();//问题2框获取光标
else
jtf_question1.requestFocus(true);
}
}
/**
* 第二个问题光标移到到下一处时执行的方法
*/
private void jtextFileQuestion2GetFocus(){
if(jtf_question2.getFocusTraversalKeysEnabled()){
if(this.isRequiredQuestion(jtf_question2,jb_messageQ2))
jtf_question3.requestFocus();//问题3框获取光标
else
jtf_question2.requestFocus(true);
}
}
/**
* 第三个问题光标移到到下一处时执行的方法
*/
private void jtextFileQuestion3GetFocus(){
if(jtf_question3.getFocusTraversalKeysEnabled()){
if(this.isRequiredQuestion(jtf_question3,jb_messageQ3))
if("name".equals(action))
this.findBackUserName();
else
this.findBackUserPassword();
else
jtf_question3.requestFocus(true);
}
}
/**
* 判断问题答案是否已经输入内容
*
* @return 返回布尔值，true是符合要求的，反之不符合要求
*/
private boolean isRequiredQuestion(JTextField jtf,JLabel jb){
String text =jtf.getText();
if(text !=null && text.equals("")==false){
jb.setText("");
return true;
}else{
jb.setText("请输入内容！");
return false;
}
}
/**
* 判断姓名是否符合要求
*
* @return 返回布尔值，true是符合要求的，反之不符合要求
*/
private boolean isRequiredName(){
String name=jtf_name.getText();
//1.判断用户名不为空
if(name != null && name.equals("")==false){//不为空进行验证
//2.验证输入的合法性
if(Regex.isRequiredName(name)){//输入合法
return true;
}else {
//输入不合法，显示提示信息
jb_messageName.setText("输入不合法，由字母/数字/中文字符组成！");
jb_messageName.setForeground(Color.RED);
}
}else {
//为空显示提示信息
jb_messageName.setText("请输入账号信息！");
jb_messageName.setForeground(Color.RED);
}
return false;
}
@Override
public void mouseClicked(MouseEvent e) {
if("password".equals(action)&&e.getSource()==jtf_question1){
if(this.isRequiredName())
jb_messageName.setText("");
else
jtf_name.requestFocus(true);
}else if(e.getSource()==jtf_question2){
if(this.isRequiredQuestion(jtf_question1,jb_messageQ1))
jb_messageQ1.setText("");
else
jtf_question1.requestFocus(true);
this.jtextFileQuestion1GetFocus();
}else if(e.getSource()==jtf_question3){
if(this.isRequiredQuestion(jtf_question2,jb_messageQ2))
jb_messageQ2.setText("");
else
jtf_question2.requestFocus(true);
this.jtextFileQuestion2GetFocus();
}else if(e.getSource()==bt_submit){
if(this.isRequiredQuestion(jtf_question3,jb_messageQ3)){
jb_messageQ3.setText("");
if("name".equals(action))
this.findBackUserName();
else if("password".equals(action))
this.findBackUserPassword();
}else {
jtf_question3.requestFocus(true);
}
}else if(e.getSource()==bt_cancle){
jb_findAccount.setForeground(Color.BLUE);
jb_findAccount.setEnabled(true);
this.dispose();
}
}
@Override
public void mousePressed(MouseEvent e) {
}
@Override
public void mouseReleased(MouseEvent e) {
}
@Override
public void mouseEntered(MouseEvent e) {
}
@Override
public void mouseExited(MouseEvent e) {
}
/**
* 找回密码信息
*/
private void findBackUserPassword(){
if(this.isRequiredName()&&this.isRequiredQuestion(jtf_question1,jb_messageQ1)&&this.isRequiredQuestion(jtf_question2,jb_messageQ2)&&this.isRequiredQuestion(jtf_question3,jb_messageQ3)){
User user=this.getUserInformation();
User user1 = loginService.queryUserByNameAndThreeQuestion(user);
if (user1 != null) {
JOptionPane.showMessageDialog(null,"恭喜你！成功找回密码！");
jtf_result.setText(user1.getPassword());
}else{
jtf_result.setText("");
JOptionPane.showMessageDialog(null,"未查找到账号，请再尝试！");
}
}
}
/**
* 找回账号信息
*/
private void findBackUserName(){
if(this.isRequiredQuestion(jtf_question1,jb_messageQ1)&&this.isRequiredQuestion(jtf_question2,jb_messageQ2)&&this.isRequiredQuestion(jtf_question3,jb_messageQ3)){
User user=this.getUserInformation();
User user1 = loginService.queryUserByThreeQuestion(user);
if (user1 != null) {
JOptionPane.showMessageDialog(null,"恭喜你！成功找回账号！");
jtf_result.setText(user1.getName());
}else{
jtf_result.setText("");
JOptionPane.showMessageDialog(null,"未查找到账号，请再尝试！");
}
}
}
/**
* 获取封装对象信息
*
* @return 返回user
*/
private User getUserInformation(){
User user=new User();
if("password".equals(action))
user.setName(jtf_name.getText());
user.setQuestion1(jtf_question1.getText());
user.setQuestion2(jtf_question2.getText());
user.setQuestion3(jtf_question3.getText());
return user;
}
@Override
public void windowOpened(WindowEvent e) {
}
@Override
public void windowClosing(WindowEvent e) {
if(e.getSource()==this){
jb_findAccount.setForeground(Color.BLUE);
jb_findAccount.setEnabled(true);
}
}
@Override
public void windowClosed(WindowEvent e) {
}
@Override
public void windowIconified(WindowEvent e) {
}
@Override
public void windowDeiconified(WindowEvent e) {
}
@Override
public void windowActivated(WindowEvent e) {
}
@Override
public void windowDeactivated(WindowEvent e) {
}
}
（4）注册界面
package com.study.dialog;
import com.study.bean.User;
import com.study.service.LoginService;
import com.study.utils.MyFont;
import com.study.utils.Regex;
import javax.swing.*;
import java.awt.*;
import java.awt.event.KeyEvent;
import java.awt.event.KeyListener;
import java.awt.event.MouseEvent;
import java.awt.event.MouseListener;
/**
* 注册界面
*/
public class RegisterDialog extends JDialog implements MouseListener,KeyListener {
//标签：账号、密码、确认密码、找寻账号或密码的三个问题
JLabel jb_name, jb_password, jb_okPassword, jb_question1, jb_question2, jb_question3;
//检测用户名
JLabel jb_checkName;
//查看条款
JLabel jb_lookDetail;
//输入文本域
JTextField jtf_name, jtf_question1, jtf_question2, jtf_question3;
JPasswordField jpf_password, jpf_okPassword;
//信息提示标签
JLabel jb_message,jb_okMessage,jb_messageQ1,jb_messageQ2,jb_messageQ3;
//同意条款确按钮
JRadioButton rbt;
//确认、取消按钮
JButton bt_OK, bt_cancle;
//声明对象
private LoginService loginService;
//声明标签
private JTextField jtf_updateName;
private JPasswordField jtf_updatePassword;
/**
* 有参构造方法
*/
public RegisterDialog(JTextField jtf_updateName,JPasswordField jtf_updatePassword,LoginService loginService) {
this.jtf_updateName=jtf_updateName;
this.jtf_updatePassword=jtf_updatePassword;
this.loginService=loginService;
this.initJDialog();
}
private void initComponent() {
//账号部分
jb_name = new JLabel("账 号：");
jtf_name = new JTextField();
jb_checkName = new JLabel("由字母、数字、中文字符组成");
jb_name.setBounds(50, 20, 80, 30);
jtf_name.setBounds(130, 20, 150, 30);
jb_checkName.setBounds(285, 20, 200, 30);
jb_checkName.setFont(MyFont.font11);
jb_checkName.setForeground(Color.BLUE);
this.add(jb_name);
this.add(jtf_name);
this.add(jb_checkName);
//密码部分
jb_password = new JLabel("密 码：");
jpf_password = new JPasswordField();
jb_message=new JLabel("由字母、数字组成,长度[6,30]");
jb_password.setBounds(50,70,80,30);
jpf_password.setBounds(130,70,150,30);
jb_message.setBounds(285,70,200,30);
jb_message.setFont(MyFont.font11);
jb_message.setForeground(Color.BLUE);
//确认密码部分
jb_okPassword = new JLabel("确认密码：");
jpf_okPassword = new JPasswordField();
jb_okMessage = new JLabel();
//jb_okMessage.setVisible(false);
jb_okPassword.setBounds(50,120,80,30);
jpf_okPassword.setBounds(130,120,150,30);
jb_okMessage.setBounds(285,120,200,30);
jb_okMessage.setFont(MyFont.font11);
jb_okMessage.setForeground(Color.RED);
this.add(jb_password);
this.add(jb_okPassword);
this.add(jpf_password);
this.add(jpf_okPassword);
this.add(jb_message);
this.add(jb_okMessage);
//问题设置部分
jb_question1=new JLabel("Question1：你就读的小学是哪一所？");
jtf_question1=new JTextField();
jb_messageQ1=new JLabel();
jb_messageQ1.setFont(MyFont.font11);
jb_messageQ1.setForeground(Color.RED);
jb_question1.setBounds(50,170,260,30);
jtf_question1.setBounds(70,200,200,30);
jb_messageQ1.setBounds(275,200,200,30);
jb_question2=new JLabel("Question2：你目前最敬佩的人是谁？");
jtf_question2=new JTextField();
jb_messageQ2=new JLabel();
jb_messageQ2.setFont(MyFont.font11);
jb_messageQ2.setForeground(Color.RED);
jb_question2.setBounds(50,250,260,30);
jtf_question2.setBounds(70,280,200,30);
jb_messageQ2.setBounds(275,280,200,30);
jb_question3=new JLabel("Question3：你目前的人生目标是啥？");
jtf_question3=new JTextField();
jb_messageQ3=new JLabel();
jb_messageQ3.setFont(MyFont.font11);
jb_messageQ3.setForeground(Color.RED);
jb_question3.setBounds(50,330,260,30);
jtf_question3.setBounds(70,360,200,30);
jb_messageQ3.setBounds(275,360,200,30);
this.add(jb_question1);this.add(jb_question2);this.add(jb_question3);
this.add(jtf_question1);this.add(jtf_question2);this.add(jtf_question3);
this.add(jb_messageQ1);this.add(jb_messageQ2);this.add(jb_messageQ3);
//确认条款和按钮部分
rbt=new JRadioButton("同意条款注册账号");
jb_lookDetail=new JLabel("<html><u>查看详细条款信息</u></html>");
bt_OK=new JButton("确 定");
bt_cancle=new JButton("取 消");
rbt.setBounds(50,420,150,30);
jb_lookDetail.setBounds(200,420,150,30);
jb_lookDetail.setForeground(Color.BLUE);
bt_OK.setBounds(70,480,80,30);
bt_cancle.setBounds(180,480,80,30);
this.add(rbt);
this.add(jb_lookDetail);
this.add(bt_OK);
this.add(bt_cancle);
}
private void addActionListener(){
jtf_name.addKeyListener(this);
jpf_password.addKeyListener(this);
jpf_okPassword.addKeyListener(this);
jtf_question1.addKeyListener(this);
jtf_question2.addKeyListener(this);
jtf_question3.addKeyListener(this);
jtf_name.addMouseListener(this);
jpf_password.addMouseListener(this);
jpf_okPassword.addMouseListener(this);
jtf_question1.addMouseListener(this);
jtf_question2.addMouseListener(this);
jtf_question3.addMouseListener(this);
jb_lookDetail.addMouseListener(this);
rbt.addMouseListener(this);
bt_OK.addMouseListener(this);
bt_cancle.addMouseListener(this);
}
private void initJDialog(){
this.setLayout(null);
this.initComponent();
this.addActionListener();
this.setTitle("用户注册界面");
this.setSize(500,565);
this.setLocation(300,150);
this.setResizable(false);
this.setDefaultCloseOperation(JDialog.DISPOSE_ON_CLOSE);
this.setVisible(true);
}
@Override
public void keyTyped(KeyEvent e) {
}
@Override
public void keyPressed(KeyEvent e) {
if(e.getSource()==jtf_name && e.getKeyCode()==KeyEvent.VK_ENTER)
this.jtextFileNameGetFocus();
else if(e.getSource()==jpf_password && e.getKeyCode()==KeyEvent.VK_ENTER)
this.jtextFilePasswordGetFocus();
else if(e.getSource()==jpf_okPassword && e.getKeyCode()==KeyEvent.VK_ENTER)
this.jtextFileOkPasswordGetFocus();
else if(e.getSource()==jtf_question1 && e.getKeyCode()==KeyEvent.VK_ENTER)
this.jtextFileQuestion1GetFocus();
else if(e.getSource()==jtf_question2 && e.getKeyCode()==KeyEvent.VK_ENTER)
this.jtextFileQuestion2GetFocus();
else if(e.getSource()==jtf_question3 && e.getKeyCode()==KeyEvent.VK_ENTER)
this.jtextFileQuestion3GetFocus();
}
/**
* 账号焦点改变执行的方法
*/
private void jtextFileNameGetFocus(){
if(jtf_name.getFocusTraversalKeysEnabled()){
//判断姓名的合法性
if(this.isRequiredName())
jpf_password.requestFocus();//密码框获取光标
else
jtf_name.requestFocus(true);
}
}
/**
* 第一次输入密码光标移动到下一处时执行的方法
*/
private void jtextFilePasswordGetFocus(){
if(jpf_password.getFocusTraversalKeysEnabled()){
//判断密码是否符合条件
if(this.isRequiredPassword())
jpf_okPassword.requestFocus();//确认密码框获取光标
}
}
/**
* 第二次输入密码光标移动到下一处时执行的方法
*/
private void jtextFileOkPasswordGetFocus(){
if(jpf_okPassword.getFocusTraversalKeysEnabled()){
if(this.isRequiredOkPassword())
jtf_question1.requestFocus();//问题1框获取光标
}
}
/**
* 第一个问题光标移到到下一处时执行的方法
*/
private void jtextFileQuestion1GetFocus(){
if(jtf_question1.getFocusTraversalKeysEnabled()){
if(this.isRequiredQuestion(jtf_question1,jb_messageQ1))
jtf_question2.requestFocus();//问题2框获取光标
else
jtf_question1.requestFocus(true);
}
}
/**
* 第二个问题光标移到到下一处时执行的方法
*/
private void jtextFileQuestion2GetFocus(){
if(jtf_question2.getFocusTraversalKeysEnabled()){
if(this.isRequiredQuestion(jtf_question2,jb_messageQ2))
jtf_question3.requestFocus();//问题3框获取光标
else
jtf_question2.requestFocus(true);
}
}
/**
* 第三个问题光标移到到下一处时执行的方法
*/
private void jtextFileQuestion3GetFocus(){
if(jtf_question3.getFocusTraversalKeysEnabled()){
if(this.isRequiredQuestion(jtf_question3,jb_messageQ3))
if(rbt.isSelected()==true)
this.registerUser();
else
JOptionPane.showMessageDialog(null,"请先同意条款","提示消息",1);
else
jtf_question3.requestFocus(true);
}
}
@Override
public void keyReleased(KeyEvent e) {
}
@Override
public void mouseClicked(MouseEvent e) {
if(e.getSource()==rbt) {
if(this.isRequiredQuestion(jtf_question3,jb_messageQ3)==false)
jtf_question3.requestFocus(true);
}else if(e.getSource()==jb_lookDetail) {
new DetailDialog();
}else if(e.getSource()==bt_OK ) {
if(rbt.isSelected()==true)
this.registerUser();
else
JOptionPane.showMessageDialog(null,"同意条款方可注册！");
}else if(e.getSource()==bt_cancle) {
this.dispose();//退出注册界面
}else if(e.getSource()==jpf_password) {
if(this.isRequiredName()==false)
jtf_name.requestFocus(true);
}else if(e.getSource()==jpf_okPassword) {
if(this.isRequiredPassword()==false)
jpf_password.requestFocus(true);
}else if(e.getSource()==jtf_question1) {
if(this.isRequiredOkPassword()==false)
jpf_okPassword.requestFocus(true);
}else if(e.getSource()==jtf_question2) {
if(this.isRequiredQuestion(jtf_question1,jb_messageQ1)==false)
jtf_question1.requestFocus(true);
}else if(e.getSource()==jtf_question3) {
if(this.isRequiredQuestion(jtf_question2,jb_messageQ2)==false)
jtf_question2.requestFocus(true);
}
}
@Override
public void mousePressed(MouseEvent e) {
}
@Override
public void mouseReleased(MouseEvent e) {
}
@Override
public void mouseEntered(MouseEvent e) {
}
@Override
public void mouseExited(MouseEvent e) {
}
/**
* 进入注册方法，正式注册信息
*/
private void registerUser(){
//全部符合要求，正式注册
if(this.booleanRegisterCondition()){
String name=jtf_name.getText();
String password=this.getStringFromPasswordFile(jpf_password.getPassword());
User user=new User();
user.setName(name);
user.setPassword(password);
user.setQuestion1(jtf_question1.getText());
user.setQuestion2(jtf_question2.getText());
user.setQuestion3(jtf_question3.getText());
if(loginService.insertUser(user)) {
this.updateLoginMessage(name,password);
JOptionPane.showMessageDialog(null, "注册成功！");
}else {
JOptionPane.showMessageDialog(null, "注册失败！");
}
}else{
JOptionPane.showMessageDialog(null,"有错误，请检查！");
}
}
/**
* 判断所有输入的结果
* @return 全部符合要求返回true，否则返回false
*/
private boolean booleanRegisterCondition(){
if(this.isRequiredName()&&this.isRequiredPassword()&&this.isRequiredOkPassword()&&this.isRequiredQuestion(jtf_question1,jb_messageQ1)&&this.isRequiredQuestion(jtf_question2,jb_messageQ2)&&this.isRequiredQuestion(jtf_question3,jb_messageQ3))
return true;
return false;
}
/**
* 判断姓名是否符合要求
*
* @return 返回布尔值，true是符合要求的，反之不符合要求
*/
private boolean isRequiredName(){
String name=jtf_name.getText();
//1.判断用户名不为空
if(name != null && name.equals("")==false){//不为空进行验证
//2.验证输入的合法性
if(Regex.isRequiredName(name)){//输入合法
//3.查询是否重名
if(loginService.queryUserByName(name)) {//不重名
jb_checkName.setText("由字母、数字、中文字符组成");
jb_checkName.setForeground(Color.BLUE);
return true;
}else {
//重名显示提示信息，结束执行
jb_checkName.setText("该账号已经存在，请重新输入！");
jb_checkName.setForeground(Color.RED);
}
}else {
//输入不合法，显示提示信息
jb_checkName.setText("输入不合法，只能由字母、数字、中文字符组成！");
jb_checkName.setForeground(Color.RED);
}
}else {
//为空显示提示信息
jb_checkName.setText("请输入账号信息！");
jb_checkName.setForeground(Color.RED);
}
return false;
}
/**
* 判断密码输入是否符合条件
* @return
*/
private boolean isRequiredPassword(){
char[] password = jpf_password.getPassword();
String passwordStr=this.getStringFromPasswordFile(password);
if(passwordStr !=null && passwordStr.equals("")==false){
if(Regex.isRequiredPassword(passwordStr)){
jb_message.setText("由字母、数字组成,长度[6,30]");
jb_message.setForeground(Color.BLUE);
return true;
}else{
jb_message.setText("输入不合法!");
jb_message.setForeground(Color.RED);
return false;
}
}else{
jb_message.setText("密码不能为空");
jb_message.setForeground(Color.RED);
return false;
}
}
/**
* 将密码字符数组转成字符串形式
*
* @param password 密码
* @return 返回字符串
*/
private String getStringFromPasswordFile(char[] password){
String str="";
if (password != null) {
for (char c : password) {
str +=c;
}
}
return str;
}
/**
* 判断确认密码是否符合要求
*
* @return 返回布尔值，true是符合要求的，反之不符合要求
*/
private boolean isRequiredOkPassword(){
if(this.isRequiredPassword()){
char[] password = jpf_okPassword.getPassword();
String passwordStr=this.getStringFromPasswordFile(password);
if(passwordStr !=null && passwordStr.equals("")==false){
if(Regex.isRequiredPassword(passwordStr)){
String passwordStr1=this.getStringFromPasswordFile(jpf_password.getPassword());
if(passwordStr.equals(passwordStr1)){
jb_okMessage.setText("");
return true;
}else{
jb_okMessage.setText("前后两次输入密码不相符！");
return false;
}
}else{
jb_okMessage.setText("确认密码输入不合法！");
return false;
}
}else{
jb_okMessage.setText("确认密码不能为空");
return false;
}
}else{
jb_okMessage.setText("前后两次输入密码不相符！");
return false;
}
}
/**
* 判断问题答案是否已经输入内容
*
* @return 返回布尔值，true是符合要求的，反之不符合要求
*/
private boolean isRequiredQuestion(JTextField jtf,JLabel jb){
String text =jtf.getText();
if(text !=null && text.equals("")==false){
jb.setText("");
return true;
}else{
jb.setText("问题答案不能为空！");
return false;
}
}
/**
* 更新登陆信息
* @param name 用户名
* @param password 密码
*/
public void updateLoginMessage(String name,String password){
jtf_updateName.setText(name);
jtf_updatePassword.setText(password);
}
}
2.学生管理系统界面的设计与代码实现（部分）
（1）整体设计
package com.study.myPage;
import com.study.myTable.MyJTable;
import com.study.myTable.MyTable;
import com.study.myTable.MyTablePopupMenu;
import com.study.service.StudentSevice;
import javax.swing.*;
import java.awt.*;
import java.awt.event.*;
public class StudentAdmin extends JFrame implements MouseListener{
private JSplitPane bottomJSp;
private JPanel leftPanel;
private CalendarPanel calendarPanel;
private TimePanel timePanel;
private MenuPanel menuPanel;
private JSplitPane studentJSp;
private JScrollPane jScrollPane;
private MyJTable jTable;
private JPanel tablePanel,tableBottomPanel;
private StudentSevice studentSevice=new StudentSevice();
public StudentAdmin(){
this.initJFrame();
}
/**
* 左边的日历和时钟显示
*/
private void initLeftPanel(){
leftPanel=new JPanel();
leftPanel.setLayout(new BorderLayout());
calendarPanel=new CalendarPanel();
timePanel=new TimePanel();
leftPanel.add(calendarPanel,BorderLayout.CENTER);
leftPanel.add(timePanel,BorderLayout.SOUTH);
}
/**
* 右边上部分内容
*/
private void initStudentPanel(){
menuPanel=new MenuPanel(studentSevice,jTable);
}
/**
* 右边下部分内容
*/
private void initTablePanel(){
tablePanel=new JPanel();
tablePanel.setLayout(new BorderLayout());
MyTable myTable=new MyTable(studentSevice);
jTable=new MyJTable(myTable);
jScrollPane=new JScrollPane(jTable);
jScrollPane.setSize(tablePanel.getWidth(),tablePanel.getHeight()-120);
tableBottomPanel=new JPanel();
tableBottomPanel.setSize(tablePanel.getWidth(),60);
JLabel label=new JLabel("原创作者：语程峰");
tableBottomPanel.add(label);
tablePanel.add(jScrollPane);
tablePanel.add(tableBottomPanel,BorderLayout.SOUTH);
}
/**
* 上下界面
*/
private void initStudentJSplitPane(){
studentJSp=new JSplitPane(JSplitPane.VERTICAL_SPLIT,menuPanel,tablePanel);
studentJSp.setDividerLocation(280);
}
/**
* 左右界面
*/
private void initBottomJSplitPane(){
bottomJSp=new JSplitPane(JSplitPane.HORIZONTAL_SPLIT,leftPanel,studentJSp);
bottomJSp.setDividerLocation(300);
}
private void addListener(){
jTable.addMouseListener(this);
}
/**
* 初始化界面
*/
private void initJFrame(){
this.initLeftPanel();
this.initTablePanel();
this.initStudentPanel();
this.initStudentJSplitPane();
this.initBottomJSplitPane();
this.add(bottomJSp);
this.addListener();
this.setTitle("学生管理系统操作界面");
this.setSize(1200,1000);
this.setLocation(200,50);
this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
this.setVisible(true);
}
@Override
public void mouseClicked(MouseEvent e) {
if(e.getSource()==jTable&&e.getButton()==MouseEvent.BUTTON3){
MyTablePopupMenu myTablePopupMenu = new MyTablePopupMenu(jTable);
myTablePopupMenu.show(e.getComponent(),e.getX(),e.getY());
}
}
@Override
public void mousePressed(MouseEvent e) {
}
@Override
public void mouseReleased(MouseEvent e) {
}
@Override
public void mouseEntered(MouseEvent e) {
}
@Override
public void mouseExited(MouseEvent e) {
}
}
（2）各个界面
package com.study.myPage;
import com.study.utils.MyFont;
import javax.swing.*;
import java.awt.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.util.Calendar;
import java.util.Date;
public class CalendarPanel extends JPanel implements ActionListener {
private JComboBox jcbb_year,jcbb_month;
private JLabel jb_year,jb_month;
private JTextArea textarea;
private JButton bt_carry;
private JLabel jb_time;
private Timer timer;
private String[] yearArr,monthArr;
private Date date=new Date();
private int indexYear=date.getYear();
private int indexMonth=date.getMonth();
private int year,month;
public CalendarPanel(){
this.initArrays();
this.initComponent();
this.addListener();
}
private void initArrays() {
yearArr=new String[201];
for(int i=0;i<201;i++){
yearArr[i]=i+1900+"";
}
monthArr=new String[12];
for(int i=0;i<12;i++){
monthArr[i]=i+1+"";
}
}
private void initComponent(){
this.setLayout(null);
jcbb_year=new JComboBox(yearArr);
jcbb_year.setSelectedIndex(indexYear);
year=Integer.parseInt((String)jcbb_year.getSelectedItem());
jb_year=new JLabel("年");
jcbb_year.setBounds(20,100,60,25);
jb_year.setBounds(85,100,20,25);
jcbb_month=new JComboBox(monthArr);
jcbb_month.setSelectedIndex(indexMonth);
month=Integer.parseInt((String)jcbb_month.getSelectedItem());
jb_month=new JLabel("月");
jcbb_month.setBounds(115,100,40,25);
jb_month.setBounds(160,100,20,25);
bt_carry=new JButton("查询");
bt_carry.setBounds(200,100,60,25);
textarea=new JTextArea();
textarea.setBounds(20,140,250,230);
textarea.setEditable(false);
textarea.setBackground(Color.LIGHT_GRAY);
textarea.setForeground(Color.BLUE);
this.getCalendar();
timer=new Timer(1000,this);
timer.start();
jb_time=new JLabel("当前时间："+Calendar.getInstance().getTime().toLocaleString());
jb_time.setBounds(20,375,250,40);
jb_time.setForeground(Color.BLUE);
jb_time.setFont(MyFont.font9);
this.add(jb_time);
this.add(jcbb_month);
this.add(jcbb_year);
this.add(jb_month);
this.add(jb_year);
this.add(bt_carry);
this.add(textarea);
}
private void addListener(){
jcbb_year.addActionListener(this);
jcbb_month.addActionListener(this);
bt_carry.addActionListener(this);
}
@Override
public void actionPerformed(ActionEvent e) {
jb_time.setText("当前时间："+Calendar.getInstance().getTime().toLocaleString());
if(e.getSource()==jcbb_year||e.getSource()==jcbb_month||e.getSource()==bt_carry){
this.carryUpdateCalendar();
}
}
private void carryUpdateCalendar(){
year=Integer.parseInt((String)jcbb_year.getSelectedItem());
month=Integer.parseInt((String)jcbb_month.getSelectedItem());
this.getCalendar();
}
private void getCalendar() {
//1.获取1900年到指定年份的总天数
int days=0;
for(int i=1900;i<year;i++){
if(this.isIntercalation(i))
days += 366;
else
days +=365;
}
//2.获取到指定月数的前一个月的总天数
for(int i=1;i<month;i++) {
if (i == 4 || i == 6 || i == 9 || i == 11) {
days += 30;
} else if (i == 2) {
if(this.isIntercalation(year))
days +=29;
else
days +=28;
} else {
days += 31;
}
}
//3.获取当月的天数
int day=0;
if (month == 4 || month == 6 || month == 9 || month == 11) {
day = 30;
} else if (month == 2) {
if(this.isIntercalation(year))
day =29;
else
day =28;
} else {
day = 31;
}
//4.获取查询月第一天是星期几（1900年1月1日是星期一）：对7取模，余数就是对应的星期，0对应星期日
int weekday=(days+1)%7;
String[] str={"日","一","二","三","四","五","六"};
String content=String.format("%7s","");
for (int i = 0; i < str.length; i++) {
if(i>=2 && i<4){
content +=String.format("%s",str[i])+String.format("%7s","");
}else{
content +=String.format("%s",str[i])+String.format("%8s","");
}
}
content +="\n\n"+String.format("%7s", "");
//5.打印星期几之前的空格：空格数是weekday
for(int i=0;i<weekday;i++){
content +=String.format("%4s", "")+String.format("%7s", "");
}
//6.打印月日历
for(int i=1;i<=day;i++){
if((i+weekday) %7==0){
if(i<10)
content +=String.format("%4s", i)+String.format("%7s", "")+"\n\n"+String.format("%7s", "");
else
content +=String.format("%2s", i)+String.format("%7s", " ")+"\n\n"+String.format("%6s", "");
}else{
if(i<10)
content +=String.format("%3s", i)+String.format("%7s", "");
else
content +=String.format("%2s", i)+String.format("%7s", "");
}
}
textarea.setText(content);
}
/**
* 闰年判断：普通闰年是能被4整除，同时不能被100整除；世纪闰年是能被400整除
*
* @param year 年份
* @return 返回布尔值，true是闰年，false是平年
*/
private boolean isIntercalation(int year){
if (year % 4 == 0 && year % 100 != 0 || year % 400 == 0)
return true;
else
return false;
}
}
package com.study.myPage;
import com.study.bean.Student;
import com.study.myTable.MyJTable;
import com.study.myTable.MyTable;
import com.study.service.StudentSevice;
import com.study.utils.DataTxtAndExcel;
import com.study.utils.ModelUtils;
import com.study.utils.Regex;
import javax.swing.*;
import java.awt.event.KeyEvent;
import java.awt.event.KeyListener;
import java.awt.event.MouseEvent;
import java.awt.event.MouseListener;
import java.util.ArrayList;
public class MenuPanel extends JPanel implements MouseListener, KeyListener {
private JRadioButton rbt_query, rbt_queryAll, rbt_insert, rbt_update, rbt_deleteOne, rbt_deleteAll;
private ButtonGroup bg;
private JLabel jb_id, jb_name, jb_age, jb_separator1, jb_rank, jb_separator2, jb_gender, jb_subject, jb_score, jb_separator3, jb_sum, jb_separator4;
private JTextField jtf_id, jtf_name, jtf_age1, jtf_age2, jtf_rank1, jtf_rank2, jtf_gender, jtf_subject, jtf_score1, jtf_score2, jtf_sum1, jtf_sum2;
private JButton bt_clear, bt_query;
private JRadioButton rbt_header;
private JButton bt_readTxt,bt_saveTxt,bt_readTable,bt_saveTable;
private StudentSevice studentSevice;
private MyJTable jTable;
private DataTxtAndExcel dataTxt=new DataTxtAndExcel();
public MenuPanel() {
this.initComponent();
}
public MenuPanel(StudentSevice studentSevice,MyJTable jTable){
this.studentSevice=studentSevice;
this.jTable=jTable;
this.initComponent();
}
/**
* 所有组件进行初始化
*/
private void initComponent(){
this.setLayout(null);
this.initJRadioButton();
this.initQueryComponent();
this.initButton();
this.addListener();
}
private void initJRadioButton() {
rbt_queryAll = new JRadioButton("查询全部");
rbt_insert = new JRadioButton("添加");
rbt_update = new JRadioButton("修改");
rbt_deleteOne = new JRadioButton("选择删除");
rbt_deleteAll = new JRadioButton("删除全部");
rbt_query = new JRadioButton("条件查询");
rbt_queryAll.setBounds(50, 20, 80, 30);
rbt_insert.setBounds(160, 20, 80, 30);
rbt_update.setBounds(270, 20, 80, 30);
rbt_deleteOne.setBounds(380, 20, 80, 30);
rbt_deleteAll.setBounds(490, 20, 80, 30);
rbt_query.setBounds(50, 60, 80, 30);
bg = new ButtonGroup();
bg.add(rbt_queryAll);
bg.add(rbt_insert);
bg.add(rbt_update);
bg.add(rbt_deleteAll);
bg.add(rbt_deleteOne);
bg.add(rbt_query);
this.add(rbt_queryAll);
this.add(rbt_insert);
this.add(rbt_update);
this.add(rbt_deleteAll);
this.add(rbt_deleteOne);
this.add(rbt_query);
rbt_header=new JRadioButton("其它操作");
bg.add(rbt_header);
rbt_header.setBounds(50,180,80,30);
bt_readTxt=new JButton("文本导入");
bt_saveTxt=new JButton("导入文本");
bt_readTxt.setBounds(50,220,90,30);
bt_saveTxt.setBounds(160,220,90,30);
bt_readTable=new JButton("表格导入");
bt_saveTable=new JButton("导入表格");
bt_readTable.setBounds(280,220,90,30);
bt_saveTable.setBounds(390,220,90,30);
this.add(rbt_header);this.add(bt_readTxt);this.add(bt_saveTxt);
this.add(bt_readTable);this.add(bt_saveTable);
}
private void initQueryComponent() {
//学号
jb_id = new JLabel("学号：");
jtf_id = new JTextField();
jb_id.setBounds(50, 100, 40, 30);
jtf_id.setBounds(90, 105, 100, 25);
this.add(jb_id);
this.add(jtf_id);
//姓名
jb_name = new JLabel("姓名：");
jtf_name = new JTextField();
jb_name.setBounds(210, 100, 40, 30);
jtf_name.setBounds(250, 105, 100, 25);
this.add(jb_name);
this.add(jtf_name);
//年龄
jb_age = new JLabel("年龄：");
jtf_age1 = new JTextField();
jb_separator1 = new JLabel("--");
jtf_age2 = new JTextField();
jb_age.setBounds(370, 100, 40, 30);
jtf_age1.setBounds(410, 105, 40, 25);
jb_separator1.setBounds(450, 105, 10, 25);
jtf_age2.setBounds(460, 105, 40, 25);
this.add(jb_age);
this.add(jtf_age1);
this.add(jb_separator1);
this.add(jtf_age2);
//性别
jb_gender = new JLabel("性别：");
jtf_gender = new JTextField();
jb_gender.setBounds(520, 100, 40, 30);
jtf_gender.setBounds(560, 105, 100, 25);
this.add(jb_gender);
this.add(jtf_gender);
//科目
jb_subject = new JLabel("科目：");
jtf_subject = new JTextField();
jb_subject.setBounds(50, 140, 40, 30);
jtf_subject.setBounds(90, 145, 100, 25);
this.add(jb_subject);
this.add(jtf_subject);
jb_score = new JLabel("分数：");
jtf_score1 = new JTextField();
jb_separator2 = new JLabel("--");
jtf_score2 = new JTextField();
jb_score.setBounds(210, 140, 40, 30);
jtf_score1.setBounds(250, 145, 40, 25);
jb_separator2.setBounds(290, 145, 10, 25);
jtf_score2.setBounds(300, 145, 40, 25);
this.add(jb_score);
this.add(jtf_score1);
this.add(jb_separator2);
this.add(jtf_score2);
//总分
jb_sum = new JLabel("总分：");
jtf_sum1 = new JTextField();
jb_separator3 = new JLabel("--");
jtf_sum2 = new JTextField();
jb_sum.setBounds(370, 140, 40, 30);
jtf_sum1.setBounds(410, 145, 40, 25);
jb_separator3.setBounds(450, 145, 10, 25);
jtf_sum2.setBounds(460, 145, 40, 25);
this.add(jb_sum);
this.add(jtf_sum1);
this.add(jb_separator3);
this.add(jtf_sum2);
//排名
jb_rank = new JLabel("名次：");
jtf_rank1 = new JTextField();
jb_separator4 = new JLabel("--");
jtf_rank2 = new JTextField();
jb_rank.setBounds(520, 140, 40, 30);
jtf_rank1.setBounds(560, 145, 40, 25);
jb_separator4.setBounds(600, 145, 10, 25);
jtf_rank2.setBounds(610, 145, 40, 25);
this.add(jb_rank);
this.add(jtf_rank1);
this.add(jb_separator4);
this.add(jtf_rank2);
}
private void initButton() {
bt_clear = new JButton("清空条件");
bt_query = new JButton("点击查询");
bt_clear.setBounds(680, 100, 90, 30);
bt_query.setBounds(680, 140, 90, 30);
this.add(bt_clear);
this.add(bt_query);
}
private void addListener() {
//1.文本框监听
jtf_id.addKeyListener(this);
jtf_name.addKeyListener(this);
jtf_age1.addKeyListener(this);
jtf_age2.addKeyListener(this);
jtf_rank1.addKeyListener(this);
jtf_rank2.addKeyListener(this);
jtf_gender.addKeyListener(this);
jtf_subject.addKeyListener(this);
jtf_score1.addKeyListener(this);
jtf_score2.addKeyListener(this);
jtf_sum1.addKeyListener(this);
jtf_sum2.addKeyListener(this);
//2.按钮监听
rbt_queryAll.addMouseListener(this);
rbt_insert.addMouseListener(this);
rbt_update.addMouseListener(this);
rbt_deleteOne.addMouseListener(this);
rbt_deleteAll.addMouseListener(this);
bt_query.addMouseListener(this);
bt_clear.addMouseListener(this);
bt_readTxt.addMouseListener(this);
bt_saveTxt.addMouseListener(this);
bt_readTable.addMouseListener(this);
bt_saveTable.addMouseListener(this);
}
/**
* 清空所有文本域
*/
private void clearContentAllJTextField() {
jtf_id.setText("");
jtf_name.setText("");
jtf_age1.setText("");
jtf_age2.setText("");
jtf_rank1.setText("");
jtf_rank2.setText("");
jtf_gender.setText("");
jtf_subject.setText("");
jtf_score1.setText("");
jtf_score2.setText("");
jtf_sum1.setText("");
jtf_sum2.setText("");
}
@Override
public void keyTyped(KeyEvent e) {
}
@Override
public void keyPressed(KeyEvent e) {
if(e.getSource()==jtf_id && e.getKeyCode()==KeyEvent.VK_ENTER){
if(jtf_id.getFocusTraversalKeysEnabled())
jtf_name.requestFocus(true);
}else if(e.getSource()==jtf_name && e.getKeyCode()==KeyEvent.VK_ENTER){
if(jtf_name.getFocusTraversalKeysEnabled())
jtf_age1.requestFocus(true);
}else if(e.getSource()==jtf_age1 && e.getKeyCode()==KeyEvent.VK_ENTER){
if(jtf_age1.getFocusTraversalKeysEnabled())
jtf_age2.requestFocus(true);
}else if(e.getSource()==jtf_age2 && e.getKeyCode()==KeyEvent.VK_ENTER){
if(jtf_age2.getFocusTraversalKeysEnabled())
jtf_gender.requestFocus(true);
}else if(e.getSource()==jtf_gender && e.getKeyCode()==KeyEvent.VK_ENTER){
if(jtf_gender.getFocusTraversalKeysEnabled())
jtf_subject.requestFocus(true);
}else if(e.getSource()==jtf_subject && e.getKeyCode()==KeyEvent.VK_ENTER){
if(jtf_subject.getFocusTraversalKeysEnabled())
jtf_score1.requestFocus(true);
}else if(e.getSource()==jtf_score1 && e.getKeyCode()==KeyEvent.VK_ENTER){
if(jtf_score1.getFocusTraversalKeysEnabled())
jtf_score2.requestFocus(true);
}else if(e.getSource()==jtf_score2 && e.getKeyCode()==KeyEvent.VK_ENTER){
if(jtf_score2.getFocusTraversalKeysEnabled())
jtf_sum1.requestFocus(true);
}else if(e.getSource()==jtf_sum1 && e.getKeyCode()==KeyEvent.VK_ENTER){
if(jtf_sum1.getFocusTraversalKeysEnabled())
jtf_sum2.requestFocus(true);
}else if(e.getSource()==jtf_sum2 && e.getKeyCode()==KeyEvent.VK_ENTER){
if(jtf_sum2.getFocusTraversalKeysEnabled())
jtf_rank1.requestFocus(true);
}else if(e.getSource()==jtf_rank1 && e.getKeyCode()==KeyEvent.VK_ENTER){
if(jtf_rank1.getFocusTraversalKeysEnabled())
jtf_rank2.requestFocus(true);
}else if(e.getSource()==jtf_rank2 && e.getKeyCode()==KeyEvent.VK_ENTER){
if(jtf_rank2.getFocusTraversalKeysEnabled())
this.queryStudentInformationByCondition();
}
}
@Override
public void keyReleased(KeyEvent e) {
}
@Override
public void mouseClicked(MouseEvent e) {
if(e.getSource()==bt_clear){
this.clearContentAllJTextField();
}else if(e.getSource()==bt_query){//条件查询
this.queryStudentInformationByCondition();
}else if(e.getSource()==rbt_queryAll){//查询全部
ModelUtils.queryAllStudentsInformation(studentSevice,jTable);
}else if(e.getSource()==rbt_insert){//添加
new InsertAndUpdate("insert",studentSevice,jTable);
}else if(e.getSource()==rbt_update){//修改
this.updateStudentById();
}else if(e.getSource()==rbt_deleteOne){//删除
this.deleteStudentById();
}else if(e.getSource()==rbt_deleteAll){
studentSevice.deleteAllStudentsInformation();
ModelUtils.queryAllStudentsInformation(studentSevice,jTable);
}else if(e.getSource()==bt_readTxt){//导入文本文档
ArrayList<Student> students = dataTxt.readFromTxt();
MyTable myTable = new MyTable(students);
jTable.setModel(myTable);
}else if(e.getSource()==bt_saveTxt){
ArrayList<Student> students = studentSevice.queryAllStudentsInformation();
dataTxt.writeToTxt(students);
}else if(e.getSource()==bt_readTable){
ArrayList<Student> students = dataTxt.readFromExcel();
MyTable myTable = new MyTable(students);
jTable.setModel(myTable);
}else if(e.getSource()==bt_saveTable){
dataTxt.writeToExcel(jTable);
}
}
@Override
public void mousePressed(MouseEvent e) {
}
@Override
public void mouseReleased(MouseEvent e) {
}
@Override
public void mouseEntered(MouseEvent e) {
}
@Override
public void mouseExited(MouseEvent e) {
}
/**
* 修改学生列表
*/
private void updateStudentById(){
int row=jTable.getSelectedRow();
if(row==-1){
JOptionPane.showMessageDialog(null,"请选中要修改的行再执行该命令");
return;
}else {
long id= (Long) jTable.getValueAt(row,0);
Student student=studentSevice.queryStudentById(id);
if (student != null) {
new InsertAndUpdate("update",studentSevice,jTable,student);
}else{
JOptionPane.showMessageDialog(null,"无效选择，系统没有该学生的信息！");
}
}
}
/**
* 根据ID删除学生
*/
private void deleteStudentById(){
int[] rows = jTable.getSelectedRows();
if(rows ==null){
JOptionPane.showMessageDialog(null,"请选中要删除的行再执行该命令");
return;
}else {
Long[] id = new Long[rows.length];
for (int i = 0; i < rows.length; i++) {
id[i] = (Long) jTable.getValueAt(rows[i], 0);
}
boolean result = studentSevice.deleteStudentByIds(id);
ModelUtils.queryAllStudentsInformation(studentSevice, jTable);
if (result == false) {
JOptionPane.showMessageDialog(null, "删除失败！");
}
}
}
/**
* 条件查询学生
*/
private void queryStudentInformationByCondition(){
//1.创建两个数组，分别存储名称和值
String[] name=new String[11];
String[] value=new String[11];
//2.判断学号，将结果添加到数组中
this.dealStudentStuID(name,value);
//3.判断姓名
this.dealStudentStuName(name,value);
//4.判断性别
this.dealStudentStuGender(name,value);
//5.判断年龄
this.dealStudentStuAge(name,value);
//6.判断科目成绩
this.dealStudentSubjectScore(name,value);
//7.判断总分
this.dealStudentScoreSum(name,value);
//8.判断排名
this.dealStudentRank(name,value);
//9.调用方法执行
ArrayList<Student> students=studentSevice.queryStudentInformationByCondition(name, value);
if (students != null) {
MyTable myTable = new MyTable(students);
jTable.setModel(myTable);
}else {
JOptionPane.showMessageDialog(null,"没有查询到任何信息");
}
}
/**
* 判断查询条件之学号
* @param name 属性名数组
* @param value 属性值数组
*/
private void dealStudentStuID(String[] name, String[] value) {
String text = jtf_id.getText();
if(Regex.isRequiredStuID(text)){
name[0]="stu_ID";
value[0]=text;
}else{
name[0]=null;
value[0]=null;
}
}
/**
* 判断查询条件之姓名
* @param name 属性名数组
* @param value 属性值数组
*/
private void dealStudentStuName(String[] name, String[] value) {
String text = jtf_name.getText();
if(Regex.isRequiredStuName(text)){
name[1]="stu_name";
value[1]=text;
}else{
name[1]=null;
value[1]=null;
}
}
/**
* 判断查询条件之性别
* @param name 属性名数组
* @param value 属性值数组
*/
private void dealStudentStuGender(String[] name, String[] value) {
String text = jtf_gender.getText();
if(Regex.isRequiredStuGender(text)){
name[2]="stu_gender";
value[2]=text;
}else{
name[2]=null;
value[2]=null;
}
}
/**
* 判断查询条件之年龄
* @param name 属性名数组
* @param value 属性值数组
*/
private void dealStudentStuAge(String[] name, String[] value) {
String text1 = jtf_age1.getText();
String text2 = jtf_age2.getText();
if(Regex.isRequiredStuAge(text1)){
name[3]="stu_age";
value[3]=text1;
}else{
name[3]=null;
value[3]=null;
}
if(Regex.isRequiredStuAge(text2)){
name[4]="stu_age";
value[4]=text2;
}else{
name[4]=null;
value[4]=null;
}
}
/**
* 判断查询条件之科目的分数
* @param name 属性名数组
* @param value 属性值数组
*/
private void dealStudentSubjectScore(String[] name, String[] value) {
String text1 = jtf_score1.getText();
String text2 = jtf_score2.getText();
String text = jtf_subject.getText();
text=text.toLowerCase();
if(text.equals("java")||text.equals("python")||text.equals("computer")){
if(Regex.isRequiredStuScore(text1)){
name[5]=text;
value[5]=text1;
}else{
name[5]=null;
value[5]=null;
}
if(Regex.isRequiredStuScore(text2)){
name[6]=text;
value[6]=text2;
}else{
name[6]=null;
value[6]=null;
}
}
}
/**
* 判断查询条件之总分
* @param name 属性名数组
* @param value 属性值数组
*/
private void dealStudentScoreSum(String[] name, String[] value) {
String text1 = jtf_sum1.getText();
String text2 = jtf_sum2.getText();
if(Regex.isRequiredInteger(text1)){
name[7]="scoreSum";
value[7]=text1;
}else{
name[7]=null;
value[7]=null;
}
if(Regex.isRequiredInteger(text2)){
name[8]="scoreSum";
value[8]=text2;
}else{
name[8]=null;
value[8]=null;
}
}
/**
* 判断查询条件之名次
* @param name 属性名数组
* @param value 属性值数组
*/
private void dealStudentRank(String[] name, String[] value) {
String text1 = jtf_rank1.getText();
String text2 = jtf_rank2.getText();
if(Regex.isRequiredRank(text1)){
name[9]="ranking";
value[9]=text1;
}else{
name[9]=null;
value[9]=null;
}
if(Regex.isRequiredRank(text2)){
name[10]="ranking";
value[10]=text2;
}else{
name[10]=null;
value[10]=null;
}
}
}
==================================================================================================================================================================================
crud菜单操作界面
package com.study.myPage;
import com.study.bean.Student;
import com.study.myTable.MyJTable;
import com.study.service.StudentSevice;
import com.study.utils.ModelUtils;
import com.study.utils.MyFont;
import com.study.utils.Regex;
import javax.swing.*;
import java.awt.*;
import java.awt.event.KeyEvent;
import java.awt.event.KeyListener;
import java.awt.event.MouseEvent;
import java.awt.event.MouseListener;
import java.math.BigDecimal;
import java.text.DecimalFormat;
public class InsertAndUpdate extends JDialog implements MouseListener, KeyListener {
private JLabel jb_stuID, jb_stuName, jb_stuGender, jb_stuAge, jb_java, jb_python, jb_computer;
private JLabel jb_stuID1, jb_stuName1, jb_stuGender1, jb_stuAge1, jb_java1, jb_python1, jb_computer1;
private JTextField jtf_stuID, jtf_stuName, jtf_stuGender, jtf_stuAge, jtf_java, jtf_python, jtf_computer;
private JButton bt_submit, bt_cancle, bt_clear;
private String action;
private StudentSevice studentSevice;
private MyJTable jTable;
private Student updateStudent;
public InsertAndUpdate(String action, StudentSevice studentSevice, MyJTable jTable) {
this.action = action;
this.studentSevice = studentSevice;
this.jTable = jTable;
this.initDialog();
}
public InsertAndUpdate(String action, StudentSevice studentSevice, MyJTable jTable, Student student) {
this.action = action;
this.studentSevice = studentSevice;
this.jTable = jTable;
this.updateStudent = student;
this.initDialog();
}
public void initComponent() {
this.setLayout(null);
jb_stuID = new JLabel("学 号：");
if ("update".equals(action)) {
jtf_stuID = new JTextField(updateStudent.getStu_ID());
jtf_stuID.setEditable(false);
} else if ("insert".equals(action)) {
jtf_stuID = new JTextField();
}
jb_stuID.setBounds(50, 30, 80, 30);
jtf_stuID.setBounds(125, 30, 100, 30);
jb_stuName = new JLabel("姓 名：");
if ("update".equals(action)) {
jtf_stuName = new JTextField(updateStudent.getStu_name());
} else if ("insert".equals(action)) {
jtf_stuName = new JTextField();
}
jb_stuName.setBounds(50, 80, 80, 30);
jtf_stuName.setBounds(125, 80, 100, 30);
jb_stuGender = new JLabel("性 别：");
if ("update".equals(action)) {
jtf_stuGender = new JTextField(updateStudent.getStu_gender());
} else if ("insert".equals(action)) {
jtf_stuGender = new JTextField();
}
jb_stuGender.setBounds(50, 130, 80, 30);
jtf_stuGender.setBounds(125, 130, 100, 30);
jb_stuAge = new JLabel("年 龄：");
if ("update".equals(action)) {
jtf_stuAge = new JTextField(updateStudent.getStu_age()+"");
} else if ("insert".equals(action)) {
jtf_stuAge = new JTextField();
}
jb_stuAge.setBounds(50, 180, 80, 30);
jtf_stuAge.setBounds(125, 180, 100, 30);
jb_java = new JLabel("java：");
if ("update".equals(action)) {
jtf_java = new JTextField(updateStudent.getJava()+"");
} else if ("insert".equals(action)) {
jtf_java = new JTextField();
}
jb_java.setBounds(50, 230, 80, 30);
jtf_java.setBounds(125, 230, 100, 30);
jb_python = new JLabel("Python：");
if ("update".equals(action)) {
jtf_python = new JTextField(updateStudent.getPython()+"");
} else if ("insert".equals(action)) {
jtf_python = new JTextField();
}
jb_python.setBounds(50, 280, 80, 30);
jtf_python.setBounds(125, 280, 100, 30);
jb_computer = new JLabel("computer：");
if ("update".equals(action)) {
jtf_computer = new JTextField(updateStudent.getComputer()+"");
} else if ("insert".equals(action)) {
jtf_computer = new JTextField();
}
jb_computer.setBounds(50, 330, 80, 30);
jtf_computer.setBounds(125, 330, 100, 30);
this.add(jb_stuID);
this.add(jtf_stuID);
this.add(jb_stuName);
this.add(jtf_stuName);
this.add(jb_stuGender);
this.add(jtf_stuGender);
this.add(jb_stuAge);
this.add(jtf_stuAge);
this.add(jb_java);
this.add(jtf_java);
this.add(jb_python);
this.add(jtf_python);
this.add(jb_computer);
this.add(jtf_computer);
//信息提示部门
if ("insert".equals(action)) {
jb_stuID1 = new JLabel("学号以2021开头，后接6位任意数字");
jb_stuID1.setFont(MyFont.font9);
jb_stuID1.setForeground(Color.BLUE);
jb_stuID1.setBounds(225, 30, 260, 30);
this.add(jb_stuID1);
}
jb_stuName1 = new JLabel("只能是中文，长度[2,5]");
jb_stuName1.setFont(MyFont.font9);
jb_stuName1.setForeground(Color.BLUE);
jb_stuName1.setBounds(225, 80, 200, 30);
this.add(jb_stuName1);
jb_stuGender1 = new JLabel("仅可以输入男或女");
jb_stuGender1.setFont(MyFont.font9);
jb_stuGender1.setForeground(Color.BLUE);
jb_stuGender1.setBounds(225, 130, 200, 30);
this.add(jb_stuGender1);
jb_stuAge1 = new JLabel("年龄范围：[3-60]整数");
jb_stuAge1.setFont(MyFont.font9);
jb_stuAge1.setForeground(Color.BLUE);
jb_stuAge1.setBounds(225, 180, 200, 30);
this.add(jb_stuAge1);
jb_java1 = new JLabel("分数范围：[0-100]整数");
jb_java1.setFont(MyFont.font9);
jb_java1.setForeground(Color.BLUE);
jb_java1.setBounds(225, 230, 200, 30);
this.add(jb_java1);
jb_python1 = new JLabel("分数范围：[0-100]整数");
jb_python1.setFont(MyFont.font9);
jb_python1.setForeground(Color.BLUE);
jb_python1.setBounds(225, 280, 200, 30);
this.add(jb_python1);
jb_computer1 = new JLabel("分数范围：[0-100]整数");
jb_computer1.setFont(MyFont.font9);
jb_computer1.setForeground(Color.BLUE);
jb_computer1.setBounds(225, 330, 200, 30);
this.add(jb_computer1);
bt_submit = new JButton("提交");
bt_clear = new JButton("清空");
bt_cancle = new JButton("取消");
bt_submit.setBounds(80, 390, 60, 30);
bt_cancle.setBounds(190, 390, 60, 30);
bt_clear.setBounds(300, 390, 60, 30);
this.add(bt_submit);
this.add(bt_cancle);
this.add(bt_clear);
}
private void addListener() {
//鼠标监听
jtf_stuName.addMouseListener(this);
jtf_stuGender.addMouseListener(this);
jtf_stuAge.addMouseListener(this);
jtf_java.addMouseListener(this);
jtf_python.addMouseListener(this);
jtf_computer.addMouseListener(this);
bt_submit.addMouseListener(this);
bt_cancle.addMouseListener(this);
bt_clear.addMouseListener(this);
//键盘监听
if ("insert".equals(action))
jtf_stuID.addKeyListener(this);
jtf_stuName.addKeyListener(this);
jtf_stuGender.addKeyListener(this);
jtf_stuAge.addKeyListener(this);
jtf_java.addKeyListener(this);
jtf_python.addKeyListener(this);
jtf_computer.addKeyListener(this);
}
private void initDialog() {
this.initComponent();
this.addListener();
if ("update".equals(action))
this.setTitle("修改学生界面");
else if ("insert".equals(action))
this.setTitle("添加学生界面");
this.setSize(500, 500);
this.setResizable(false);
this.setDefaultCloseOperation(DISPOSE_ON_CLOSE);
this.setVisible(true);
}
/**
* 判断学号是否符合要求
*
* @return 返回布尔值，true符合，false不符合
*/
private boolean isRequiredStuID() {
String stuId = jtf_stuID.getText();
if (stuId != null && stuId.equals("") == false) {
if (Regex.isRequiredStuID(stuId)) {
if (studentSevice.queryStudentByStuID(stuId)) {
jb_stuID1.setText("学号以2021开头，后接6位任意数字");
jb_stuID1.setForeground(Color.BLUE);
return true;
} else {
jb_stuID1.setText("该学号已经存在，要求学号唯一性！");
}
} else {
jb_stuID1.setText("输入的学号不符合要求！");
}
} else {
jb_stuID1.setText("内容不能为空");
}
jb_stuID1.setForeground(Color.RED);
return false;
}
/**
* 判断名字是否符合要求
*
* @return 返回布尔值，true符合，false不符合
*/
private boolean isRequiredName() {
String stuName = jtf_stuName.getText();
if (stuName != null && stuName.equals("") == false) {
if (Regex.isRequiredStuName(stuName)) {
jb_stuName1.setText("只能是中文，长度[2,5]");
jb_stuName1.setForeground(Color.BLUE);
return true;
} else {
jb_stuName1.setText("输入的姓名不符合要求！");
}
} else {
jb_stuName1.setText("内容不能为空");
}
jb_stuName1.setForeground(Color.RED);
return false;
}
/**
* 判断性别输入是否符合要求
*
* @return 返回布尔值，true符合，false不符合
*/
private boolean isRequiredGender() {
String stuGender = jtf_stuGender.getText();
if (stuGender != null && stuGender.equals("") == false) {
if (Regex.isRequiredStuGender(stuGender)) {
jb_stuGender1.setText("仅可以输入男或女");
jb_stuGender1.setForeground(Color.BLUE);
return true;
} else {
jb_stuGender1.setText("输入的性别不符合要求！");
}
} else {
jb_stuGender1.setText("内容不能为空");
}
jb_stuGender1.setForeground(Color.RED);
return false;
}
/**
* 判断性别输入是否符合要求
*
* @return 返回布尔值，true符合，false不符合
*/
private boolean isRequiredAge() {
String stuAge = jtf_stuAge.getText();
if (stuAge != null && stuAge.equals("") == false) {
if (Regex.isRequiredStuAge(stuAge)) {
jb_stuAge1.setText("年龄范围：[3-60]整数");
jb_stuAge1.setForeground(Color.BLUE);
return true;
} else {
jb_stuAge1.setText("输入的年龄不符合要求！");
}
} else {
jb_stuAge1.setText("内容不能为空");
}
jb_stuAge1.setForeground(Color.RED);
return false;
}
/**
* 判断年龄输入是否符合要求
*
* @return 返回布尔值，true符合，false不符合
*/
private boolean isRequiredScore(JTextField jtf, JLabel jb) {
String inStr = jtf.getText();
if (inStr != null && inStr.equals("") == false) {
if (Regex.isRequiredStuScore(inStr)) {
jb.setText("分数范围：[0-100]整数");
jb.setForeground(Color.BLUE);
return true;
} else {
jb.setText("输入的分数不符合要求！");
}
} else {
jb.setText("内容不能为空");
}
jb.setForeground(Color.RED);
return false;
}
/**
* 判断是否是所有条件都满足
*
* @return 返回布尔值，true均满足，false不满足
*/
private boolean isAllRequiredConditon() {
boolean requiredName = this.isRequiredName();
boolean requiredGender = this.isRequiredGender();
boolean requiredAge = this.isRequiredAge();
boolean requiredScoreJava = this.isRequiredScore(jtf_java, jb_java1);
boolean requiredScorePython = this.isRequiredScore(jtf_python, jb_python1);
boolean requiredScoreComputer = this.isRequiredScore(jtf_computer, jb_computer1);
if (requiredName && requiredGender && requiredAge && requiredScoreJava && requiredScorePython && requiredScoreComputer){
if("insert".equals(action)){
if(this.isRequiredStuID())
return true;
}else{
return true;
}
}
return false;
}
/**
* 添加学生
*/
private void insertStudent() {
if (this.isAllRequiredConditon()) {
Student student = this.getInsertStudent();
boolean insert = studentSevice.insertStudent(student);
if (insert) {
JOptionPane.showMessageDialog(null, "添加成功！");
ModelUtils.queryAllStudentsInformation(studentSevice, jTable);
} else {
JOptionPane.showMessageDialog(null, "添加失败！");
}
} else {
JOptionPane.showMessageDialog(null, "有错误，请检查！");
}
}
/**
* 修改学生的信息
*/
private void updateStudent() {
if (this.isAllRequiredConditon()) {
Student student = this.getUpdateStudent();
boolean update = studentSevice.updateStudent(student);
if (update) {
JOptionPane.showMessageDialog(null, "修改成功！");
ModelUtils.queryAllStudentsInformation(studentSevice, jTable);
} else {
JOptionPane.showMessageDialog(null, "修改失败！");
}
} else {
JOptionPane.showMessageDialog(null, "有错误，请检查！");
}
}
@Override
public void keyTyped(KeyEvent e) {
}
@Override
public void keyPressed(KeyEvent e) {
if ("insert".equals(action)&&e.getSource() == jtf_stuID && e.getKeyCode() == KeyEvent.VK_ENTER) {
if (jtf_stuID.getFocusTraversalKeysEnabled())
if (this.isRequiredStuID())
jtf_stuName.requestFocus(true);
else
jtf_stuID.requestFocus(true);
} else if (e.getSource() == jtf_stuName && e.getKeyCode() == KeyEvent.VK_ENTER) {
if (jtf_stuName.getFocusTraversalKeysEnabled())
if (this.isRequiredName())
jtf_stuGender.requestFocus(true);
else
jtf_stuName.requestFocus(true);
} else if (e.getSource() == jtf_stuGender && e.getKeyCode() == KeyEvent.VK_ENTER) {
if (jtf_stuGender.getFocusTraversalKeysEnabled())
if (this.isRequiredGender())
jtf_stuAge.requestFocus(true);
else
jtf_stuGender.requestFocus(true);
} else if (e.getSource() == jtf_stuAge && e.getKeyCode() == KeyEvent.VK_ENTER) {
if (jtf_stuAge.getFocusTraversalKeysEnabled())
if (this.isRequiredAge())
jtf_java.requestFocus(true);
else
jtf_stuAge.requestFocus(true);
} else if (e.getSource() == jtf_java && e.getKeyCode() == KeyEvent.VK_ENTER) {
if (jtf_java.getFocusTraversalKeysEnabled())
if (this.isRequiredScore(jtf_java, jb_java1))
jtf_python.requestFocus(true);
else
jtf_java.requestFocus(true);
} else if (e.getSource() == jtf_python && e.getKeyCode() == KeyEvent.VK_ENTER) {
if (jtf_python.getFocusTraversalKeysEnabled())
if (this.isRequiredScore(jtf_python, jb_python1))
jtf_computer.requestFocus(true);
else
jtf_python.requestFocus(true);
} else if (e.getSource() == jtf_computer && e.getKeyCode() == KeyEvent.VK_ENTER) {
if (jtf_computer.getFocusTraversalKeysEnabled())
this.carrySubmit();
}
}
/**
* 执行提交操作
*/
private void carrySubmit() {
if (this.isRequiredScore(jtf_computer, jb_computer1)) {
if ("update".equals(action)) {
this.updateStudent();
} else if ("insert".equals(action)) {
this.insertStudent();
}
} else {
jtf_computer.requestFocus(true);
}
}
@Override
public void keyReleased(KeyEvent e) {
}
@Override
public void mouseClicked(MouseEvent e) {
if (e.getSource() == bt_submit) {
this.carrySubmit();
} else if (e.getSource() == bt_cancle) {
this.dispose();
} else if (e.getSource() == jtf_stuName) {
if ("insert".equals(action)&&this.isRequiredStuID() == false)
jtf_stuID.requestFocus(true);
} else if (e.getSource() == jtf_stuGender) {
if (this.isRequiredName() == false)
jtf_stuName.requestFocus(true);
} else if (e.getSource() == jtf_stuAge) {
if (this.isRequiredGender() == false)
jtf_stuGender.requestFocus(true);
} else if (e.getSource() == jtf_java) {
if (this.isRequiredAge() == false)
jtf_stuAge.requestFocus(true);
} else if (e.getSource() == jtf_python) {
if (this.isRequiredScore(jtf_java, jb_java1) == false)
jtf_java.requestFocus(true);
} else if (e.getSource() == jtf_computer) {
if (this.isRequiredScore(jtf_python, jb_python1) == false)
jtf_python.requestFocus(true);
} else if (e.getSource() == bt_clear) {
this.clearAllJTextField();
}
}
private void clearAllJTextField() {
if ("insert".equals(action))
jtf_stuID.setText("");
jtf_stuName.setText("");
jtf_stuGender.setText("");
jtf_stuAge.setText("");
jtf_java.setText("");
jtf_python.setText("");
jtf_computer.setText("");
}
@Override
public void mousePressed(MouseEvent e) {
}
@Override
public void mouseReleased(MouseEvent e) {
}
@Override
public void mouseEntered(MouseEvent e) {
}
@Override
public void mouseExited(MouseEvent e) {
}
private Student getInsertStudent() {
Student student = new Student();
student.setStu_ID(jtf_stuID.getText());
student.setStu_name(jtf_stuName.getText());
student.setStu_gender(jtf_stuGender.getText());
student.setStu_age(Integer.parseInt(jtf_stuAge.getText()));
int java = Integer.parseInt(jtf_java.getText());
int python = Integer.parseInt(jtf_python.getText());
int computer = Integer.parseInt(jtf_computer.getText());
student.setJava(java);
student.setPython(python);
student.setComputer(computer);
int sum = java + python + computer;
student.setScoreSum(sum);
student.setScoreAvg(this.getStudentScoreAvg(sum));
return student;
}
private Student getUpdateStudent()
{
updateStudent.setStu_name(jtf_stuName.getText());
updateStudent.setStu_gender(jtf_stuGender.getText());
updateStudent.setStu_age(Integer.parseInt(jtf_stuAge.getText()));
int java = Integer.parseInt(jtf_java.getText());
int python = Integer.parseInt(jtf_python.getText());
int computer = Integer.parseInt(jtf_computer.getText());
updateStudent.setJava(java);
updateStudent.setPython(python);
updateStudent.setComputer(computer);
int sum=java+python+computer;
updateStudent.setScoreSum(sum);
updateStudent.setScoreAvg(this.getStudentScoreAvg(sum));
return updateStudent;
}
private BigDecimal getStudentScoreAvg(Integer sum) {
DecimalFormat df=new DecimalFormat("0.00");
String format = df.format(new BigDecimal(sum*1.0/3));
return new BigDecimal(format);
}
}
==================================================================================================================================================================================
表格模型界面
package com.study.myTable;
import com.study.bean.Student;
import com.study.service.StudentSevice;
import com.study.utils.ModelUtils;
import com.study.utils.Regex;
import javax.swing.event.TableModelEvent;
import javax.swing.event.TableModelListener;
import javax.swing.table.AbstractTableModel;
import java.math.BigDecimal;
import java.text.DecimalFormat;
import java.util.ArrayList;
public class MyTable extends AbstractTableModel implements TableModelListener {
private StudentSevice studentSevice;
public ArrayList list=new ArrayList<>();
public ArrayList<String> header=new ArrayList<>();
/**
* 获取列名
*/
{
//1.初始化列名
header.add("序号");
header.add("学号");
header.add("姓名");
header.add("性别");
header.add("年龄");
header.add("java");
header.add("Python");
header.add("computer");
header.add("总分");
header.add("平均分");
header.add("名次");
}
/**
* 获取行数
*
* @return 返回总行数
*/
@Override
public int getRowCount() {
return list.size();
}
/**
* 获取列数
*
* @return 返回总列数
*/
@Override
public int getColumnCount() {
return header.size();
}
/**
* 获取列名
*
* @param column 列号
* @return 得到列名
*/
@Override
public String getColumnName(int column) {
return this.header.get(column);
}
/**
* 获取单元格的值
*
* @param rowIndex 行号
* @param columnIndex 列号
* @return 得到对应单元格的具体值
*/
@Override
public Object getValueAt(int rowIndex, int columnIndex) {
return ((ArrayList)list.get(rowIndex)).get(columnIndex);
}
/**
* 更新单元格的值
*
* @param newValue 修改的新值
* @param rowIndex 行号
* @param columnIndex 列号
*/
@Override
public void setValueAt(Object newValue, int rowIndex, int columnIndex) {
((ArrayList)this.list.get(rowIndex)).set(columnIndex,newValue);
fireTableCellUpdated(rowIndex,columnIndex);
}
public MyTable(StudentSevice studentSevice){
this.studentSevice=studentSevice;
this.queryAllStudentsInformation();
this.addTableModelListener(this);
}
public MyTable(ArrayList<Student> students){
this.initArrayListContent(students);
this.addTableModelListener(this);
}
/**
* 将信息添加到集合中用于显示
*
* @param students 对象的信息集合
*/
private void initArrayListContent(ArrayList<Student> students){
if (students != null) {
for (Student student : students) {
ArrayList list1=new ArrayList();
list1.add(student.getId());
list1.add(student.getStu_ID());
list1.add(student.getStu_name());
list1.add(student.getStu_gender());
list1.add(student.getStu_age());
list1.add(student.getJava());
list1.add(student.getPython());
list1.add(student.getComputer());
list1.add(student.getScoreSum());
list1.add(student.getScoreAvg());
list1.add(student.getRanking());
list.add(list1);
}
}
}
/**
* 查询全部并显示所有信息
*/
private void queryAllStudentsInformation(){
ArrayList<Student> students = studentSevice.queryAllStudentsInformation();
this.initArrayListContent(students);
}
/**
* 表格监听，实现各种功能操作
*
* @param e
*/
@Override
public void tableChanged(TableModelEvent e) {
int firstRow = e.getFirstRow();
int lastRow=e.getLastRow();
int column=e.getColumn();
/**
* 事件的类型值有：
* TableModelEvent.INSERT;
* TableModelEvent.UPDATE;
* TableModelEvent.DELETE;
*/
int type=e.getType();
if(type==TableModelEvent.UPDATE) {
String inStr=String.valueOf(this.getValueAt(firstRow,column));
if(column >4 && column<8){
if(Regex.isRequiredStuScore(inStr)){
// 获取单元格的值，同时获取其附近的其它值
String value1=String.valueOf(this.getValueAt(firstRow,5));
String value2=String.valueOf(this.getValueAt(firstRow,6));
String value3=String.valueOf(this.getValueAt(firstRow,7));
Student student=new Student();
student.setJava(Integer.parseInt(value1));
student.setPython(Integer.parseInt(value2));
student.setComputer(Integer.parseInt(value3));
// 总分、平均分更新
int sum=student.getJava()+student.getPython()+student.getComputer();
BigDecimal avg = new BigDecimal((sum * 1.0) / 3);
DecimalFormat df=new DecimalFormat("0.00");
BigDecimal format = new BigDecimal(df.format(avg));
student.setScoreSum(sum);
student.setScoreAvg(format);
student.setId(Long.parseLong(String.valueOf(this.getValueAt(firstRow,0))));
// 表格值更新
this.setValueAt(sum,firstRow,8);
this.setValueAt(format,firstRow,9);
// 更新数据表
studentSevice.updateStudentScore(student);
// 名次更新
ArrayList<Student> students = studentSevice.queryAllStudentsInformationOrderBySumDesc();
ModelUtils.updateStudentsRanking(students,studentSevice);
students = studentSevice.queryAllStudentsInformation();
if (students != null) {
for (int i = 0; i < students.size(); i++) {
this.setValueAt(students.get(i).getRanking(),i,10);
}
}
}
}
System.out.println("执行了？");
}else if(type==TableModelEvent.DELETE){
System.out.println("删除啦");
}else if(type==TableModelEvent.INSERT){
System.out.println("添加啦");
}
}
}
4868
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
