Java是面向过程的（这也是我喜欢Java的一个原因），相对于Python，Java显得十分繁琐，且很多地方明明可以简化，确搞得特别复杂，但从另一个角度来说Java显得更加严谨。
在管理系统的领域中，我觉得Java在个体单页时会显得特别的臃肿繁琐，许许多多很难解决的地方，不像Python，Python在数据量大时个体单页才显得无力，所以Java中的管理系统要是搭配上数据库，那工作量与各大小问题会少很多。
话不多说开始我们今天的学生管理系统:
思维模式：这里用到的是面向对象，首先先写出每个方法，再进行逐个排版实例化，去实现我们需要一个系统（我很喜欢Java的这个写法）
首先输入咱需要用到的模块：
package kaohe;
import java.util.Scanner;我们的数据存放与初始数据类：
class students{
String yiz = "懿子";
String guiz = "贵子";
String YIZI = "yizi" ;
String xingbie = "男" ;
String xingbien = "女" ;
int yizsheng = 190;
int yizti = 130;
int guizsheng = 130;
int guizti = 190;
int YIZIsheng = 190;
int YIZIti = 191;
}
class studentc{
String yuwen = "语文";
String shux = "数学";
String yingyu = "英语";
int yizyw,yizsx,yizyyi;
int guizyw,guizsx,guizyyi;
int YIZIyw,YIZIsx,YIZIyyi;
int yy = 99;
int ys = 98;
int yyi = 97;
int gy = 96;
int gs = 95;
int gyi = 94;
int YY = 93;
int YS = 94;
int YYI = 93;
}我们的导语类，因为里面用到了数据类students 的数据，所以我们的导语类是需要继承students：
class daoyu extends students{
public void kaishi(){
System.out.println("欢迎进入学生管理系统");
}
public void ssheng(){
System.out.println("在校学生有"+yiz+guiz+YIZI);
}
public void zsheng(){
System.out.println("请输入您需要的操作1.查询学生身体状况 2.学生成绩");
}
public void dqcj(){
System.out.println("当前学生的成绩为：");
}
public void esheng(){
System.out.println("成绩修改输入继续修改 退出系统输入ESC");
}
public void xsheng(){
System.out.println("1.插入成绩 2.查询成绩");
}
public void tx(){
System.out.println("请输入需要插入同学名字：");
}
public void km(){
System.out.println("请输入需要插入的科目");
}
public void cr(){
System.out.println("请输入需要插入的分数");
}
}写一个学生身体状况的类，因为它需要用到students里的数据，所以要继承它：
class studentst extends students{
public void yizz(){
int yizz = yizsheng / yizti ;
System.out.println(yiz+"同学 性别："+xingbien+"身高："+yizsheng+"体重："+yizti+"健康状况:"+yizz);
}
public void guizz(){
int guizz = guizsheng / guizti ;
System.out.println(guiz+"同学 性别："+xingbie+"身高："+guizsheng+"体重："+guizti+"健康状况:"+guizz);
}
public void YIZIz(){
int YIZIz = YIZIsheng / YIZIti ;
System.out.println(YIZI+"同学 性别："+xingbien+"身高："+YIZIsheng+"体重："+YIZIti+"健康状况:"+YIZIz);
}
}实现其中一个同学的方法：
class yizc extends studentc{
public void yw(){
Scanner in = new Scanner(System.in);
int yw = in.nextInt();
yizyw = yy - yy + yw;
this.yy = yizyw;
System.out.println("插入了懿子的语文成绩："+yizyw+"分");
}
public void sx(){
Scanner in = new Scanner(System.in);
int yw = in.nextInt();
yizsx = ys - ys + yw;
System.out.println("插入了懿子的数学成绩："+yizsx+"分");
this.ys = yizsx;
}
public void yyi(){
Scanner in = new Scanner(System.in);
int yw = in.nextInt();
yizyyi = yyi - yyi + yw;
System.out.println("插入了懿子的英语成绩："+yizyyi+"分");
this.yyi = yizyyi;
}
public void ycj(){
System.out.println("懿子的成绩为 语文："+this.yy+"数学："+this.ys+"英语："+this.yyi);
}
}有了这条基础，可以试试实现另外两个
1
2
3
4
5
另外两个：
class guizf extends yizc{
public void yw(){
Scanner in = new Scanner(System.in);
int yw = in.nextInt();
guizyw = gy - gy + yw;
System.out.println("插入了贵子的语文成绩："+guizyw+"分");
this.gy = guizyw;
}
public void sx(){
Scanner in = new Scanner(System.in);
int yw = in.nextInt();
guizsx = gs - gs + yw;
System.out.println("插入了贵子的数学成绩："+guizsx+"分");
this.gs = guizsx;
}
public void yyi(){
Scanner in = new Scanner(System.in);
int yw = in.nextInt();
guizyyi = gyi - gyi + yw;
System.out.println("插入了贵子的英语成绩："+guizyyi+"分");
this.gyi = guizyyi;
}
public void gcj(){
System.out.println("贵子的成绩为 语文："+this.gy+"数学："+this.gs+"英语："+this.gyi);
}
}
class YIZIZ extends guizf{
public void yw(){
Scanner in = new Scanner(System.in);
int yw = in.nextInt();
YIZIyw = YY - YY + yw;
System.out.println("插入了yizi的语文成绩："+YIZIyw+"分");
this.YY = YIZIyw;
}
public void sx(){
Scanner in = new Scanner(System.in);
int yw = in.nextInt();
YIZIsx = YS - YS + yw;
System.out.println("插入了yizi的数学成绩："+YIZIsx+"分");
this.YS = YIZIsx;
}
public void yyi(){
Scanner in = new Scanner(System.in);
int yw = in.nextInt();
YIZIyyi = YYI - YYI + yw;
System.out.println("插入了yizi的英语成绩："+YIZIyyi+"分");
this.YYI = YIZIyyi;
}
public void Ycj(){
System.out.println("YIZI的成绩为 语文："+this.YY+"数学："+this.YS+"英语："+this.YYI);
}
}这里有个问题，为什么guizf是继承yizc，而YIZIZ是继承guizf呢？
哪个类的方法是最多的呢？ 答案是YIZIZ
要知道我们在Java中继承是什么关系，继承就像继承家产，父类将他所有的东西给了子类，子类就拥有父类有的方法，但父类不拥有子类有的方法。
所以以此类推 YIZIZ拥有前面所有类的方法，这也是解决Java中不能继承多个父类的一个好方法。
初始成绩类：
class dcj extends studentc{
public void dycj(){
System.out.println("懿子的成绩为 语文："+yy+"数学："+ys+"英语："+yyi);
}
public void dgcj(){
System.out.println("贵子的成绩为 语文："+gy+"数学："+gs+"英语："+gyi);
}
public void dYcj(){
System.out.println("yizi的成绩为 语文："+YY+"数学："+YS+"英语："+YYI);
}
}每个需要用到的方法我们已经实现了，现在我们要将它们实例化，展现给别人看。
在面向对象中实例化中才能看出一个写码的逻辑思维
按照这个思维，我们逐个实例化各个方法：
public static void main(String[] ARGE){
String i;
daoyu dy = new daoyu();
studentst st = new studentst();
yizc yc = new yizc();
guizf gf = new guizf();
YIZIZ yz = new YIZIZ();
dcj dj = new dcj();
dy.kaishi();
dy.ssheng();
dy.zsheng();
Scanner in = new Scanner(System.in);
String shur = in.next();
switch (shur){
case "查询学生身体状况":
st.yizz();
st.guizz();
st.YIZIz();
break;
case "学生成绩":
dy.dqcj();
dj.dycj();
dj.dgcj();
dj.dYcj();
while (true){
dy.esheng();
Scanner sc = new Scanner(System.in);
i = sc.nextLine();
if(i.equals("ESC")){
System.out.println("退出系统");
break;
}
else {
dy.xsheng();
String P = in.next();
switch (P){
case "插入成绩":
dy.tx();
String e = in.next();
switch (e){
case "懿子":
dy.km();
String w = in.next();
switch (w){
case "语文":
dy.cr();
yc.yw();
break;
case "数学":
dy.cr();
yc.sx();
break;
case "英语":
dy.cr();
yc.yyi();
break;
}
break;
case "贵子":
dy.km();
String r = in.next();
switch (r){
case "语文":
dy.cr();
gf.yw();
break;
case "数学":
dy.cr();
gf.sx();
break;
case "英语":
dy.cr();
gf.yyi();
break;
}
break;
case "yizi":
dy.km();
String a = in.next();
switch (a){
case "语文":
dy.cr();
yz.yw();
break;
case "数学":
dy.cr();
yz.sx();
break;
case "英语":
dy.cr();
yz.yyi();
break;
}
}
break;
case "查询成绩":
yc.ycj();
gf.gcj();
yz.Ycj();
break;
}
}
}
}
}这里我们用到的是switch方法，将它们逐个实现
好啦，Java学生管理系统就大功告成了，这个有很多不完善的地方，需要用到数据库来弥补缺陷，所以后续会更新。
本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。
