员工管理系统初学者阶段

涉及知识点

类和对象（属性、方法）、类的封装、引用数组（对象数组）、数组的插入、删除、对象的聚集处理、多对象协同工作

需求

模拟实现基于文本界面的《员工管理系统》。

该软件能够实现对员工对象的插入、修改和删除（用数组实现），并能够打印员工明细表。

一、项目采用分级菜单方式。主菜单如下：

-----------------员工信息管理-----------------

1 添加员工

2 修改员工

3 删除员工

4 员工列表

5 退 出

请选择(1-5)：_

• 每个员工的信息被保存在Employee对象中。

• 以一个Employee类型的数组来记录当前所有的客户

• 每次“添加员工”（菜单1）后，员工（Employee）对象被添加到数组中。

• 每次“修改员工”（菜单2）后，员工对象的属性被重新赋为新值。

• 每次“删除员工”（菜单3）后，员工（ Employee ）对象被从数组中清除。

• 执行“员工列表 ”（菜单4）时，将列出数组中所有员工的信息

二、“添加员工”的界面及操作过程如下所示：

请选择(1-5)：1

---------------------添加员工---------------------

姓名：键盘录入

性别：键盘录入

年龄：。。。

工资：。。。

电话：。。。

邮箱：。。

---------------------添加完成---------------------

三、“修改员工”的界面及操作过程如下所示：

请选择(1-5)：2

---------------------修改员工---------------------

请选择待修改员工编号(-1退出)：1

姓名(张三)：<直接回车表示不修改>

性别(男)：

年龄(30)：

工资(8000)：

电话(010-56253825)：

邮箱(zhang@123)：

---------------------修改完成---------------------

四、“删除员工”的界面及操作过程如下所示：

请选择(1-5)：3

---------------------删除员工---------------------

请选择待删除员工编号(-1退出)：1

确认是否删除(Y/N)：y

---------------------删除完成---------------------

五、“员工列表”的界面及操作过程如下所示：

请选择(1-5)：4

----------------------------员工列表------------------------------

编号 姓名性别 年龄 工资 电话 邮箱

1 张三 男 30 8000 56253825 abc

2 李四 女 23 7000 56253826 。。。

3 王芳 女 26 9000 56253827 。。。

--------------------------员工列表完成----------------------------

需求理解

一般项目分为三层：

数据访问层

负责把从键盘/页面输入的数据，或者计算产生的数据，存储到数据库中，或者把数据库中的数据查询出来在控制台/页面展示。

该初学者阶段则是掌握：类的创建，并会操作该类的成员变量和调用该类的成员方法

业务逻辑层

处理复杂的数据处理逻辑，接收视图层和数据访问层传递的信息，经处理后返回到视图层和数据访问层

该初学者阶段则是需要掌握：对象数组的增、删、改、查

视图层

负责页面的数据接收和展示。

该初学者阶段则是需要掌握：用循环保证程序的不断运行、方法的调用、字符串处理的常见方法、键盘录入和输出

框架

数据访问层

class Employee{成员、set、get方法}

业务逻辑层

class EmployeeService{Employee类的对象数组、元素计数、getEmployee（index）、addEmployee（Employee）、removeEmployee（index）、getAllEmployee()}

增：addEmployee（Employee）{if判满、添加、return boolean}

删：removeEmployee（index）{if判满、for遍历移动数组、计数、return boolean}

查：getEmployee（index）{if判越界、获取、return Employee}

获得所有数据：getAllEmployee(){new新数组、for遍历传递至新数组、return 新数组}

视图层

class EmployeeView{EmployeeService类的实例对象、enterMainMenu（）、modifyEmployee（）、addNewEmployee（）、deleteEmployee（）、listAllEmployee（）}

主菜单入口：enterMainMenu（）{while循环输出界面、键盘录入、switch判执行方法}

增：addNewEmployee（）{提示界面、临时变量、键盘录入、临时对象、把临时变量存入临时对象、调用逻辑层 增 方法，把数据存入数据访问层}

删：deleteEmployee（）{提示界面、列出所有数据、键盘录入、if分支判断调用逻辑层 删 方法后是否删除成功}

改：modifyEmployee（）{列出所有数据、调用业务层 查 方法、提示界面、临时变量接收录入数据、临时变量接收后再传给数据访问层}

查：listAllEmployee（）{提示界面、创建临时业务层对象、遍历调用 获得所有数据 方法}

代码（复制到idea读，都写了注释，可读性更高）

Employee类（数据访问层）

public class Employee {
    private String name;// : 姓名
    private char gender;// : 性别
    private int age;// : 年龄
    private double salary;// : 工资
    private String phone;// : 电话号码
    private String email;// : 电子邮箱
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public char getGender() {
        return gender;
    }
    public void setGender(char gender) {
        this.gender = gender;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    public double getSalary() {
        return salary;
    }
    public void setSalary(double salary) {
        this.salary = salary;
    }
    public String getPhone() {
        return phone;
    }
    public void setPhone(String phone) {
        this.phone = phone;
    }
    public String getEmail() {
        return email;
    }
    public void setEmail(String email) {
        this.email = email;
    }
    public String say() {
        return name + "\t" + gender + "\t" +
                age + "\t" + salary + "\t" + phone + "\t" + email;
    }
}

EmployeeService(业务逻辑层)

/**
 * 这是一个具有管理功能的功能类. 内部数据不允许外部随意修改, 具有更好的封装性.
 */
public class EmployeeService {

    private Employee[] employees;//用来保存员工对象的数组, 始终保持结构良好 : 前面都是连续的有效对象,后面是连续的空洞.
    private int realCount = 0;   //记录已保存员工对象的数量

    /**
     * 用途：构造器，用来初始化employees数组
     * 参数：totalCount：指定employees数组的最大空间
     */
    public EmployeeService(int totalCount) {

        this.employees = new Employee[totalCount];
    }

    /**
     * 用途：将参数emp对象添加组中最后一个员工对象记录之后
     * 参数：emp指定要添加的员工对象
     * 返回：添加成功返回true；false表示数组已满，无法添加
     */
    public boolean addEmployee(Employee emp) {
        if (realCount == this.employees.length) { // if (数组已满) {
            return false;
        }
        this.employees[realCount] = emp;
        realCount++;
        return true;
    }

    /**
     * 用途：返回数组中记录的所有员工对象
     * 返回： Employee[] 数组中包含了当前所有员工对象，该数组长度与对象个数相同。
     * 返回的是完美数组, 数组是没有空洞的数组
     * @return
     */
    public Employee[] getAllEmployees() {
        // 创建一个新数组, 长度是计数器
        Employee[] newArr = new Employee[realCount];
        // 依次把内部数组中的所有有效元素复制到新数组中
        for (int i = 0; i < realCount; i++) {
            newArr[i] = this.employees[i];
        }
        // 返回新数组
        return newArr;
    }

    /**
     * 用途：返回参数index指定索引位置的员工对象记录
     * 参数： index指定所要获取的员工对象在数组中的索引位置
     * 返回：封装了员工信息的Employee对象
     */
    public Employee getEmployee(int index) {
        if (index < 0 || index >= realCount) { // if (下标不合法) {
            return null;
        }
        return this.employees[index];
    }

    /**
     * 用途：从数组中删除参数index指定索引位置的员工对象记录
     * 参数： index指定所删除对象在数组中的索引位置
     * 返回：删除成功返回true；false表示索引无效，无法删除
     */
    public boolean removeEmployee(int index) {
        if (index < 0 || index >= realCount) { // if (下标不合法) {
            return false;
        }
        // 1) 把要删除的下标位置置空
        employees[index] = null;
        // 2) 依次把右侧位置的值复制到左侧, 作用是补空洞
        for (int i = index; i < realCount - 1; i++) {
            employees[i] = employees[i + 1];
        }
        // 3) 把之前的最后有效位置置空
        employees[realCount - 1] = null;
        // 4) 调整计数器
        realCount--;
        return true;
    }
}

EmployeeView(视图层)

/**
 * 这是主控模块, 负责菜单显示和用户交互. 也称为UI, 内部要频繁到管理器对象, 所以使用对象关联
 */
public class EmployeeView {
    /**
     * 关联到的管理器对象, 内部的数组长度在这里写死成10个, 允许最多管理10个员工
     */
    private EmployeeService empService = new EmployeeService(10);
    /**
     * 进入主菜单, 是项目的真正入口, 不可以轻易结束
     */
    public void enterMainMenu() {
        // 1) 声明布尔
        boolean loopFlag = true;
        // 2) 写循环
        do {
            System.out.println("-----------------员工信息管理---------------- -");
            System.out.println("        1 添加员工");
            System.out.println("        2 修改员工");
            System.out.println("        3 删除员工");
            System.out.println("        4 员工列表");
            System.out.println("        5 退   出");
            System.out.println();
            System.out.print("        请选择(1 - 5)：");
            // 读取用户选择
            char choice = EMSUtility.readMenuSelection();
            switch (choice) {
                case '1' : addNewEmployee(); break;
                case '2' : modifyEmployee(); break;
                case '3' : deleteEmployee(); break;
                case '4' : listAllEmployees(); break;
                case '5' :
                    System.out.print("确认是否退出(Y/N)：");
                    // 获取用户输入的确认
                    char confirm = EMSUtility.readConfirmSelection();
                    if (confirm == 'Y') {
                        loopFlag = false;
                    }
                    break;
            }
        } while (loopFlag);
    }

    /**
     * 添加新员工
     */
    private void addNewEmployee() {
        System.out.println("---------------------添加员工---------------------");
        System.out.print("姓名：");
        String name = EMSUtility.readString(10);
        System.out.print("性别：");
        char gender = EMSUtility.readChar();
        System.out.print("年龄：");
        int age = EMSUtility.readInt();
        System.out.print("工资：");
        double salary = EMSUtility.readDouble();
        System.out.print("电话：");
        String phone = EMSUtility.readString(20);
        System.out.print("邮箱：");
        String email = EMSUtility.readString(30);
        // 创建Employee对象
        Employee employee = new Employee();
        employee.setName(name);
        employee.setGender(gender);
        employee.setAge(age);
        employee.setSalary(salary);
        employee.setPhone(phone);
        employee.setEmail(email);

        // 通过调用管理器对象完成 员工添加
        boolean flag = empService.addEmployee(employee);
        if (flag) {
            System.out.println("---------------------添加完成---------------------");
            listAllEmployees();
        } else {
            System.out.println("---------------------添加失败---------------------");
        }
    }

    /**
     * 修改员工
     */
    private void modifyEmployee () {
        System.out.println("---------------------修改员工---------------------");
        listAllEmployees();
        System.out.print("请选择待修改员工编号(-1退出)：");
        // 获取用户输入的编号
        int no = EMSUtility.readInt();
        if (no == -1) {
            return;
        }
        // 根据编号定位要修改的目标对象
        Employee target = empService.getEmployee(no - 1);
        if (target == null) {
            System.out.println("--------------指定编号[" + no + "]的员工不存在-----------------");
            return;
        }
        System.out.println("<直接回车表示不修改>");
        System.out.print("姓名(" + target.getName() + ")：");
        String name = EMSUtility.readString(10, target.getName());
        target.setName(name);
        System.out.print("性别(" + target.getGender() + ")：");
        char gender = EMSUtility.readChar(target.getGender());
        target.setGender(gender);
        System.out.print("年龄(" + target.getAge() + ")：");
        int age = EMSUtility.readInt(target.getAge());
        target.setAge(age);
        System.out.print("工资(" + target.getSalary() + ")：");
        double salary = EMSUtility.readDouble(target.getSalary());
        target.setSalary(salary);
        System.out.print("电话(" + target.getPhone() + ")：");
        String phone = EMSUtility.readString(20, target.getPhone());
        target.setPhone(phone);
        System.out.print("邮箱(" + target.getEmail() + ")：");
        String email = EMSUtility.readString(50, target.getEmail());
        target.setEmail(email);
        System.out.println("---------------------修改完成---------------------");
        listAllEmployees();
    }

    /**
     * 删除员工
     */
    private void deleteEmployee () {
        System.out.println("---------------------删除员工---------------------");
        listAllEmployees();
        System.out.print("请选择待删除员工编号(-1退出)：");
        // 获取用户输入的编号
        int no = EMSUtility.readInt();
        if (no == -1) {
            return;
        }
        System.out.print("确认是否删除(Y/N)：");
        // 获取用户输入的确认
        char confirm = EMSUtility.readConfirmSelection();
        if (confirm == 'Y') {
            boolean flag = empService.removeEmployee(no - 1);
            if (flag) {
                System.out.println("---------------------删除完成---------------------");
                listAllEmployees();
            } else {
                System.out.println("---------------------删除失败---------------------");
            }
        }
    }

    /**
     * 员工列表
     */
    private void listAllEmployees() {
        System.out.println("---------------------------------员工列表--------------------------------------");
        System.out.println("编号\t姓名\t性别\t年龄\t工资\t\t电话\t\t邮箱");
        // 真的获取所有员工
        Employee[] allEmployees = empService.getAllEmployees();
        for (int i = 0; i < allEmployees.length; i++) {
            System.out.println((i + 1) + "\t" + allEmployees[i].say());
        }
        System.out.println("-----------------------------员工列表完成-------------------------------------");
    }

}

工具类（字符串录入长度限制处理）

import java.util.Scanner;
public class EMSUtility {
    private static Scanner scanner = new Scanner(System.in);
    /*
    读菜单选择
     */
    public static char readMenuSelection() {
        char c;
        for (; ; ) {
            String str = readKeyBoard(1, false);
            c = str.charAt(0);
            if (c != '1' && c != '2' &&
                    c != '3' && c != '4' && c != '5') {
                System.out.print("选择错误，请重新输入：");
            } else break;
        }
        return c;
    }
    /*
    读单个字符，用于添加
    */
    public static char readChar() {
        String str = readKeyBoard(1, false);
        return str.charAt(0);
    }
    /*
    读取单个字符，用于修改
     */
    public static char readChar(char defaultValue) {
        String str = readKeyBoard(1, true);
        return (str.length() == 0) ? defaultValue : str.charAt(0);
    }
    /*
    读取一个整数，用于添加
     */
    public static int readInt() {
        int n;
        for (; ; ) {
            String str = readKeyBoard(11, false);
            try {
                n = Integer.parseInt(str);
                break;
            } catch (NumberFormatException e) {
                System.out.print("数字输入错误，请重新输入：");
            }
        }
        return n;
    }
    /*
    读取一个整数，用于修改
     */
    public static int readInt(int defaultValue) {
        int n;
        for (; ; ) {
            String str = readKeyBoard(11, true);
            if (str.equals("")) {
                return defaultValue;
            }

            try {
                n = Integer.parseInt(str);
                break;
            } catch (NumberFormatException e) {
                System.out.print("数字输入错误，请重新输入：");
            }
        }
        return n;
    }
    /*
    读一个小数，用于添加
     */
    public static double readDouble() {
        double n;
        for (; ; ) {
            String str = readKeyBoard(12, false);
            try {
                n = Double.parseDouble(str);
                break;
            } catch (NumberFormatException e) {
                System.out.print("数字输入错误，请重新输入：");
            }
        }
        return n;
    }
    /*
    读一个小数，用于修改
     */
    public static double readDouble(double defaultValue) {
        double n;
        for (; ; ) {
            String str = readKeyBoard(12, true);
            if (str.equals("")) {
                return defaultValue;
            }

            try {
                n = Double.parseDouble(str);
                break;
            } catch (NumberFormatException e) {
                System.out.print("数字输入错误，请重新输入：");
            }
        }
        return n;
    }
    /*
    读一个字符串，用于添加
    参数limit标表示最多输入几个字符。即限制字符串长度
     */
    public static String readString(int limit) {
        return readKeyBoard(limit, false);
    }
    /*
    读一个字符串，用于修改
     */
    public static String readString(int limit, String defaultValue) {
        String str = readKeyBoard(limit, true);
        return str.equals("")? defaultValue : str;
    }
    /*
    读一个字符，通常用于读取正确字符。 Y/N
    是否退出，是否删除，用于确认用
     */
    public static char readConfirmSelection() {
        char c;
        for (; ; ) {
            String str = readKeyBoard(1, false).toUpperCase();
            c = str.charAt(0);
            if (c == 'Y' || c == 'N') {
                break;
            } else {
                System.out.print("选择错误，请重新输入：");
            }
        }
        return c;
    }
    /*
    输入一个字符串
    参数：int   boolean
    返回值：一个字符串
     */
    private static String readKeyBoard(int limit, boolean blankReturn) {
        String line = "";

        while (scanner.hasNextLine()) {
            line = scanner.nextLine();
            if (line.length() == 0) {
                if (blankReturn) return line;
                else continue;
            }

            if (line.length() < 1 || line.length() > limit) {
                System.out.print("输入长度（不大于" + limit + "）错误，请重新输入：");
                continue;
            }
            break;
        }

        return line;
    }
}

运行测试类

public class EmployeeMain {
    public static void main(String[] args) {
        EmployeeView employeeView=new EmployeeView();
        employeeView.enterMainMenu();
    }
}

测试展示

部分英文意思

Employee：员工

gender:性别

salary：薪水

EmployeeService：员工服务

getEmployee（index）：传入标记后获得员工方法

addEmployee（Employee）：传入员工后添加员工方法

listAllEmployees()：列出所有员工方法

EMSUtility：多功能