这是一个学生管理系统

  • 分析步骤：

  • 1.定义一个学生类

  • 2.学生管理系统主界面的编写
  • 3.学生管理系统的查看所有学生的信息
  • 4.学生管理系统的添加学生信息
  • 5.学生管理系统的删除学生信息
  • 6.学生管理系统的修改学生信息

新建一个学生实体类

  1. package Test10_Demo.StudentManager06;/*
  3.     @create 2020--11--26--9:31
  4. */
  6. /**
  7.  * 学生的实体类
  8.  */
  10. public class Student {
  11.     //属性
  12.     private String id;
  13.     private String name;
  14.     private String age;
  15.     private String address;
  17.     public Student(){
  19.     }
  20.     public Student(String id,String name ,String age,String address){
  21.         this.id = id;
  22.         this.name = name;
  23.         this.age = age;
  24.         this.address = address;
  25.     }
  27.     public String getId() {
  28.         return id;
  29.     }
  31.     public void setId(String id) {
  32.         this.id = id;
  33.     }
  35.     public String getName() {
  36.         return name;
  37.     }
  39.     public void setName(String name) {
  40.         this.name = name;
  41.     }
  43.     public String getAge() {
  44.         return age;
  45.     }
  47.     public void setAge(String age) {
  48.         this.age = age;
  49.     }
  51.     public String getAddress() {
  52.         return address;
  53.     }
  55.     public void setAddress(String address) {
  56.         this.address = address;
  57.     }
  58. }

实现学生管理系统：

  1. package Test10_Demo.StudentManager06;/*
  3.     @create 2020--11--26--9:28
  4. */
  6. import java.util.ArrayList;
  7. import java.util.Scanner;
  9. /**
  10.  * 这是一个学生管理系统
  11.  *
  12.  * 分析步骤：
  13.  * 1.定义一个学生类
  14.  * 2.学生管理系统主界面的编写
  15.  * 3.学生管理系统的查看所有学生的信息
  16.  * 4.学生管理系统的添加学生信息
  17.  * 5.学生管理系统的删除学生信息
  18.  * 6.学生管理系统的修改学生信息
  19.  */
  20. public class StudentManagerTest {
  21.     public static void main(String[] args) {
  23.         //定义一个学生类型的集合
  24.         ArrayList<Student> array = new ArrayList<>();
  26.         //为了用户体验度，设计一个界面
  27.         //利用循环的方法可以重复的展示界面，直到推出程序就结束循环
  29.         while (true) {
  30.             //主界面的欢迎词
  31.             System.out.println("-------------------------欢迎来到学生管理系统-------------------------------");
  32.             System.out.println("1.查看所有学生信息");
  33.             System.out.println("2.添加学生信息");
  34.             System.out.println("3.删除学生信息");
  35.             System.out.println("4.修改学生信息");
  36.             System.out.println("5.退出学生管理系统");
  39.             //键盘录入获取
  40.             Scanner sc = new Scanner(System.in);
  41.             String choiceString = sc.nextLine();
  43.             //用开关键 - swtich...case
  44.             switch (choiceString) {
  45.                 case "1":
  46.                     //查看所有学生
  47.                     findAllStudent(array);
  48.                     break;
  49.                 case "2":
  50.                     //添加学生信息
  51.                     addStudent(array);
  52.                     break;
  53.                 case "3":
  54.                     deleteStudent(array);
  55.                     //删除学生信息
  56.                     break;
  57.                 case "4":
  58.                     updateStudent(array);
  59.                     //修改学生信息
  60.                     break;
  61.                 default:
  62.                     System.out.println("谢谢你的使用");
  63.                     System.exit(0); //jvm中提供的退出程序
  64.                     break;
  65.             }
  68.         }
  72.     }
  74.     //封装一个方法用于查询学生的所有细腻
  75.     public static void findAllStudent(ArrayList<Student> array){
  76.         //首先判断集合中有没有数据，如果是空的，那就要给出提示，并且该方法就不需要执行了 - 非空判断
  77.         if (array.size() == 0) {
  78.             System.out.println("抱歉！目前没有任何的学生信息可以查询，请回去重新选择！");
  79.             return; //将当前的方法直接结束
  80.         }
  81.         //有学生的情况下 - 遍历查询
  82.         //\t 表示一个Tab键 - 制表符
  83.         //\s 表示一个space键 - 空格
  84.         System.out.println("学号\t姓名\t年龄\t居住地");
  86.         for (int i = 0; i <array.size() ; i++) {
  87.             Student s = array.get(i);
  88.             //输出属性
  89.             System.out.println(s.getId()+"\t " +
  90.                                 s.getName() + "\t  " +
  91.                                 s.getAge() + "\t  " +
  92.                                 s.getAddress());
  95.         }
  97.     }
  99.     public static void addStudent(ArrayList<Student> array) {
  100.         //键盘对象
  101.         Scanner sc = new Scanner(System.in);
  103.         //所有的对学生的操作都是基于id，所以我们把id属性放到循环的外面
  104.         String id;
  105.         //能够实现重复添加学生的信息，所以使用循环
  106.         while (true) {
  107.             //判断一下这个学号是不是已经存在了
  108.             System.out.println("请输入学号");
  109.             id = sc.nextLine();
  110.             boolean flag = false;
  111.             //遍历学号 - 就是遍历数组
  112.             for (int i = 0; i < array.size(); i++) {
  113.                 Student s = array.get(i);
  114.                 //获取学号
  115.                 if (s.getId().equals(id)) {
  116.                     flag = true;//学号存在
  117.                     break;
  118.                 }
  119.             }
  120.             //这个时候flag就是true
  121.             if (flag) {
  122.                 System.out.println("你输入的学号已经存在，请重新输入");
  123.             } else {
  124.                 break;
  125.             }
  126.         }
  129.         //通过上面的验证之后就可以添加学生了
  130.         System.out.println("请输入学生姓名");
  131.         String name = sc.nextLine();
  133.         System.out.println("请输入学生年龄");
  134.         String age = sc.nextLine();
  136.         System.out.println("请输入学生居住地");
  137.         String address = sc.nextLine();
  139.         //创建学生对象
  140.         Student s = new Student();
  141.         //赋值
  142.         s.setId(id);
  143.         s.setName(name);
  144.         s.setAge(age);
  145.         s.setAddress(address);
  147.         //把学生保存到集合中
  148.         array.add(s);
  150.         //给出一个提示
  151.         System.out.println("添加学生成功！");
  152.     }
  154.     //封装以个方法用于删除学生
  155.     public static void deleteStudent(ArrayList<Student> array){
  156.         //思路：键盘录入一个id（唯一），到集合中查找，看看是否有学生，如果有，则删除
  157.         //键盘录入
  158.         Scanner sc = new Scanner(System.in);
  159.         System.out.println("请输入你要删除的学生的学号：");
  160.         String id = sc.nextLine();
  162.         //遍历集合看看这个id所对应的学生是不是存在 - 设置一个索引
  163.         int index = -1;
  164.         for (int i = 0; i < array.size(); i++) {
  165.             //获取每一个学生
  166.             Student s = array.get(i);
  167.             //判断这个学生的学号喝键盘录入的id进行比较
  168.             if (s.getId().equals(id)) { //要删除的对象存在
  169.                 index = i;
  170.                 break;
  171.             }
  172.         }
  173.         //判断
  174.         if (index == -1) {
  175.             System.out.println("抱歉！您要删除的学生不存在!请重新输入");
  176.         } else {
  177.             array.remove(index);
  178.             System.out.println("删除成功！");
  179.         }
  180.     }
  182.     //封装一个方法用于修改学生
  183.     public static void updateStudent(ArrayList<Student> array){
  184.         //思路：键盘录入一个id（唯一），到集合中查找，看看是否有学生，如果有，则删除
  185.         //键盘录入
  186.         Scanner sc = new Scanner(System.in);
  187.         System.out.println("请输入你要删除的学生的学号：");
  188.         String id = sc.nextLine();
  190.         //遍历集合看看这个id所对应的学生是不是存在 - 设置一个索引
  191.         int index = -1;
  192.         for (int i = 0; i < array.size(); i++) {
  193.             //获取每一个学生
  194.             Student s = array.get(i);
  195.             //判断这个学生的学号喝键盘录入的id进行比较
  196.             if (s.getId().equals(id)) { //要删除的对象存在
  197.                 index = i;
  198.                 break;
  199.             }
  200.         }
  201.         //判断
  202.         if (index == -1) {
  203.             System.out.println("抱歉！您要修改的学生不存在!请重新输入");
  204.         } else {
  205.             //修改的逻辑
  206.             System.out.println("请输入学生的新的姓名：");
  207.             String name = sc.nextLine();
  208.             System.out.println("请输入学生的新的年龄：");
  209.             String age = sc.nextLine();
  210.             System.out.println("请输入学生的新的居住地：");
  211.             String address = sc.nextLine();
  213.             //创建一个新的对象
  214.             Student s = new Student();
  215.             s.setId(id);
  216.             s.setName(name);
  217.             s.setAge(age);
  218.             s.setAddress(address);
  220.             //修改集合中的学生对象 -- 实际上就是把原来的元素替换
  221.             array.set(index, s);//index表示集合中元素的下表  s表示替换进去的对象
  224.             //给出一个提示
  225.             System.out.println("修改学生成功！");
  226.         }
  227.     }
  228. }