本文是大二时期所写，在我的博客上发布，现在在语雀上再次整理一下，我的博客地址：用JAVA写一个学生管理系统

1.知识铺垫：(非常非常基础的知识)

1.1我们先创建一个Student类

  1. public class  Student {
  2.     //属性私有是为了保护数据安全
  3.     private int sno;
  4.     private String name;
  5.     private int age;
  6.     private String gender;
  7.     private int score;
  8. }

1.2然后我们再建立一个HelloStudent的类

  1. public class HelloStudent {
  2.     public static void main(String[] args) {
  3. //        根据类创建对象(创建一个叫studentXM的学生对象)
  4.         Student studentXm=new Student();
  5. //        当我们Student中private int sno写出public int sno的时候，我们才能通过studentXm.sno属性来使用
  6.         studentXm.sno=100;
  8.     }
  9. }

2.1我们在Student类中加入Geter() and Seter()方法,使我们用方法来访问这些私有属性

  1. //创建getName()和setName()方法，使我们用方法来访问这些私有属性
  2.     public String getName() {
  3.         return name;
  4.     }
  6.     public void setName(String name) {
  7.         this.name = name;
  8.     }
  10.     public int getAge() {
  11.         return age;
  12.     }
  14.     public void setAge(int age) {
  15.         this.age = age;
  16.     }
  18.     public String getGender() {
  19.         return gender;
  20.     }
  22.     public void setGender(String gender) {
  23.         this.gender = gender;
  24.     }
  26.     public int getSno() {
  27.         return sno;
  28.     }
  30.     public void setSno(int sno) {
  31.         this.sno = sno;
  32.     }
  34.     public int getScore() {
  35.         return score;
  36.     }
  38.     public void setScore(int score) {
  39.         this.score = score;
  40.     }

2.2在HelloStudent的类中,我们就可以通过方法的方式对私有属性的访问

  1. //我们这是通过方法的方式对私有属性的访问
  2.      studentXm.setSno(100);
  3.      System.out.print(studentXm.getSno());

3.1在Students类中设置toString 方法，使可以直接使用对象

  1. //设置toString 方法，使可以直接使用对象
  2.     @Override
  3.     public String toString() {
  4.         return "Student{" +
  5.                 "name='" + name + '\'' +
  6.                 ", age=" + age +
  7.                 ", gender='" + gender + '\'' +
  8.                 ", sno=" + sno +
  9.                 ", score=" + score +
  10.                 '}';
  11.     }
  1. //toString()底层代码如下
  2. public String toString() {
  3.  return getClass().getName() + "@" + Integer.toHexString(hashCode());
  4. }

3.2在HelloStudent的类中

  1. //        我们使用了toString方法，可以直接输出studentXm这个对象
  2.         studentXm.setSno(100);
  3.         studentXm.setName("小明");
  4.         System.out.print(studentXm);

2.写学生管理系统

1.Student类如下

  1. public class Student {
  2. //    属性私有是为了数据安全
  3.     private String name;
  4.     private int age;
  5.     private String gender;
  6.     private int sno;
  7.     private int score;
  9.     /**
  10.      * 构造器
  11.      * 使用有参构造器之前必须生成一个无参构造器
  12.      * @param
  13.      */
  15.     public Student() {
  17.     }
  19. //    public Student(String name, int age, String gender, int sno, int score) {
  20.     public Student(int sno,String name,int age,String gender,int score){
  21.         this.sno=sno;
  22.         this.name=name;
  23.         this.age=age;
  24.         this.gender=gender;
  25.         this.score=score;
  26.     }
  28.     public Student(String name, int sno, int score) {
  29.         this.name = name;
  30.         this.sno = sno;
  31.         this.score = score;
  32.     }
  34.     //设置toString 方法，使可以直接使用对象
  35.     @Override
  36.     public String toString() {
  37.         return "Student{" +
  38.                 "name='" + name + '\'' +
  39.                 ", age=" + age +
  40.                 ", gender='" + gender + '\'' +
  41.                 ", sno=" + sno +
  42.                 ", score=" + score +
  43.                 '}';
  44.     }
  47.     //创建getName()和setName()方法，使我们用方法来访问这些私有属性
  48.     public String getName() {
  49.         return name;
  50.     }
  52.     public void setName(String name) {
  53.         this.name = name;
  54.     }
  56.     public int getAge() {
  57.         return age;
  58.     }
  60.     public void setAge(int age) {
  61.         this.age = age;
  62.     }
  64.     public String getGender() {
  65.         return gender;
  66.     }
  68.     public void setGender(String gender) {
  69.         this.gender = gender;
  70.     }
  72.     public int getSno() {
  73.         return sno;
  74.     }
  76.     public void setSno(int sno) {
  77.         this.sno = sno;
  78.     }
  80.     public int getScore() {
  81.         return score;
  82.     }
  84.     public void setScore(int score) {
  85.         this.score = score;
  86.     }
  87. }

2.StudentOS类如下

  1. /**
  2.  * 这是一个学生的管理系统
  3.  * 对学生的管理包括
  4.  * 1.添加学生信息
  5.  * 2.删除学生信息
  6.  * 3.修改学生信息
  7.  * 4.查询学生信息
  8.  * 5.按照学生分数排序，然后展示学生信息
  9.  * 6.展示学生信息
  10.  */
  11. public class StudentOs {
  12.     //学生数组的最大容量
  13.     private int capacity = 10;
  14.     //存放学生信息
  15.     private Student[] students = new Student[capacity];
  16.     //实际存放学生数量
  17.     private int size = 0;
  18.     //声明当前可用的学生编号
  19.     private int nextSno = 10000;
  21.     /**
  22.      * 动态获取下一个学号
  23.      *
  24.      * @return
  25.      */
  26.     public int getNextSno() {
  27.         nextSno++;
  28.         return nextSno;
  29.     }
  32.     /**
  33.      * 添加学生信息
  34.      *
  35.      * @param student
  36.      */
  37.     public void add(Student student) {
  38.         //确定容量是否足够
  39.         ensureEnough();
  40.         //将学生信息添加到系统
  41.         students[size] = student;
  42.         size++;
  43.     }
  45.     /**
  46.      * 根据索引获取学生信息
  47.      *
  48.      * @param index
  49.      * @return
  50.      */
  51.     public Student get(int index) {
  52.         if (index < 0 || index > size - 1) {
  53.             System.out.println("您输入的索引有误，请重新输入");
  54.             return null;
  55.         }
  56.         return students[index];
  57.     }
  59.     /**
  60.      * 确定数组的容量是足够的
  61.      */
  62.     private void ensureEnough() {
  63.         //判断是否已经装满，对数组进行扩容
  64.         if (size == capacity) {
  65.             //计算扩容后的大小
  66.             capacity += capacity / 2;
  67.             //创建新的数组
  68.             Student[] newStudents = new Student[capacity];
  69.             //将原来数组的数据拷贝到新数组
  70.             for (int i = 0; i < students.length; i++) {
  71.                 newStudents[i] = students[i];
  72.             }
  73.             //将学生数组的地址指向新的数组
  74.             students = newStudents;
  75.             System.out.println("数组扩容成功，扩容后的大小为[" + capacity + "]");
  76.         }
  77.     }
  79.     /**
  80.      * 根据学生删除学生信息
  81.      *
  82.      * @param sno
  83.      */
  84.     public void deleteBySno(int sno) {
  85.         //首先遍历学生数组(已有)
  86.         for (int i = 0; i < size; i++) {
  87.             //判断是否学号相等
  88.             if (students[i].getSno() == sno) {
  89.                 //获取被删除学生信息
  90.                 Student student = students[i];
  91.                 //学号相同，可以删除数据
  92.                 for (int j = i; j < size - 1; j++) {
  93.                     students[j] = students[j + 1];
  94.                 }
  95.                 //删除最后一个数据
  96.                 students[size - 1] = null;
  97.                 size--;
  98.                 //打印信息
  99.                 System.out.println("学生[" + student + "]删除成功");
  100.                 //删除成功，直接退出循环
  101.                 return;
  102.             }
  103.         }
  104.     }
  106.     /**
  107.      * 根据学号修改学生的成绩
  108.      *
  109.      * @param sno
  110.      * @param score
  111.      */
  112.     public void updateScoreBySno(int sno, int score) {
  113.         //首先遍历学生数组(已有)
  114.         for (int i = 0; i < size; i++) {
  115.             //判断是否学号相等
  116.             if (students[i].getSno() == sno) {
  117.                 //开始修改分数
  118.                 students[i].setScore(score);
  119.                 //打印信息
  120.                 System.out.println("学生[" + students[i] + "]分数修改成功");
  121.                 //修改成功，直接退出循环
  122.                 return;
  123.             }
  124.         }
  125.     }
  127.     /**
  128.      * 根据学生学号查询对应的学生信息
  129.      *
  130.      * @param sno
  131.      * @return
  132.      */
  133.     public int queryBySno(int sno) {
  134.         //首先遍历学生数组(已有)
  135.         for (int i = 0; i < size; i++) {
  136.             //判断是否学号相等
  137.             if (students[i].getSno() == sno) {
  138.                 //根据学号查询到索引，直接返回
  139.                 return i;
  140.             }
  141.         }
  142.         return -1;
  143.     }
  145.     /**
  146.      * 展示现有全部学生的信息
  147.      */
  148.     public void showAll() {
  149.         System.out.println("============当前系统学生信息为：============");
  150.         //遍历学生信息
  151.         for (int i = 0; i < size; i++) {
  152.             System.out.println(students[i]);
  153.         }
  154.     }
  156.     /**
  157.      * 根据用户输入的用户名和密码验证是否登录成功
  158.      *
  159.      * @param username
  160.      * @param password
  161.      * @return
  162.      */
  163.     public boolean login(String username, String password) {
  164.         //假设用户名是admin 密码是123456 就算成功
  165.         //“equals()”比较字符串中所包含的内容是否相同。
  166.         if ("admin".equals(username) && "123456".equals(password)) {
  167.             return true;
  168.         }
  169.         return false;
  170.     }
  172.     /**
  173.      * 根据学生的分数进行排序
  174.      */
  175.     public void sortByScore() {
  177.     }
  178. }

3.StudentOsMenu类如下：

  1. import java.util.Scanner;
  2. //简单来说Scanner是一个扫描器，我们录取到键盘的数据，先存到缓存区等待读取，他判断读取结束的标示是 空白符；比如空格，比如回车，比如tab…
  3. //next()方法读取到空白符就结束；nextLin()读取到回车结束也就是“\r”
  5. /**
  6.  * 学生管理系统
  7.  */
  8. public class StudentOsMenu {
  9.     public static void main(String[] args) {
  10.         //创建一个学生系统对象
  11.         StudentOs studentOs = new StudentOs();
  12.         //声明一个Scanner  常用于控制台的输入,当需要使用控制台输入时即可调用这个类
  13.         Scanner scanner = new Scanner(System.in);
  14.         //声明一个变量判断是否退出系统
  15.         boolean quitFlag = true;
  16.         //声明一个变量存放管理员的登录状态
  17.         boolean loginFlag = false;
  18.         //死循环进入待机状态
  19.         for (; quitFlag; ) {
  20.             //显示菜单
  21.             System.out.println("-------------学生管理系统-------------");
  22.             System.out.println("|1.登录系统");
  23.             System.out.println("|2.添加学生信息");
  24.             System.out.println("|3.删除学生信息");
  25.             System.out.println("|4.修改学生信息-成绩");
  26.             System.out.println("|5.查询学生信息-学号");
  27.             System.out.println("|6.显示所有学生信息");
  28.             System.out.println("|0.退出系统");
  29.             System.out.println("------------(请输入要执行的菜单编号)-----------");
  30.             //获取用户的输入的菜单
  31.             int menu = scanner.nextInt();
  32.             if (menu == 1) {
  33.                 System.out.println("|1.登录系统");
  34.                 System.out.println("请输入您的用户名!");
  35.                 String username = scanner.next();
  36.                 System.out.println("请输入您的密码!");
  37.                 String password = scanner.next();
  38.                 //判断用户名和密码是否正确
  39.                 loginFlag = studentOs.login(username, password);
  40.                 if (loginFlag) {
  41.                     System.out.println("恭喜您登录成功!");
  42.                 } else {
  43.                     System.out.println("您输入的用户名和密码不匹配，请重新输入【" + username + "】【" + password + "】!");
  44.                 }
  45.             } else if (menu == 0) {
  46.                 System.out.println("|0.退出系统");
  47.                 quitFlag = false;
  48.             } else if (!loginFlag) {
  49.                 System.out.println("|警告：您还没有登录学生管理系统，请执行菜单[1]");
  50.             } else if (menu == 2) {
  51.                 addMenu(studentOs, scanner);
  53.             } else if (menu == 3) {
  54.                 deleteMenu(studentOs, scanner);
  55.             } else if (menu == 4) {
  56.                 updateMenu(studentOs, scanner);
  57.             } else if (menu == 5) {
  58.                 queryMenu(studentOs, scanner);
  59.             } else if (menu == 6) {
  60.                 showMenu(studentOs);
  61.             } else if (menu == 0) {
  62.                 System.out.println("|0.退出系统");
  63.                 quitFlag = false;
  64.             } else {
  65.                 System.out.println("您输入的菜单编号有误，请重新输入！");
  66.             }
  67.         }
  68.     }
  69.     /**
  70.      * 显示所有的学生信息
  71.      *
  72.      * @param studentOs
  73.      */
  74.     private static void showMenu(StudentOs studentOs) {
  75.         System.out.println("|6.显示所有学生信息");
  76.         studentOs.showAll();
  77.     }
  78.     /**
  79.      * 查询学生信息
  80.      *
  81.      * @param studentOs
  82.      * @param scanner
  83.      */
  84.     private static void queryMenu(StudentOs studentOs, Scanner scanner) {
  85.         System.out.println("|5.查询学生信息-学号");
  86.         System.out.println("请输入学生学号!");
  87.         int sno = scanner.nextInt();
  88.         int index = studentOs.queryBySno(sno);
  89.         System.out.println("学号为【" + sno + "】的学生信息为：" + studentOs.get(index));
  90.     }
  91.     /**
  92.      * 修改学生分数
  93.      *
  94.      * @param studentOs
  95.      * @param scanner
  96.      */
  97.     private static void updateMenu(StudentOs studentOs, Scanner scanner) {
  98.         System.out.println("|4.修改学生信息-成绩");
  99.         System.out.println("请输入学生学号!");
  100.         int sno = scanner.nextInt();
  101.         System.out.println("请输入学生成绩!");
  102.         int score = scanner.nextInt();
  103.         //调用方法
  104.         studentOs.updateScoreBySno(sno, score);
  105.     }
  107.     /**
  108.      * 删除学生信息
  109.      *
  110.      * @param studentOs
  111.      * @param scanner
  112.      */
  113.     private static void deleteMenu(StudentOs studentOs, Scanner scanner) {
  114.         System.out.println("|3.删除学生信息");
  115.         System.out.println("请输入你要删除的学生学号!");
  116.         int sno = scanner.nextInt();
  117.         studentOs.deleteBySno(sno);
  118.     }
  120.     /**
  121.      * |2.添加学生信息
  122.      *
  123.      * @param studentOs
  124.      * @param scanner
  125.      */
  126.     private static void addMenu(StudentOs studentOs, Scanner scanner) {
  127.         System.out.println("|2.添加学生信息");
  128.         int sno = studentOs.getNextSno();
  129. //        java.lang.Math.random()
  130. //        返回带正号的 double 值，该值大于等于 0.0 且小于 1.0。返回值是一个伪随机选择的数，在该范围内（近似）均匀分布。
  131.         int score = (int) (Math.random() * 101);
  132.         System.out.println("请输入学生姓名!");
  133.         String name = scanner.next();
  134.         System.out.println("请输入学生年龄!");
  135.         int age = scanner.nextInt();
  136.         System.out.println("请输入学生性别!");
  137.         String gender = scanner.next();
  138.         //创建一个新的学生对象
  139.         Student student = new Student(sno, name, age, gender, score);
  140.         //将学生信息存放到系统
  141.         studentOs.add(student);
  142.         //开发阶段，每次添加后都显示全部学生信息
  143.         studentOs.showAll();
  144.     }
  145. }