Java，似乎找不到与我的继承有关的问题

Question

I am trying to find out my problem.

For some reason when I try to set the sales of a sales person it only sets the first SalesPerson founds sales to the last Salesperson sales set.

Here EmployeeDatabase holds and EmployeeList which is a container object of types of Employees.

I have code for the other classes but I think this is all the is needed... Sorry for the lack of comments in the code

My output:

John 12000.0
Set sales to: 12000.0
Joan 10000.0
Set sales to: 10000.0
Jack 5000.0
Set sales to: 5000.0
Name: John           Commision: 0.03 Sales: 5000.0
Name: Joan           Commision: 0.04 Sales: 0.0
Name: Jack           Commision: 0.02 Sales: 0.0

Payroll: 150.0

Code: EmployeeDatabase

public class EmployeeDatabase 
{

public static void main(String[] args) 
{
    EmployeeList emp = new EmployeeList();
    /*emp.enqueue(new SalesManager("Gee", 1000));
    emp.enqueue(new SalesManager("Gal", 1000));
    emp.enqueue(new SalesManager("Gem", 1000));*/
    emp.enqueue(new SalesPerson("John", 0.03));
    emp.enqueue(new SalesPerson("Joan", 0.04));
    emp.enqueue(new SalesPerson("Jack", 0.02));
    /*emp.enqueue(new Manager("Fred", 10000));
    emp.enqueue(new Manager("Frank", 5000));
    emp.enqueue(new Manager("Florence", 3000));
    emp.enqueue(new Programmer("Linda", 7));
    emp.enqueue(new Programmer("Larry", 5));
    emp.enqueue(new Programmer("Lewis", 3));*/

    /*emp.setHours("Linda", 35);
    emp.setHours("Larry", 23);
    emp.setHours("Lewis", 3);*/
    emp.setSales("John", 12000);
    emp.setSales("Joan", 10000);
    emp.setSales("Jack", 5000);
    /*emp.setSales("Gee", 4000);
    emp.setSales("Gal", 3000);
    emp.setSales("Gem", 2000);
    emp.setSalary("Gee", 1000);
    emp.setSalary("Gal", 2000);
    emp.setSalary("Gem", 3000);*/
    emp.display();
}
}

EmployeeList

import java.util.Iterator;
import java.util.LinkedList;
import java.util.Queue;


public class EmployeeList 
{
Queue<Employee> empList = new LinkedList<Employee>();

Employee find(String nm)
{
    Iterator<Employee> it = empList.iterator();
    while(it.hasNext())
    {
        Employee em = (Employee)it.next();
        if(!em.name.equals(nm))
        {
            return em;
        }   
    }
    return null;
}

double payroll()
{
    double payroll = 0.0;
    Iterator<Employee> it = empList.iterator();
    while(it.hasNext())
    {
        Employee em = (Employee)it.next();
        payroll += em.computePay(); 
    }
    return payroll;
}

void display()
{
    Iterator<Employee> it = empList.iterator();
    while(it.hasNext())
    {
        Employee em = (Employee)it.next();
        em.display();   
    }
    System.out.println("\nPayroll: " + payroll());
}

void enqueue(Employee e)
{
    empList.add(e);
}

void setHours(String nm, int hrs)
{
    Employee em = find(nm);
    /*if(em == null)
        return;*/
    em.setHours(hrs);
}

void setSalary(String nm, float salary)
{
    Employee em = find(nm);
    /*if(em == null)
        return;*/
    em.setSalary(salary);
}

void setSales(String nm, double sales)
{
    System.out.println(nm + " " + sales);
    Employee em = find(nm);
    /*if(em == null)
        return;*/
    em.setSales(sales);
}
}

Employee

abstract class Employee 
{
String name;

Employee() {}
Employee (String nm) { name = nm; }
abstract double computePay();
void display () {}
void setHours(double hrs) {}
void setSales(double sales) {}
void setSalary(double salary) { System.out.println("NO!"); }
 }

WageEmployee

public class WageEmployee extends Employee 
{
double rate;
double hours;

WageEmployee(String name)
{
    this.name = name;
    if(this.name.length() < 14)
    {
        while(this.name.length() < 14)
        {
            this.name += " ";
        }
    }
}
WageEmployee(String name, double rate)
{
    this.name = name;
    if(this.name.length() < 14)
    {
        while(this.name.length() < 14)
        {
            this.name += " ";
        }
    }
    this.rate = rate;
}

double computePay()
{
    return rate * hours;
}

void setHours(double hrs) 
{
    hours = hrs;
    System.out.println("Set Hours to: " + hours);
}

 void display () 
 {
     System.out.println("Name: " + name + " Hours: " + hours + " Rate: " + rate);
 }
}

SalesPerson

public class SalesPerson extends WageEmployee 
{
double comission;
double salesMade;

SalesPerson(String name, double commision) 
{
    super(name);
    this.comission = commision;
}

double computePay()
{
    return comission * salesMade;
}

void setSales(double sales) 
{
    salesMade = sales;
    System.out.println("Set sales to: " + salesMade);
}

void display () 
 {
     System.out.println("Name: " + name + " Commision: " + comission + " Sales: " + salesMade);
 }
}

Answer 1

There are two issues in this piece of code.

First, there is the extra ! in the find method.

if(!em.name.equals(nm)) should be if(em.name.equals(nm)) .

The second issue is the padding created in your wage employee constructor.

if(this.name.length() < 14)
{
    while(this.name.length() < 14)
    {
        this.name += " ";
    }
}`

This code makes so that the "John" you are looking for is actually "John " . Note the spacing. (Shoot, markdown eliminated most of it, but you get the idea of extra spacing at the end). This causes the names to never compare equal, resulting in a null pointer exception as you try to work with a non-existent employee.

There are three possible solutions to this. First, use the String.trim method on em.name before comparing. Second, pad your search name the same way as they are stored before comparing. Third, you might be able to just remove the padding altogether(I don't know your use case, but String.format might allow you to just pad only at output time).

Answer 2

You have a bug in your find method:

Employee find(String nm)
{
    Iterator<Employee> it = empList.iterator();
    while(it.hasNext())
    {
        Employee em = (Employee)it.next();
        if(!em.name.equals(nm)) // should be if(em.name.equals(nm))
        {
            return em;
        }   
    }
    return null;
}

This results in the first employee being returned for when setSales is invoked for later employees.