When to use interface and abstract class in Java? what is the difference between them?
When to use interface and abstract class in java with real time example. interface vs abstract class in oops. difference between interface and abstract class.
This is very popular interview question for the beginners as well for experienced.
interface Vs abstract class in Java.
Interface:
Interface is used when you want to define a contract and you don't know anything about implementation. (here it is total abstraction as you don't know anything.)
Abstract class:
Abstract class is used when you know something and rely on others for what you don't know.(here it is partial abstraction as some of the things you know and some you don't know.)
Now, Let's understand above difference between Interface and Abstract class with real world project example.
When to use Interface
Scenario,
Consider we want to start a service like "makemytrip.com" or "expedia.com", where we are responsible for displaying the flights from various flight service company and place an order from customer.
Lets keep our service as simple as,
- Displaying flights available from vendors like "airasia", "british airways" and "emirates".
- Place and order for seat to respective vendor.
How should we design our application considering interfaces and abstract class? In this scenario, interface is useful or abstract class?
Remember, In this application, we don't own any flight. we are just a middle man/aggregator and our task is to first enquire "airasia", then enquire "british airways" and at last enquire "emirates" about the list of flights available and later if customer opts for booking then inform the respective flight vendor to do booking.
For this, first we need to tell "airasia", "british airways" and "emirates" to give us list of flights, internally how they are giving the list that we don't care.
- This means I only care for method name "getAllAvailableFlights()"
"getAllAvailableFlights()" from "airasia" may have used SOAP service to return list of flights.
"getAllAvailableFlights()" from "british airways" may have used REST service to return list of flights.
"getAllAvailableFlights()" from "emirates" may have used CORBA service to return list of flights.
but we don't care how it is internally implemented and what we care is the contract method "getAllAvailableFlights" that all the flight vendor should provide and return list of flights.
- Similarly, for booking I only care for method name "booking()" that all vendors should have, internally how this vendors are doing booking that I don't care.
To conclude: We know contract.
So we can say that we know the contract that irrespective of who the Flight
vendor is, you need "getAllAvailableFlights()" and "booking()" method from
them to run our aggregator service.
In this situation, Interface is useful because we are not aware of the implementation of all the 2 methods required, and what we know is the contract methods that vendor(implementer) should provide. so due to this total abstraction and for defining the contract, interface is useful in this place.
Technically, we need to design our interface somewhat like below,
FlightOpeartions.java(Contract)
package javabypatel;
public interface FlightOpeartions {
void getAllAvailableFlights();
void booking(BookingObject bookingObj);
}
BookingObject.java
package javabypatel;
public class BookingObject {}
BritishAirways.java (Vendor 1)
package javabypatel;
public class BritishAirways implements FlightOpeartions {
public void getAllAvailableFlights(){
//get british airways flights in the way
//they told us to fetch flight details.
}
public void booking(BookingObject flightDetails){
//place booking order in a way British airways
//told us to place order for seat.
}
}
Emirates.java (Vendor 2)
package javabypatel;
public class Emirates implements FlightOpeartions {
public void getAllAvailableFlights(){
//get Emirates flights in the way
//they told us to fetch flight details.
}
public void booking(BookingObject flightDetails){
//place booking order in a way Emirates airways
//told us to place order for seat.
}
}
How Interface achieve Polymorphism.
Note:
Interface just speak about the contract capabilities and don't know anything about implementation.
Example:
Interface can very well say that "I can get all available flights", "I can do booking" because they have that capability, but they don't know "How exactly to get all available flights", "How exactly to do booking" and this is the job of class that accepted Interface contract in other words it is the job of class that implements that interface.
Interface helps in achieving dynamic Polymorphism because it focus only on capabilities and don't care about implementation which implemented class MUST take care of as define in interface contract.
Interface very well knows what methods it is capable of calling, and it is sure that class that implements this interface definitely has given the body to those methods, so it blindly calls
"interfaceReference.capableMethods()",
(in our example: flightOperationsReference.getAllAvailableFlights())
It doesn't care, what object has been assigned to "interfaceReference", (it can be of any class that implemented it), but when interface calls "interfaceReference.capableMethods()", "capableMethods()" method will definitely be called on class whose object has been assigned to "interfaceReference" and that is the contract that every implementer of interface should provide body to methods defined in interface.
When to use Abstract class
Scenario,
Consider
we want to start a service like Bulk SMS sender, where we take orders from various telecom vendors like Airtel, France Telecom, Vodafone etc.
For this, we don't have to setup your own infrastructure for sending SMS like Mobile towers but we need to take care of government rules like after 9PM, we should not send promotional SMS, we should also not send SMS to users registered under Do Not Disturb(DND) service etc. Remember, we need to take care of government rules for all the countries where we are sending SMS.
Note: for infrastructure like towers, we will be relying on vendor who is going to give us order.
Example, In case of,
Vodafone request us for bulk messaging, in that case we will use Vodafine towers to send SMS.
Airtel request us for bulk messaging, in that case we will use Airtel towers to send SMS.
What our job is to manage Telecom Regulations for different countries where we are sending SMS.
So what all methods we require would be somewhat like below,
public void eastablishConnectionWithYourTower(){
//connect using vendor way.
//we don't know how, candidate for abstract method
}
public void sendSMS(){
eastablishConnectionWithYourTower();
checkForDND();
checkForTelecomRules();
//sending SMS to numbers...numbers.
destroyConnectionWithYourTower()
}
public void destroyConnectionWithYourTower(){
//disconnect using vendor way.
//we don't know how, candidate for abstract method
}
public void checkForDND(){
//check for number present in DND.
}
public void checkForTelecomRules(){
//Check for telecom rules.
}
Out of above 5 methods,
- Methods we know is "sendSMS()", "checkForDND()", "checkForTelecomRules()".
- Methods we don't know is "eastablishConnectionWithYourTower()", "destroyConnectionWithYourTower()".
we know how to check government rules for sending SMS as that is what our job is but
we don't how to eastablish connection with tower and how to destroy connection with tower because this is purely customer specific, airtel has its own way, vodafone has its own way etc.
So in the given scenario, we know some methods but there also exist some methods which are unknown and depends on customers.
In this case, what will be helpful, abstarct class or interface?
In this case, Abstract class will be helpful, because you know partial things like "checkForDND()", "checkForTelecomRules()" for sending sms to users but we don't know how to eastablishConnectionWithTower() and destroyConnectionWithTower() and need to depend on vendor specific way to connect and destroy connection from their towers.
Let's see how our class will look like,
abstract class SMSSender{
abstract public void eastablishConnectionWithYourTower();
public void sendSMS(){
/*eastablishConnectionWithYourTower();
checkForDND();
checkForTelecomRules();
sending SMS to numbers...numbers.*/
}
abstract public void destroyConnectionWithYourTower();
public void checkForDND(){
//check for number present in DND.
}
public void checkForTelecomRules(){
//Check for telecom rules
}
}
class Vodafone extends SMSSender{
@Override
public void eastablishConnectionWithYourTower() {
//connecting using Vodafone way
}
@Override
public void destroyConnectionWithYourTower() {
//destroying connection using Vodafone way
}
}
class Airtel extends SMSSender{
@Override
public void eastablishConnectionWithYourTower() {
//connecting using Airtel way
}
@Override
public void destroyConnectionWithYourTower() {
//destroying connection using Airtel way
}
}
So to summarize,
For Interface:
Interface is used when you don't know anything about implementation but know the contract that implementer should have to accomplish the task.
For Abstract class:
Abstract class is used when you know partial implementation, where say out of 5 methods, you know implementation of 3 methods and don't know implemenatation of 2 methods in that case 2 methods will be abstract and you need to rely on implementer as a contract to must provide body of abstract methods to accomplish the task.
Other differences between interface and abstract class in Java.
| No |
abstract class |
interface |
| 1 |
Abstract
class can have both abstract methods (incomplele. methods without body)
and non-abstract methods(complete. methods with body). |
Interface can only have abstract methods till Java 7.
In Java 8, Interface can have non-abstract default and static methods. |
| 2 |
Abstract class can extends only one class and can implements multiple interfaces. |
Interface can only extends other interfaces. |
You may also like to see
Enjoy !!!!
If you find any issue in post or face any error while implementing, Please comment.
