6

I am creating a employee wage system. I have an abstract Employee class. WageEmployee and Manager extend Employee. Then Programmer and SalesPerson extend WageEmployee.

My problem is that I want to create a SalesManager. The SalesManger has thier pay computed by adding commission and a salary. So they have type SalesPerson and Manager.

What should I make an interface and what should SalesPerson extend?

It is only natural to extend SalesManager from manager, then make SalesPerson an interface. But I cannot because it inherits from WageEmployee...

How do I get this to work. properly?

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!"); }

}

Improve this question
4
  • Is there functionality that is being inherited, or is it just methods? Commented Jul 12, 2012 at 23:36
  • 1
    I'd, personally, start with all interfaces, this will give you the greatest deal of flexibility. Then you need to figure out from there which abstract implementations are going to produce the least amount of re-work. The only other solution you have is to use a proxy style solution. That is, the functionality of one interface is actually implemented by a proxy object which the parent object maintains a reference to and calls on it's behalf. Commented Jul 12, 2012 at 23:40
  • 1
    Interfaces and object composition are your friends in this case. Commented Jul 12, 2012 at 23:41
  • 3
    You should probably start looking into another way of modeling your employees. Commented Jul 12, 2012 at 23:45

3 Answers 3

Reset to default
10

Call me crazy, but you may not need to subclass to deal with the different pay methods here. Instead, consider using the Strategy pattern to figure out wages/sales commissions. That way, you have a class Employee and its subclass SalesEmployee; each of these would have as a property a PayStrategy object, which can have concrete subclasses WagePayStrategy and CommissionPayStrategy. If you define the right methods on PayStrategy (could be an interface or abstract class), you can have your Employee instances ask the strategy objects what pay the employee gets for certain inputs (hours worked, sales made, etc.).

Consider the following trivial example:

interface PayStrategy {
    public float getPay(float hoursWorked, float salesMade);
}

class WageStrategy implements PayStrategy {
    public float getPay(float hoursWorked, float salesMade) {
        return hoursWorked * 8.5;
    }
}

class CommissionStrategy implements PayStrategy {
    public float getPay(float hoursWorked, float salesMade) {
        return salesMade * 0.5 + hoursWorked * 5.0;
    }
}

abstract class Employee {
    public PayStrategy payStrategy; // assign as needed

    public float getPay(float hoursWorked, float salesMade) {
        return this.payStrategy.getPay(hoursWorked, salesMade);
    }
}

Note how you can change the pay strategy for any given employee without needing a different class, giving you more flexibility and encapsulation around that algorithm.

Improve this answer
Sign up to request clarification or add additional context in comments.

2 Comments

It's also possible to have PayStrategy.getPay take a single generic float value. Then the SalesManager could have a combined strategy implementation like so: public float getPay(float ignored) { return wageStrategy.getPay(getHoursWorked()) + commissionStrategy.getPay(getSalesMade()); } where the SalesManager class has a salesMade and an hoursWorked field.
@AngerClown: True, but then what's the point of the parameter? You might as well just place getHoursWorked() and getSalesMade() (even if abstractly) on Employee, fix up default return values (e.g. 0) where they don't matter, and drop float ignored altogether. If you're deliberately calling parameters ignored, something's amiss IMO.
1

Employee has methods getFixedSalary() and getComissionSalary().

You can create abstract subclasses SalariedEmployee (getComissionSalary always returns 0) and make Programmer and SalesPerson expand it. SalesManager implements directly Employee.

Or all the classes directly inherit from Employee, to grant maximum flexibility should salary scales change some day (I would go this way). Write helper methods to avoid duplicating code but given you still options to change the modus operandi if needed later.

Improve this answer

Comments

1

When you extend Classes, you usually want to keep some sort of functionality and you add onto it by extending it. With an Interface, it gives you list of methods that an object will have.

It looks like you have Employees and Managers, and you have to decide where the functionality is going to be extended from. Without looking at your code or object model, it looks like everyone's an Employee and some of them are Manager. So it looks like you need to decide what extra a Manager does that makes it separate from an Employee. Then everything will extend Employee, and extend subclasses of Employee (WageEmployee, SalaryEmployee, etc), then the ones that are Managers, they implement a Manager interface. So you can have a SalesPerson extending a WageEmployee and then a SalesManager extending SalesPerson that implements Manager.

Improve this answer

Comments

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service and acknowledge you have read our privacy policy.