Java作业 题目：16版.真实员工数统计

题目：16版.真实员工数统计

该资源支持按部自动给分，评分规则如下：

sjkdfhslkfdhdsiog函数定义测试

sjkdfhslkfdhdsiog函数定义测试

sjkdfhslkfdhdsiog函数定义测试

sjkdfhslkfdhdsiog函数定义测试

-->

题干：

1、实验要求

本实验要求：通过给定的员工列表，显示工号不重复的员工信息。

1-1. 业务介绍：

1-1.1. 本实验给定一组员工数据，要求将工号不重复的员工数据输出到控制台。

1）本实验提供3个员工的完整数据（工号、姓名、部门、薪水）。

2）要求通过重写Object类的equals方法，判断工号的重复性。

3）要求通过重写Object类的toString方法，输出员工数据。

1-2. 创建工程并配置环境：

1-2.1. 工程名：SE_JAVA_EXP_E030。

1-2.2. 创建包，取名：cn.campsg.java.experiment。

1-3. 创建员工实体类及相关属性：

1-3.1. 限制1. 在包cn.campsg.java.experiment下创建员工实体类：Employee。

1-3.2. 分别为Employee实体类定义如下属性：

1）员工工号：字符串类型。

2）员工姓名：字符串类型。

3）员工薪水：浮点类型。

4）隶属部门：字符串类型。

1-3.3. 为Employee类中的各属性分别创建getter和setter方法。

1-4. 重写equals函数：

1-4.1. 在Employee类中，重写父类Object的equals函数。

1-4.2. 在equals函数中，判断当前员工对象与传入的员工对象之间工号是否一致。

1-4.3. 如果一致则表示员工数据相同，返回true，否则表示数据不同，返回false。

1-4.4. 说明1：equals函数用于判断两个相同类型对象的数据一致性。

1-4.5. 说明2：双等于（==）和equals不同，用于判断两个对象的地址一致性。

1-5. 重写toString函数：

1-5.1. 在Employee类中，重写父类Object的toString函数。

1-5.2. 将Employee类中所有属性组织成以下格式并返回：

"工号: " + 工号 + ",姓名: " + 姓名  + ",部门: " + 部门 + ",薪水: " + 薪水

1-6. 编写工号判重函数：

1-6.1. 限制1. 在包cn.campsg.java.experiment下创建主类：MainClass。

1-6.2. 限制2. 在MainClass中，创建判重函数：isRepeat。

1-6.3. 该函数用于判断多个员工之间工号是否一致。

1-7. 显示有效员工信息：

1-7.1. 在主入口main函数中，通过访问isRepeat获取工号不重复的员工数据。

1-7.2. 通过调用员工实体的toString函数，向控制台输出员工数据。

1-7.3. 最后，在控制台上显示："本公司有效员工数: " + 不重复的员工数。

2、实现思路

2-1. 按实验要求创建工程并配置环境。

2-2. 创建员工实体类及相关属性：

2-2.1. 在包cn.campsg.java.experiment下创建员工类：Employee。

2-2.2. 创建成员变量属性：

1）员工工号：字符串类型 no。

2）员工姓名：字符串类型 name。

3）员工薪水：浮点类型 salary。

4）隶属部门：字符串类型 department。

2-2.3. 为成员变量添加setter和getter方法。

2-2.4. 创建Employee类的0参构造器。

2-2.5. 创建Employee类的2参构造器，属性初始化如下：

1）员工工号：no = 构造体no参数。

2）员工姓名：name = 构造体name参数。

3）员工薪水：salary = 构造体salary参数。

4）隶属部门：department = 构造体department参数。

2-3. 重写equals函数：

2-3.1. 在Employee内，重写父类Object的equals方法，形式如下：

  + 提示

/**

* 判断本对象与其他Employee对象的业务数据是否一致

* @param o 其他Employee对象

* @return true:业务数据一致,false:业务数据不一致

*/

@Override

  public boolean equals(Object o) {

}

1） 重写父类的方法，可通过Eclipse中的自动化工具实现：

  单击右键，选择Source à Override/Implement Methods

  勾选equals函数，即可简便的实现重写父类的方法。

2-3.2. 首先，判断传入的对象是否为空，如果为空，直接返回false。

2-3.3. 其次，判断传入的对象是否是Employee类的实例，如果不是则返回false。

1） 提示：通过 instanceof 关键字判断传入的参数是否为Employee。

2-3.4. 结束判断后，将传入的对象强制类型转换为Employee对象。

2-3.5. 最后，判断传入对象的工号和当前员工对象的工号是否相同。

1） 若不相同，则返回false。

2） 若相同，则返回true。

  + 提示

//传入的对象不是Employee类型

  if(!(o instanceof Employee))

      return false;

Employee emp = (Employee)o;

//员工的工号不一致，则认定两个员工的业务数据不一致

  if(!emp.getNo().equals(this.getNo()))

      return false;

2-4. 重写toString函数：

2-4.1. 在Employee内，重写父类Object的toString方法。

2-4.2. 新建StringBuffer类型的对象，buffer。

1） 技术常识：StringBuffer比String类在字符串拼接时效率更高。

2-4.3. 利用StringBuffer类的append方法拼接员工类的属性，如以下形式：

"工号: " + 工号 + ",姓名: " + 姓名  + ",部门: " + 部门 + ",薪水: " + 薪水

2-4.4. 返回拼接好的字符串：

1）提示：通过调用buffer对象的toString方法返回拼接结果。

2-5. 编写工号判重函数：

2-5.1. 在包cn.campsg.java.experiment下创建主类：MainClass。

2-5.2. 在MainClass内定义静态的isRepeat函数，形式如下：

  + 提示

/**

* 判断员工工号是否重复

* @param index 当前员工的数组索引

* @param employees 员工测试数据数组

* @return true:重复，false:不重复

*/

  public static boolean isRepeat(int index,Employee[] employees) {

}

2-5.3. 从employees数组中取出待判定员工，索引值 = index的员工对象。

2-5.4. 利用循环判断，待判定员工对象与数组中其他成员的工号是否一致：

1）循环初始值：0

2）循环边界：员工对象数组的长度。

2-5.5. 首先，确保待判定员工对象只能与数组中的其他成员进行工号对比：

  + 提示

  if(emp == employees[i])

  continue;

1） 双等于（==）用于判断对象地址是否相同。

2） 如果对象地址相同，表明待判定员工对象与数组中的成员为同一对象，无需判断

2-5.6. 其次，调用待判定员工对象的equals方法，判断工号是否重复。

1）如果工号重复，对外返回true。

2）如果工号不重复，对外返回false。

2-6. 显示有效员工信息：

2-6.1. 在入口函数main中，创建员工对象数组，形式如下：

1）员工数组长度：3

编号	no属性	name属性	Salary属性	Department属性
1	1001	张一	5000.0f	销售部
2	1002	王二	6500.0f	销售部
3	1001	Alan	15000.0f	研发部

  + 提示

Employee[] employees = new Employee[3];

employees[0] = new Employee("1001","张一","销售部",5000.0f);

2-6.2. 利用for循环遍历员工数组，显示工号不重复的员工信息：

1）循环初始值：0

2）循环边界：员工对象数组的长度。

2-6.3. 调用isRepeat，判断数组中的每个成员与其他数组成员的工号是否有重复：

1）isRepeat方法的1参，循环变量。

2）isRepeat方法的2参，员工数组。

2-6.4. 打印工号不重复的员工信息：

1）如果isRepeat返回false，表示该员工在数组中无重复信息。

2）通过调用员工实体的toString函数，向控制台输出员工数据。

注意：通过控制台输出语句输出员工信息时，toString会被自动调用。

2-6.5. 打印有效员工数：

1）在判重循环外定义计数变量：count。

2）在判重循环内，如果isRepeat返回false，则count加1。

3）循环结束后，向控制台输出："本公司有效员工数: "  + count。

package cn.campsg.java.experiment;

public class Employee {//2 2.1
    String no;
    String name;
    float salary;
    String department;//2 2.2
    public String getNo() {    return no;}
    public void setNo(String no) {this.no = no;}
    public String getName() {return name;}
    public void setName(String name) {this.name = name;}
    public float getSalary() {return salary;}
    public void setSalary(float salary) {this.salary = salary;}
    public String getDepartment() {    return department;}
    public void setDepartment(String department) {    this.department = department;}//2 2/3

    public Employee() {    }//2-2.4无参构造
    public Employee(String no,String name,    String department,float salary) {
        this.no = no;
        this.name = name;
        this.salary = salary;
        this.department = department;
    }//2-2.5 4参构造器
    //重写equals
    @Override
    public boolean equals(Object obj) {
        //首先，判断传入的对象是否为空，如果为空，直接返回false。
        if(obj == null) {
            return false;
        }
        if(!(obj instanceof Employee))
              return false;
          Employee emp = (Employee)obj;
          //员工的工号不一致，则认定两个员工的业务数据不一致
          if(!emp.getNo().equals(this.getNo()))
              return false;
            return true;
    }
    @Override
    public String toString() {
        StringBuffer buffer = new StringBuffer("工号");
        buffer.append(no);
        buffer.append(",姓名");
        buffer.append(name);
        buffer.append(",部门");
        buffer.append(department);
        buffer.append(",薪水");
        buffer.append(salary);
        return buffer.toString();
    }

}

Employee

 package cn.campsg.java.experiment;

 public class MainClass {
     public static boolean isRepeat(int index,Employee[] employees) {
         Employee emp = employees[index];
         for(int i = 0;i < employees.length; ++i) {
             if(emp == employees[i]) {
                 continue;
             }
             if(emp.equals(employees[i]) == true) {
                 return true;
             }
         }
         return false;
     }
     public static void main(String argv[]) {
         Employee[] employees = new Employee[3];
         employees[0] = new Employee("1001","张一","销售部",5000.0f);
         employees[1] = new Employee("1002","王二","销售部",6500.0f);
         employees[2] = new Employee("1001","Alan","研发部",15000.0f);

         int count = 0;

         for(int i=0;i<employees.length;++i){

             if(isRepeat(i,employees)==false)
             {
                 count++;
                 System.out.println(employees[i].toString());
             }
     }
     System.out.println("本公司有效员工数: "  + count);
 }
 }

MainClass