Most Read This Week
Are You Using Abstract Classes, Polymorphism, and Interfaces?
Are You Using Abstract Classes, Polymorphism, and Interfaces?
By: Yakov Fain
Sep. 1, 2003 12:00 AM
If the answer is no, at a minimum your project needs a code review.
Let's work on the following assignment: a company has employees and consultants. Design classes with and without the use of inheritance to represent the people who work for this company. The classes should have the following methods:
Promotion means giving one day off and raising the salary by a specified percentage. For employees, the method raiseSalary should raise the yearly salary and, for consultants, it should increase their hourly rate.
Abstract classes cannot be instantiated, but they allow you to create superclasses that implement some of the functionality, while leaving one or more methods to be implemented in subclasses.
The class Person can contain dozens of concrete methods that are the same for every person, such as changeAddress and giveDayOff, but since the process of raising a salary is different for employees and consultants, the method raiseSalary should remain abstract. Please note that even though this method is abstract, it could be called in an abstract class because by the time the concrete class is instantiated, the method will be already implemented. Since we have two types of workers, let's create subclasses Employee and Consultant and implement the method raiseSalary based on different rules (see Listings 2 and 3).
The designer of the class Person may not know the specifics of the raising salary process, but this does not stop him or her from calling the method raiseSalary. Programmers writing subclasses are forced to write an implementation of this method according to its signature declared in the abstract class. If they declare a method raiseSalary with a different argument list, this will be considered method overloading and the subclass will remain abstract. The class Promoter in Listing 4 shows how to use the classes Employee and Consultant for promoting workers.
Please note that even though we cast every object from the collection workers to the ancestor's type Person in line 17, Listing 4, the variable pers can hold references to its descendent objects. The actual object type will be evaluated during runtime only. This feature of object-oriented languages is called runtime or late binding.
The output of the class Promoter will look as follows:
Class Person: Promoting a worker...
Both classes Employee and Consultant are inherited from the same base class Person. Instead of having different methods for increasing the worker's compensation based on its type, we give a polymorphic behavior to the method raiseSalary, which applies different business logic depending on the type of object from the collection. Even though it looks as if we're calling the same method promote, this is not the case. Since the actual object type is evaluated during runtime, the salary is raised properly according to this particular object's implementation of the method raiseSalary. This is polymorphism in action.
The while loop in the class Promoter will remain the same even if we add some other types of workers inherited from the class Person. For example, to add a new category of worker - a foreign contractor - we'll have to create a class Foreign- Contractor derived from the class Person and implement the method raiseSalary there. The class Promoter will keep casting all these objects to the type Person during runtime and call the method raiseSalary of the proper object.
Polymorphism allows you to avoid using switch or if statements with the expensive operator instanceof. Listing 5 shows an ugly alternative to our while loop from the class Promoter that assumes there is no abstract method raiseSalary, but we have separate promote methods in each subclass of the Person. This code would work slower than the polymorphic version from the class Promoter, and the if statement would have to be modified every time a new type of worker is added.
Here's the "interface way" to ensure that each person in the firm receives the proper salary raise despite the differences in payroll calculation.
Let's define an interface Payable in Listing 7. More than one class can implement this interface (see Listing 8). When the class Consultant declares that it implements interface Payable, it promises to write implementations for all methods declared in this interface - in our case it's just one method raiseSalary. Why is it so important that the class will "keep the promise" and implement all the interface's methods? In many cases interface is a description of some behavior. In our case behavior Payable means the existence of the method boolean raiseSalary(int percent). If any other class knows that Employee implements Payable, it can safely call any method declared in the Payable interface (see the interface example in Listing 9).
Let's forget for a moment about employees and consultants and switch to the Java AWT listeners and events. When a class declares that it implements the interface java.awt.Action- Listener, a JVM will call the method actionPerformed on this class whenever the user clicks on the window's button, and in some other cases as well. Try to imagine what would happen if you forgot to include the method actionPerformed in your class. The good news is that your class won't even compile if not all methods declared in the interface were implemented. The java.awt.WindowListener interface declares seven methods, and even if you are interested only in the windowClosing one, you must include six additional empty-bodied methods to compile the class (window adapters simplify this process, but they are beyond the scope of this article).
While both abstract classes and interfaces can ensure that a concrete class will have all required methods, abstract classes can also contain implemented methods, but interfaces can't.
Beside method declarations, interfaces can contain final static variables. For example, let's say we have multiple bonus-level codes used in several classes during the calculation of new salaries. Instead of redefining these constants in every class that needs them, we can create the interface shown in Listing 10.
Now a small change in the class declaration will allow us to use these bonus levels as if they were declared in the class Employee:
Java does not allow multiple inheritance, which means a class can't have two independent ancestors, but you can use interfaces as a workaround. As you've seen in the example above, a class can implement multiple interfaces; it just needs to implement all methods declared in all interfaces. If your window needs to process button clicks and window closing events, you can declare a class as follows:
During evolution, an Employee can obtain multiple behaviors, for example
class Employee extends Person
Consultants such as myself are usually more primitive creatures and can be defined as follows:
class Consultant extends Person
But if a program such as Promoter is interested only in Payable functions, it can cast the object only to those interfaces it intends to use, for example:
Employee emp = new Employee();
Now we're ready to write a second version of the class Promoter that will use the classes Employee and Consultant defined in Listings 8 and 11.
The output of this program will look similar to the output of the class Promoter from Listing 4:
Line 18 of Listing 9 may look a little confusing: How can we call a concrete method raiseSalary on a variable of an interface type? Actually we call a method on a concrete instance of the Employee or a Consultant, but by casting this instance to the type Payable we are just letting the JVM know that we're only interested in the methods that were declared in this particular interface.
Java Technical Interviews
During the job interview your answers should be clear and short; you won't even have a chance to use all the material presented here. Here's one version of the answer to our problem.
If two classes have lots of common functionality, but some methods should be implemented differently, you could create a common abstract ancestor Person and two subclasses Employee and Consultant. The method raiseSalary must be declared abstract in the class Person while other methods should be concrete. This way we ensure that the subclasses do have the method named raiseSalary with a known signature, so we could use it in the ancestor without knowing its implementation. Java interfaces should also be considered in cases when the same method must be implemented in multiple classes - in this case we do not need to use abstract ancestors. Actually, interfaces could be your only option if a class already has an ancestor that can not be changed.
One good interview technique is to impress the interviewer by elaborating on a related topic. Discussion of abstract classes and interfaces gives you a good opportunity to show your understanding of polymorphism.
Reader Feedback: Page 1 of 1
Subscribe to the World's Most Powerful Newsletters
Today's Top Reads