黑马——Java学生管理系统

一、学生管理系统

学生管理系统

需求：

采取控制台的方式去书写学生管理系统。

loop:while(true){

? ? ? ? for(){

? ? ? ? break loop;//给while循环取名loop，break loop;可以跳出while循环

? ? ? ? }

}

或者使用System.exit(0);停止虚拟机运行，相当于让所有代码停止运行。

分析：

初始菜单：

"-------------欢迎来到黑马学生管理系统----------------"
"1：添加学生"
"2：删除学生"
"3：修改学生"
"4：查询学生"
"5：退出"
"请输入您的选择:"

学生类：

属性：id、姓名、年龄、家庭住址

添加功能：

键盘录入每一个学生信息并添加，需要满足以下要求：

• id唯一

删除功能：

键盘录入要删除的学生id，需要满足以下要求：

• id存在删除

• id不存在，需要提示不存在，并回到初始菜单

修改功能：

键盘录入要修改的学生id，需要满足以下要求

• id存在，继续录入其他信息

• id不存在，需要提示不存在，并回到初始菜单

查询功能：

打印所有的学生信息，需要满足以下要求

• 如果没有学生信息，提示：当前无学生信息，请添加后再查询

• 如果有学生信息，需要按照以下格式输出。（不用过于纠结对齐的问题）

id          姓名      年龄      家庭住址
heima001    张三      23       南京
heima002    李四      24       北京
heima003    王五      25       广州
heima004    赵六      26       深圳

代码：

• 学生类

package com.yaqi.studentsystem;
//学生类
public class Student {
    private String id;
    private String name;
    private int age;
    private String address;

    public Student() {
    }

    public Student(String id, String name, int age, String address) {
        this.id = id;
        this.name = name;
        this.age = age;
        this.address = address;
    }

    public String getId() {
        return id;
    }

    public void setId(String id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getAddress() {
        return address;
    }

    public void setAddress(String address) {
        this.address = address;
    }
}

• 功能代码

package com.yaqi.studentsystem;

import java.util.ArrayList;
import java.util.Scanner;

public class StudentSystem {
    public static void main(String[] args) {
        ArrayList<Student> list = new ArrayList<>();
        loop:while (true) {
            System.out.println("-------------欢迎来到黑马学生管理系统----------------");
            System.out.println("1:添加学生");
            System.out.println("2:删除学生");
            System.out.println("3:修改学生");
            System.out.println("4:查询学生");
            System.out.println("5:退出");
            Scanner sc = new Scanner(System.in);
            System.out.println("请输入您的选择：");
            String choose = sc.next();
            switch (choose){
                case "1":
                    addStudent(list);
                    break;
                case "2":
                    deleteStudent(list);
                    break;
                case "3":
                    updateStudent(list);
                    break;
                case "4":
                    queryStudent(list);
                    break;
                case "5":{
                    System.out.println("退出");
                    break loop;
                    //System.exit(0);//停止虚拟机运行
                }
                default:
                    System.out.println("没有这个选项");
            }
        }
    }

    //添加学生
    public static void addStudent(ArrayList<Student> list) {
        //利用空参构造创建学生对象
        Student s = new Student();

        Scanner sc = new Scanner(System.in);
        String id = null;
        while (true) {
            System.out.println("请输入学生的id");
            id = sc.next();
            boolean flag = contains(list, id);
            if (flag) {
                //表示id已经存在,需要重新录入
                System.out.println("id已经存在，请重新录入");
            } else {

                //表示id不存在，表示可以继续使用
                s.setId(id);
                break;
            }
        }


        System.out.println("请输入学生的姓名");
        String name = sc.next();
        s.setName(name);

        System.out.println("请输入学生的年龄");
        int age = sc.nextInt();
        s.setAge(age);

        System.out.println("请输入学生的家庭住址");
        String address = sc.next();
        s.setAddress(address);

        //把学生对象添加到集合中
        list.add(s);
    }

    //删除学生
    public static void deleteStudent(ArrayList<Student> list){
        Scanner sc= new Scanner(System.in);
        System.out.println("请输入要删除的id");
        String id = sc.next();
        //查询id在集合中的索引
        int index = getIndex(list, id);
        //对index进行判断
        //如果-1，就表示不存在，结束方法，回到初始菜单
        if(index>=0){
            //如果index大于等于0表示存在直接删除
            list.remove(index);
            System.out.println("id为："+id+"的学生删除");
        }else{
            System.out.println("id不存在，删除失败");
        }
    }
    //修改学生
    public static void updateStudent(ArrayList<Student> list){
       Scanner sc= new Scanner(System.in);
        System.out.println("请输入要修改学生的id");
        String id = sc.next();

        int index = getIndex(list, id);
        if(index==-1){
            System.out.println("要修改的"+id+"不存在，请重新输入");
            return;
        }

        //当代码执行到这里，表示当前id是存在的
        //获取要修改的学生对象
        Student stu = list.get(index);

        //输入其他信息并修改
        System.out.println("请输入要修改的学生姓名为");
        String newName = sc.next();
        stu.setName(newName);

        System.out.println("请输入要修改的学生年龄");
        int newAge = sc.nextInt();
        stu.setAge(newAge);

        System.out.println("请输入要修改的学生家庭住址");
        String newAddress = sc.next();
        stu.setAddress(newAddress);

        System.out.println("学生信息修改成功");
    }
    //查询学生
    public static void queryStudent(ArrayList<Student> list){
        if(list.size() == 0){
            System.out.println("当前无学生信息，请添加后，在查询");
            //结束方法
            return;
        }
        
        //打印表头信息
        System.out.println("id\t\t姓名\t年龄\t家庭住址");
        //代码执行到这里，表示集合中是有数据的
        for (int i = 0; i < list.size(); i++) {
            Student stu = list.get(i);
            System.out.println(stu.getId()+"\t"+stu.getName()+"\t"+stu.getAge()+"\t"+stu.getAddress());
        }
    }

    //判断id在集合中是否存在
    public static boolean contains(ArrayList<Student> list,String id){
        //循环遍历集合得到里面的每一个学生对象
        /*for (int i = 0; i < list.size(); i++) {
            //拿到学生对象后，获取id并进行判断
            Student stu = list.get(i);
            String sid = stu.getId();
            if(sid.equals(id)){
                //存在true
                return true;
            }
        }
        //不存在 false
        return false;*/
        return getIndex(list, id) >=0;
    }

    //提过id获取索引的方法
    public static int getIndex(ArrayList<Student> list,String id){
        //遍历集合
        for (int i = 0; i < list.size(); i++) {
            //得到每一个学生对象
            Student stu = list.get(i);
            //得到每一个学生对象的id
            String sid = stu.getId();
            //拿着集合中的学生id跟要删除的id进行比较
            if(sid.equals(id)){
                //如果一样，那么返回索引
                return i;
            }
        }
        //当前循环结束之后还没有找到，就表示不存在，返回-1
        return -1;
    }
}

二、学生管理系统升级

需求：

为学生管理系统书写一个登陆、注册、忘记密码的功能。

只有用户登录成功之后，才能进入到学生管理系统中进行增删改查操作。

分析：

登录界面：

System.out.println("欢迎来到学生管理系统");
System.out.println("请选择操作1登录 2注册 3忘记密码");

用户类：

属性：用户名、密码、身份证号码、手机号码

注册功能：

1，用户名需要满足以下要求：

验证要求：

用户名唯一

用户名长度必须在3~15位之间

只能是字母加数字的组合，但是不能是纯数字

2，密码键盘输入两次，两次一致才可以进行注册。

3，身份证号码需要验证。

验证要求：

长度为18位

不能以0为开头

前17位，必须都是数字

最为一位可以是数字，也可以是大写X或小写x

4，手机号验证。

验证要求：

长度为11位

不能以0为开头

必须都是数字

登录功能：

1，键盘录入用户名

2，键盘录入密码

3，键盘录入验证码

验证要求：

用户名如果未注册，直接结束方法，并提示：用户名未注册，请先注册

判断验证码是否正确，如不正确，重新输入

再判断用户名和密码是否正确，有3次机会

忘记密码：

1，键盘录入用户名，判断当前用户名是否存在，如不存在，直接结束方法，并提示：未注册

2，键盘录入身份证号码和手机号码

3，判断当前用户的身份证号码和手机号码是否一致，

如果一致，则提示输入密码，进行修改。

如果不一致，则提示：账号信息不匹配，修改失败。

验证码规则：

长度为5

由4位大写或者小写字母和1位数字组成，同一个字母可重复

数字可以出现在任意位置

比如：

aQa1K

• 用户类

package com.yaqi.studentsystem;
//用户类
public class User {

    private String username;
    private String password;
    private String personID;
    private String phoneNumber;

    public User() {
    }

    public User(String username, String password, String personID, String phoneNumber) {
        this.username = username;
        this.password = password;
        this.personID = personID;
        this.phoneNumber = phoneNumber;
    }

    public String getUsername() {
        return username;
    }

    public void setUsername(String username) {
        this.username = username;
    }

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }

    public String getPersonID() {
        return personID;
    }

    public void setPersonID(String personID) {
        this.personID = personID;
    }

    public String getPhoneNumber() {
        return phoneNumber;
    }

    public void setPhoneNumber(String phoneNumber) {
        this.phoneNumber = phoneNumber;
    }
}

• APP功能代码

package com.yaqi.studentsystem;

import java.util.ArrayList;
import java.util.Random;
import java.util.Scanner;

public class App {
    public static void main(String[] args) {
        ArrayList<User> list = new ArrayList<>();
        Scanner sc = new Scanner(System.in);
        while (true) {
            System.out.println("欢迎来到学生管理系统");
            System.out.println("请选择操作：1登录 2注册 3忘记密码");
            String choose = sc.next();
            switch (choose) {
                case "1":
                    login(list);
                    break;
                case "2":
                    register(list);
                    break;
                case "3":
                    forgetPassword(list);
                    break;
                case "4": {
                    System.out.println("谢谢使用，再见");
                    System.exit(0);
                }
                default:
                    System.out.println("没有这个选项");
            }
        }
    }

    private static void forgetPassword(ArrayList<User> list) {
        //1.键盘录入
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入用户名");
        String username = sc.next();
        boolean falg = contains(list, username);
        if (!falg) {
            System.out.println("当前用户" + username + "未注册，请先注册");
            return;
        }

        //键盘录入身份证号码和手机号码
        System.out.println("请输入身份证号码");
        String personID = sc.next();
        System.out.println("请输入手机号码");
        String phoneNumber = sc.next();

        //比较用户对象中的手机号码和身份证号码是否相同
        //需要把用户对象通过索引先获取出来
        int index = findIndex(list, username);
        User user = list.get(index);
        //比较对象中的手机号和身份证号码是否相同
        if (!(user.getPersonID().equalsIgnoreCase(personID) && (user.getPhoneNumber().equalsIgnoreCase(phoneNumber)))) {
            System.out.println("身份证号码或手机号码输入有误，不能修改密码");
            return;
        }

        //当执行到这里，表示所有的数据全部验证成功，直接修改即可
        //提高代码的阅读性
        String password;

        while (true) {
            System.out.println("请输入密码");
            password = sc.next();
            System.out.println("请再次输入密码");
            String againPassword = sc.next();
            if (password.equals(againPassword)) {
                System.out.println("两次输入的密码一致");
                break;
            } else {
                System.out.println("两次输入的密码不一致，请重新输入");
                continue;
            }
        }

        //直接修改即可
        user.setPassword(password);
        System.out.println("密码修改成功");


    }

    private static int findIndex(ArrayList<User> list, String username) {
        for (int i = 0; i < list.size(); i++) {
            User user = list.get(i);
            if (user.getUsername().equals(username)) {
                return i;
            }
        }
        return -1;
    }

    private static void register(ArrayList<User> list) {
        //1.键盘录入用户名
        String username;
        Scanner sc = new Scanner(System.in);
        while (true) {
            System.out.println("请输入用户名");
            username = sc.next();
            //开发细节：先验证格式是否正确，再验证是否唯一
            //因为在以后得所有数据中，都是存在数据库中如果我们要校验，需要使用到网络资源。
            boolean falg1 = checkUsername(username);
            if (!falg1) {
                System.out.println("用户名格式不满足条件，需要重新输入");
                continue;
            }
            //检验用户名唯一
            boolean falg2 = contains(list, username);
            if (falg2) {
                //用户名已存在，那么当前用户无法注册，请重新输入
                System.out.println("用户名" + username + "已存在，请重新输入");
            } else {
                //不存在，表示当前用户名可用，可以继续录入下面的其他数据
                System.out.println("用户名" + username + "可用");
                break;
            }
        }
        //2.键盘录入密码
        //密码键盘录入两次，两次一致才可以进行注册
        String password;
        while (true) {
            System.out.println("请输入要注册的密码");
            password = sc.next();
            System.out.println("请再次输入要注册的密码");
            String againPassword = sc.next();
            if (!password.equals(againPassword)) {
                System.out.println("两次密码输入不一致，请重新输入");
                continue;
            } else {
                System.out.println("两次密码一致，继续录入其他数据");
                break;
            }
        }
        //3.键盘录入身份证号码
        String personID;
        while (true) {
            System.out.println("请输入身份证号码");
            personID = sc.next();
            boolean flag = checkPersonID(personID);
            if (flag) {
                System.out.println("身份证号满足要求");
                break;
            } else {
                System.out.println("身份证号码格式有误，请重新输入");
                continue;
            }
        }
        //4.键盘录入手机号
        String phoneNumber;
        while (true) {
            System.out.println("请输入手机号码");
            phoneNumber = sc.next();
            boolean flag = checkPhoneNumber(phoneNumber);
            if (flag) {
                System.out.println("手机号格式正确");
                break;
            } else {
                System.out.println("手机号格式有误，请重新输入");
                continue;
            }
        }
        //用户名，密码，身份证号码，手机号码放到用户对象中
        User u = new User(username, password, personID, phoneNumber);
        //把用户对象添加到集合中
        list.add(u);
        System.out.println("注册成功");

        //遍历集合


    }

    private static void login(ArrayList<User> list) {
        //键盘录入
        Scanner sc = new Scanner(System.in);
        for (int i = 0; i < 3; i++) {
            System.out.println("请输入用户名");
            String username = sc.next();
            //判断用户名是否存在
            boolean falg = contains(list, username);
            if (!falg) {
                System.out.println("用户名" + username + "未注册，请先注册，在登录");
                return;
            }

            System.out.println("请输入密码");
            String password = sc.next();

            while (true) {
                String rightCode = getCode();
                System.out.println("当前正确的验证码为：" + rightCode);
                System.out.println("请输入验证码");
                String code = sc.next();
                //不区分大小写
                if (code.equalsIgnoreCase(rightCode)) {
                    System.out.println("验证码正确");
                    break;
                } else {
                    System.out.println("验证码错误");
                    continue;
                }
            }

            //验证用户名和密码是否正确
            //集合中是否包含用户名和密码
            //定义一个方法验证用户名和密码是否正确

            //封装思想的应用
            //我们可以把一些零散的数据，封装成一个对象
            //以后传递参数的时候，只要传递一个整体就可以了，不需要管这些零散的数据

            User useInfo = new User(username, password, null, null);
            boolean result = checkUserInfo(list, useInfo);
            if (result) {
                System.out.println("登录成功，可以开始使用学生管理系统了");
                break;
            } else {
                System.out.println("登录失败，用户名或者密码错误");
                if (i == 2) {
                    System.out.println("当前账号" + username + "被锁定，请联系黑马程序员客服： XXX-XXXXX");
                    //当前账号锁定之后，直接结束方法即可
                    return;
                } else {
                    System.out.println("用户名或者密码错误，还剩下" + (2 - i) + "次机会");
                }
            }
        }
    }

    private static boolean checkUserInfo(ArrayList<User> list, User useInfo) {
        //遍历集合，判断用户是否存在，如果存在则登录成功
        for (int i = 0; i < list.size(); i++) {
            User user = list.get(i);
            if (user.getUsername().equals(useInfo.getUsername()) && user.getPassword().equals(useInfo.getPassword()))
                return true;
        }
        return false;
    }
    //3.键盘录入身份证号码


    //遍历集合方法
    private static void printList(ArrayList<User> list) {
        for (int i = 0; i < list.size(); i++) {
            User user = list.get(i);
            System.out.println(user.getUsername() + "," + user.getPassword() + "," + user.getPersonID() + "," + user.getPhoneNumber());
        }
    }

    //检验手机号码
    private static boolean checkPhoneNumber(String phoneNumber) {
        //长度为1位
        if (phoneNumber.length() != 11) {
            return false;
        }
        //不能以0为开头
        if (phoneNumber.startsWith("0")) {
            return false;
        }
        //必须都是数字
        for (int i = 0; i < phoneNumber.length(); i++) {
            char c = phoneNumber.charAt(i);
            if (!(c >= '0' && c <= '9')) {
                return false;
            }
        }
        //当循环结束之后，表示每一个字符都在0-9之间
        return true;
    }

    //检验身份证号码
    private static boolean checkPersonID(String personID) {
        //长度为18位
        if (personID.length() != 18) {
            return false;
        }
        //不能以0为开头
        if (personID.startsWith("0")) {
            //如果以0开头，那么返回false
            return false;
        }
        //前17位，必须都是数字
        for (int i = 0; i < personID.length(); i++) {
            char c = personID.charAt(i);
            //如果有一个字符不在0-9之间，那么直接返回false
            if (!(c >= '0' && c <= '9')) {
                return false;
            }
        }
        //最后一位可以是数字，也可以是大写X或者小写x
        char endChar = personID.charAt(personID.length() - 1);
        if ((endChar >= '0' && endChar <= '9') || (endChar == 'x') || endChar == 'X') {
            return true;
        } else {
            return false;
        }
    }


    //检验用户名是否唯一的方法
    private static boolean contains(ArrayList<User> list, String username) {
        //循环遍历集合得到每一个用户对象
        //拿着用户对象中的用户名进行比较
        for (int i = 0; i < list.size(); i++) {
            //i索引
            User user = list.get(i);
            String rightUsername = user.getUsername();
            if (rightUsername.equals(username)) {
                return true;
            }
        }
        //当循环结束了，表示集合里面所有的用户都比较完毕了，还没有一样的，则返回false
        return false;
    }

    //检验用户名方法
    /*
    ?	1，用户名需要满足以下要求：

?		验证要求：

?			用户名唯一

?			用户名长度必须在3~15位之间

?			只能是字母加数字的组合，但是不能是纯数字
     */
    private static boolean checkUsername(String username) {
        //用户名长度必须在3~15位之间
        int len = username.length();
        if (len < 3 || len > 15) {
            return false;
        }
        //当代码执行到这里，表示用户名的长度是符合要求的。
        //继续校验：只能是字母加数字的组合
        //循环得到username里面的每一个字符，如果有一个字符不是字母或者数字，那么久返回false
        for (int i = 0; i < username.length(); i++) {
            //i索引
            char c = username.charAt(i);
            if (!((c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') || (c >= '0' && c <= '9'))) {
                return false;
            }
        }
        //当代码执行到这里，表示
        //用户名满足两个要求：1长度要求 2内容要求也满足（字母+数字）
        //但不能是纯数字
        //统计在用户名中，有多少个字母就可以了。
        int count = 0;
        for (int i = 0; i < username.length(); i++) {
            //i索引
            char c = username.charAt(i);
            if ((c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z')) {
                count++;
                break;
            }
        }
        return count > 0;
    }

    private static String getCode() {
        //1.创建一个集合添加所有的大写和小写字母
        ArrayList<Character> list = new ArrayList<>();
        for (int i = 0; i < 26; i++) {
            list.add((char) ('a' + i));
            list.add((char) ('A' + i));
        }

        StringBuilder sb = new StringBuilder();
        //2.要随机抽取4个字符
        Random r = new Random();
        for (int i = 0; i < 4; i++) {
            //获取随机索引
            int index = r.nextInt(list.size());
            //利用随机索引获取字符串
            char c = list.get(index);
            sb.append(c);
        }

        //3.把一个随机数添加到末尾
        int number = r.nextInt(10);
        sb.append(number);

        //4.如果我们要改变字符串中的内容
        //先把字符串变成字符数组，在数组中修改，然后再创建一个新的字符串
        char[] arr = sb.toString().toCharArray();
        //拿着最后一个索引，跟随机索引进行交换
        int randomIndex = r.nextInt(arr.length);
        //最大的索引指向的元素，跟随机索引指向的元素交换
        char temp = arr[randomIndex];
        arr[randomIndex] = arr[arr.length - 1];
        arr[arr.length - 1] = temp;
        return new String(arr);
    }
}