Abstract Class vs Interface: The Differences and the Similarities

If you’re sitting for a software engineering interview, the one question that you can expect to come your way is – the differences and similarities between Abstract Class and Interface. 

Abstract Classes and Interfaces are the fundamental blocks in Object-Oriented Programming. Both of these enable programmers to implement one of the more essential concepts of OOPs – Abstraction. While Abstract Classes and Interfaces are both used to implement the concept of Abstraction, the two are different in implementation and have different use cases. Abstract Classes and Interfaces might seem similar to a beginner, but they can’t be used interchangeably. 

In this article, we’ll look at the nuances of Abstract Classes, Interfaces, and the similarities and differences between the two. Keep in mind that Abstract Class and Interface is just a concept and can be implemented in any Object-Oriented Programing language of your choice. For consistency, any syntax that we use in this article to explain the concepts to you will be of Java. 

By the end of this article, you can clearly distinguish between Abstract Classes and Interfaces and which to implement for specific cases. 

Interfaces – What are they?

An Interface in OOPs can be understood simply as a behavioural contract between various systems. What this means is that any class that implements an interface must provide some implementation for all of the methods of the Interface. 

All methods in an interface must be public and abstract. Therefore, interfaces are also understood as “purely abstract” classes. 

The definition of Interfaces looks like this: 

public interface Eating{

   public void chewing();

   public void digesting();

}

As you can see, the definition includes prepending the name with the keyword interface. Further, two abstract public methods have been defined under this interface – so, the class that implements the above interface will need to provide the implementation for the chewing() and digesting(); functions. 

Now let’s look at what Abstract Classes are, and then we’ll bring both the concepts together so that you have better clarity of their similarities and differences. 

Abstract Classes – What are they?

The abstract keyword always prefixes an Abstract Class in its declaration. Further, Abstract Classes act as guidelines created for their derivative non-abstract classes. In that sense, they must have at least one abstract method in their declaration while also providing the proper implementation for its non-abstract methods. 

This is how the definition of Abstract Classes looks like: 

public abstract class Eating{

   public void getReady(){

       System.out.println(“I’m all set to eat”);

   }

   public abstract void start();

   public abstract void stop();

}

As you can see in the definition of the abstract class, the getReady() function is a non-abstract one, while the start(); and stop(); functions are abstract.

When it comes to implementing Abstract Classes, there are a few rules you should be aware of: 

  • Abstract Classes cannot be instantiated. That means – we can’t create objects from any Abstract Classes. 
  • Any child class which will extend the Abstract Class needs to implement all the abstract methods described in the Abstract Class. If the child class doesn’t implement all the abstract methods, the child class should be declared as an abstract class as well.

Now that we have the basics of Interfaces and Abstract classes, let’s talk about how they differ, their similarities, and when we should use which approach. 

Differences and similarities between Interfaces and Abstract Classes

All of the methods declared inside an Interface are implicitly public and abstract – whereas Abstract Classes can have all sorts of modifiers for their methods – from partial, public, static, protected, and more. 

Further, any user-defined class can implement more than one interface. However, they can implement only one Abstract Class. Both Interfaces and Abstract Classes can have methods and variables, but neither of them can be instantiated. All the variables declared within the interface are final. However, the variables declared in Abstract Classes can be non-final and can be modified by the user-defined classes. 

Here’s a summary of all the key differences between an Abstract Class and an Interface. 

Parameter Abstract Classes Interfaces
Keyword  abstract keyword is used. interface keyword is used. 
Type of variables Can handle final, non-final, static, and non-static variables. Can only have static and final variables defined by default. 
Final variables May or may not have final variables declared within it. Variables by default are declared as final
Access modifiers Can have all any of the modifiers – private, public, static, etc.  Can only have the public access modifier. 
Types of methods Can have both abstract and non-abstract methods. Can only have abstract methods. 
Speed Fast Slow, as it requires extra indirection. 

Abstract Class vs Interface: When to choose Which? 

If you need a base class for providing some implementations in your code – an abstract class is the way to go. For instance, you might want to initialise a few variables within a class to perform some logical action in a method that all the derived classes can use. In such a scenario, using an Abstract Class is your best bet. 

However, if you need to provide any add-on behaviour to your classes, then you should opt for interfaces. In reality, both interfaces and abstract classes will offer you the same functionality. However, the difference comes in when you consider coding standards. Interfaces help you achieve abstraction and polymorphism – two important principles of OOPs. It also allows you to keep the code loosely-coupled instead of tightly coupled.

Let’s now sum up the use cases of Interfaces and Abstract Classes!

When to use Interfaces?

An Interface allows programmers to build additional behavioural patterns for their classes. It allows somebody to start from scratch and implement the interface in any class they want. The purpose of the interface is, therefore, incidental – something that has to be added on to the code. So, in cases where you wish to provide additional functionalities to classes and don’t mind exposing the methods of your interface (since all the methods will be public), you should go ahead with an Interface implementation. 

When to use Abstract Classes?

In contrast to Interfaces, Abstract Classes provide a lot more structure. Abstract Classes come with default implementations of some methods and even offer useful tools for fully implementing the Abstract Class. You should use Abstract Classes to provide some common functionality across a set of related classes while also leaving enough room for default method implementations.

In Conclusion

Abstraction is a crucial component of OOPs, and both Abstract Classes and Interfaces allow you to achieve some degree of abstraction in your code. However, using them interchangeably without knowing the pros and cons is a mistake and can cause your code (and eventually your software) to be buggy and laggy.

 We hope this article helped you understand the crucial differences between Abstract Classes and Interfaces, along with some syntactic knowledge and where they are implemented. 

If you’re interested to learn more about Abstract Classes and Interfaces, check out upGrad & IIIT-B’s Executive PG Program in Full-stack Software Development which is designed for working professionals and offers 500+ hours of rigorous training, 9+ projects and assignments, IIIT-B Alumni status, practical hands-on capstone projects & job assistance with top firms.

If you’re still confused about the nuances, please drop us a comment below,, and we’ll get back to you soon!

Become a Full Stack Developer

UPGRAD AND IIIT-BANGALORE'S EXECUTIVE PG PROGRAM IN SOFTWARE DEVELOPMENT
Apply Now

0 replies on “Abstract Class vs Interface: The Differences and the Similarities”

×