Welcome!

Related Topics: Java IoT

Java IoT: Article

Are You Using Abstract Classes, Polymorphism, and Interfaces?

Are You Using Abstract Classes, Polymorphism, and Interfaces?

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:

 

  • changeAddress
  • promote
  • giveDayOff
  • raiseSalary

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
A class is called abstract if it has at least one abstract (not implemented) method. The keyword abstract has to be placed in the definition of the method(s) and the class itself. For example, the class in Listing 1 has three concrete methods and one abstract. (The link to the source code is available below the article)

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.

Polymorphism
A programming language could be considered object-oriented if it supports inheritance, encapsulation, and polymorphism. The first two notions can be easily defined:

  • Inheritance lets you design a class by deriving it from an existing one. This feature allows you to reuse existing code without doing copy and paste. Java provides the keyword extends for declaring inheritance.
  • Encapsulation is the ability to hide and protect data. Java has access-level qualifiers such as public, private, and protected to control who can access class variables and methods. There is also so-called package-level protection, which is automatically engaged if you don't use any of the access-level keywords.
  • Polymorphism, though, is easier to understand through an example. Let's look at the classes Person, Employee, and Consultant from a different angle. We'll populate a Vector, mixing up the instances of classes Employee and Consultant - in real life this information usually comes from a database. For example, a program could get the person's work status from the database and instantiate an appropriate concrete class. The class Promoter (see Listing 4) will give an additional vacation day and increase the salary or hourly rate of every worker by 5%.

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...
Class Person: Adding a day off
Class Employee:Increasing salary by 5%
Class Person: Promoting a worker...
Class Person: Adding a day off
Class Consultant: Increasing hourly rate by 5%
Class Person: Promoting a worker...
Class Person: Adding a day off
Class Employee:Increasing salary by 5%
Class Person: Promoting a worker...
Class Person: Adding a day off
Class Employee:Increasing salary by 5%

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.

Interfaces
A similar functionality could be implemented using Java interfaces. We'll keep working with a modified version of the ancestor class Person because it has such useful methods as changeAddress and giveDayOff. But this class doesn't have to be abstract anymore because the method raiseSalary will be moved to a Java interface. The method promote won't be needed; we'd rather make the method giveDayOff available to descendants of the class Person by changing the private access level to protected (see line 8 in Listing 6).

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:

public class Employee
implements Payable, Bonus {
...
if (empLevel==JUNIOR_LVL){
//apply the rules for juniors
}
}

public class Consultant
implements Payable, Bonus {
...
}

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:

 

class MyWindow implements ActionListener, WindowListener{S}

During evolution, an Employee can obtain multiple behaviors, for example

 

class Employee extends Person
implements Payable, Transferable,
Sueable, Bonus {...}

Consultants such as myself are usually more primitive creatures and can be defined as follows:

class Consultant extends Person
implements Payable, Sueable {...}

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();
Consultant con = new Consultant();
Payable person1 = (Payable) emp;
Payable person2 = (Payable) con;

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:

Class Employee:Increasing salary by 5%
Class Consultant: Increasing hourly rate by 5%
Class Employee:Increasing salary by 5%
Class Employee:Increasing salary by 5%

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 technical interviews, probably the most frequently asked question is, "What's the difference between Java abstract classes and interfaces?" While interviewing Java programmers, I also found out that only half of the job applicants could properly complete the assignment described at the beginning of this article.

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.

Summary
Use of abstract classes, interfaces, and polymorphism improves the design of any project by making it more readable and easily extensible. This also makes your code more compact and elegant.

More Stories By Yakov Fain

Yakov Fain is a Java Champion and a co-founder of the IT consultancy Farata Systems and the product company SuranceBay. He wrote a thousand blogs (http://yakovfain.com) and several books about software development. Yakov authored and co-authored such books as "Angular 2 Development with TypeScript", "Java 24-Hour Trainer", and "Enterprise Web Development". His Twitter tag is @yfain

Comments (4)

Share your thoughts on this story.

Add your comment
You must be signed in to add a comment. Sign-in | Register

In accordance with our Comment Policy, we encourage comments that are on topic, relevant and to-the-point. We will remove comments that include profanity, personal attacks, racial slurs, threats of violence, or other inappropriate material that violates our Terms and Conditions, and will block users who make repeated violations. We ask all readers to expect diversity of opinion and to treat one another with dignity and respect.


Latest Stories
The platform combines the strengths of Singtel's extensive, intelligent network capabilities with Microsoft's cloud expertise to create a unique solution that sets new standards for IoT applications," said Mr Diomedes Kastanis, Head of IoT at Singtel. "Our solution provides speed, transparency and flexibility, paving the way for a more pervasive use of IoT to accelerate enterprises' digitalisation efforts. AI-powered intelligent connectivity over Microsoft Azure will be the fastest connected pat...
There are many examples of disruption in consumer space – Uber disrupting the cab industry, Airbnb disrupting the hospitality industry and so on; but have you wondered who is disrupting support and operations? AISERA helps make businesses and customers successful by offering consumer-like user experience for support and operations. We have built the world’s first AI-driven IT / HR / Cloud / Customer Support and Operations solution.
ScaleMP is presenting at CloudEXPO 2019, held June 24-26 in Santa Clara, and we’d love to see you there. At the conference, we’ll demonstrate how ScaleMP is solving one of the most vexing challenges for cloud — memory cost and limit of scale — and how our innovative vSMP MemoryONE solution provides affordable larger server memory for the private and public cloud. Please visit us at Booth No. 519 to connect with our experts and learn more about vSMP MemoryONE and how it is already serving some of...
Darktrace is the world's leading AI company for cyber security. Created by mathematicians from the University of Cambridge, Darktrace's Enterprise Immune System is the first non-consumer application of machine learning to work at scale, across all network types, from physical, virtualized, and cloud, through to IoT and industrial control systems. Installed as a self-configuring cyber defense platform, Darktrace continuously learns what is ‘normal' for all devices and users, updating its understa...
Codete accelerates their clients growth through technological expertise and experience. Codite team works with organizations to meet the challenges that digitalization presents. Their clients include digital start-ups as well as established enterprises in the IT industry. To stay competitive in a highly innovative IT industry, strong R&D departments and bold spin-off initiatives is a must. Codete Data Science and Software Architects teams help corporate clients to stay up to date with the mod...
As you know, enterprise IT conversation over the past year have often centered upon the open-source Kubernetes container orchestration system. In fact, Kubernetes has emerged as the key technology -- and even primary platform -- of cloud migrations for a wide variety of organizations. Kubernetes is critical to forward-looking enterprises that continue to push their IT infrastructures toward maximum functionality, scalability, and flexibility. As they do so, IT professionals are also embr...
Platform9, the leader in SaaS-managed hybrid cloud, has announced it will present five sessions at four upcoming industry conferences in June: BCS in London, DevOpsCon in Berlin, HPE Discover and Cloud Computing Expo 2019.
At CloudEXPO Silicon Valley, June 24-26, 2019, Digital Transformation (DX) is a major focus with expanded DevOpsSUMMIT and FinTechEXPO programs within the DXWorldEXPO agenda. Successful transformation requires a laser focus on being data-driven and on using all the tools available that enable transformation if they plan to survive over the long term. A total of 88% of Fortune 500 companies from a generation ago are now out of business. Only 12% still survive. Similar percentages are found throug...
When you're operating multiple services in production, building out forensics tools such as monitoring and observability becomes essential. Unfortunately, it is a real challenge balancing priorities between building new features and tools to help pinpoint root causes. Linkerd provides many of the tools you need to tame the chaos of operating microservices in a cloud native world. Because Linkerd is a transparent proxy that runs alongside your application, there are no code changes required. I...
In his general session at 21st Cloud Expo, Greg Dumas, Calligo’s Vice President and G.M. of US operations, discussed the new Global Data Protection Regulation and how Calligo can help business stay compliant in digitally globalized world. Greg Dumas is Calligo's Vice President and G.M. of US operations. Calligo is an established service provider that provides an innovative platform for trusted cloud solutions. Calligo’s customers are typically most concerned about GDPR compliance, application p...
Modern software design has fundamentally changed how we manage applications, causing many to turn to containers as the new virtual machine for resource management. As container adoption grows beyond stateless applications to stateful workloads, the need for persistent storage is foundational - something customers routinely cite as a top pain point. In his session at @DevOpsSummit at 21st Cloud Expo, Bill Borsari, Head of Systems Engineering at Datera, explored how organizations can reap the bene...
"NetApp's vision is how we help organizations manage data - delivering the right data in the right place, in the right time, to the people who need it, and doing it agnostic to what the platform is," explained Josh Atwell, Developer Advocate for NetApp, in this SYS-CON.tv interview at 20th Cloud Expo, held June 6-8, 2017, at the Javits Center in New York City, NY.
Druva is the global leader in Cloud Data Protection and Management, delivering the industry's first data management-as-a-service solution that aggregates data from endpoints, servers and cloud applications and leverages the public cloud to offer a single pane of glass to enable data protection, governance and intelligence-dramatically increasing the availability and visibility of business critical information, while reducing the risk, cost and complexity of managing and protecting it. Druva's...
Kubernetes as a Container Platform is becoming a de facto for every enterprise. In my interactions with enterprises adopting container platform, I come across common questions: - How does application security work on this platform? What all do I need to secure? - How do I implement security in pipelines? - What about vulnerabilities discovered at a later point in time? - What are newer technologies like Istio Service Mesh bring to table?In this session, I will be addressing these commonly asked ...
BMC has unmatched experience in IT management, supporting 92 of the Forbes Global 100, and earning recognition as an ITSM Gartner Magic Quadrant Leader for five years running. Our solutions offer speed, agility, and efficiency to tackle business challenges in the areas of service management, automation, operations, and the mainframe.