Difference Between Abstract Class and Interface in Java

Hey there! So someone asked you the Difference between Abstract Class and Interface in Java and you ended up searching for it on Google? And maybe other articles did not really make you understand the topic. This question is a very popular question in interviews. There are high chances that you will be asked this one if you are applying for a Java developer role in a company.

So let us start with the differences between the two concepts!

Abstract Classes

Abstract methods, in Java, are those methods which only contain the prototype of the function and lack the body. This means that only the function name, access specifier, return type, and the parameters are known to the method itself. The method does not have a body.

If there are abstract methods in a class in Java, then the class also must be an abstract class.

A very simple example of an abstract class would be

abstract class AbstractClassName//this is the abstract class. 
{
    abstract public void abstractMethodName();//This is the abstract method. 
}

As you can see the abstractMethodName does not have a body. This type of method is an abstract method. However, it is not necessary for a class that is abstract to only contain abstract methods. An abstract class can house concrete methods as well!

Let us check out a brief program on abstract classes to refresh our memory of what they are like.

Program to illustrate the use of Abstract Classes in Java

package com.dataflair.abstractvsinterface;
abstract class AbstractClass
{
    abstract void methodabs();
}
public class Main extends AbstractClass
{
    public void methodabs()
    {
        System.out.println("We defined this inside the Main class. ");
        
    }
    public static void main(String[] args) {
        Main ob = new Main();
        ob.methodabs();
        
    }
}

Output:

Interfaces in Java

Interfaces are somewhat similar to abstract classes. They contain method prototypes that a class implements. If this is entirely new to you, check out our article on interfaces. Interfaces allow us to implement multiple interfaces in Java.

Program to illustrate the use of interfaces in Java:

package com.dataflair.abstractvsinterface;
interface CustomInterface
{
    public void methodabs();
}
public class Main implements CustomInterface
{
    //Now we will implement the method of the interface here. 
    public void methodabs()
    {
        System.out.println("We defined the definition of the interface method here.");
        
    }
    public static void main(String[] args) {
        Main ob = new Main();
        ob.methodabs();
        
    }
}

Output:

Note how the class implements the methods in the interface. Now that we are familiar, let us get to know the differences between these concepts.

Key Differences Between Abstract Class and Interface in Java

Programs to Illustrate Differences Between Abstract Classes and Interfaces in Java

You can extend only one abstract class or a concrete class from an abstract class at a time.

package com.dataflair.abstractvsinterface;
class ConcreteClassOne{
   public void method1(){
      System.out.println("This is method 1");
   }
}
abstract class AbstractClassOne{
   public void display2(){
      System.out.println("This is method 2");
   }
}
abstract class AbstractClassTwo extends ConcreteClassOne{
   abstract void display3();
}
class ConcreteClassFour extends AbstractClassTwo{
   public void display3(){
      System.out.println("This is method 3");
   }
}
public class Demo
{
    public static void main(String[] args) {
        ConcreteClassFour object = new ConcreteClassFour();
        object.display3();
    }
}

Output:

A single interface can extend more than one interface at a time.

package com.dataflair.abstractvsinterface;
interface InterfaceOne
{
    public void abstractMethodOne();
}
interface InterfaceTwo
{
    public void abstractMethodTwo();

}
interface InterfaceThree extends InterfaceOne,InterfaceTwo
{
    //This interface inherits more than one interface
}

public class InterfaceDifference1 implements InterfaceThree {
    public void abstractMethodOne()
    {
        System.out.println("This is the first abstract method from the first interface");

    }
    public void abstractMethodTwo()
    {
        System.out.println("This is the second abstract method from the second interface");
    }
    public static void main(String[] args) {
        InterfaceDifference1 object = new InterfaceDifference1();
        object.abstractMethodOne();
        object.abstractMethodTwo();
    }
    
}

Output:

A single abstract class or a concrete class can inherit an abstract class.

package com.dataflair.abstractvsinterface;
class ConcreteClassOne
{
    public void concreteMethod()
    {
        System.out.println("This is a concrete method");
    }
}
abstract class AbstractClass extends ConcreteClassOne
{
    abstract public void abstractMethodOne();
}

public class AbstractClassDifference2 extends AbstractClass {
    public void abstractMethodOne()
    {
        System.out.println("This is the Abstract method");
    }
    public static void main(String[] args) {
        AbstractClassDifference2 object = new AbstractClassDifference2();
        object.abstractMethodOne();
        object.concreteMethod();
    }
    
}

Output:

Interfaces can only extend other interfaces. A class has to implement interfaces.

package com.dataflair.abstractvsinterface;
interface InterfaceOne
{
    public void abstractMethod1();
}
interface InterfaceTwo extends InterfaceOne
{
    //Empty Interface
}

public class InterfaceDifference2 implements InterfaceTwo{
    public void abstractMethod1()
    {
        System.out.println("This is the abstract method");
    }
    public static void main(String[] args) {
        InterfaceDifference2 object = new InterfaceDifference2();
        object.abstractMethod1();
    }
    
}

Output:

Abstract classes can contain abstract and concrete methods.

package com.dataflair.abstractvsinterface;
abstract class AbstractClassOne
{
    public void concreteMethod1()
    {
        System.out.println("This is a concrete method");

    }
    abstract void abstractMethod1();
}


public class AbstractClassDifference3 extends AbstractClassOne {
    public void abstractMethod1()
    {
        System.out.println("This is an abstract method");
    }
    public static void main(String[] args) {
        AbstractClassDifference3 object = new AbstractClassDifference3();
        object.concreteMethod1();
        object.abstractMethod1();
    }
}

Output:

Interfaces can only have static, default, and abstract methods.

package com.dataflair.abstractvsinterface;
interface InterfaceNumber1
{
    public void abstractMethod1();
}

public class InterfaceDifference3 implements InterfaceNumber1{
    
    public void abstractMethod1()
    {
        System.out.println("This is the abstract method. An interface can also have default and static methods");

    }
    public static void main(String[] args) {
        InterfaceDifference3 object = new InterfaceDifference3();
        object.abstractMethod1();
    }
}

Output:

An abstract keyword is mandatory for declaring an abstract method in abstract classes.

package com.dataflair.abstractvsinterface;
abstract class AbstractClassOne
{
    abstract public void abstractMethod1();
}


public class AbstractClassDifference4 extends AbstractClassOne{
    public void abstractMethod1()
    {
        System.out.println("This is the abstract method. It is compulsory to use the abstract keyword");
    }
    public static void main(String[] args) 
    {
        AbstractClassDifference4 object = new AbstractClassDifference4();
        object.abstractMethod1();
    }
    
}

Output:

An interface does not require abstract keyword to declare its methods as abstract.

package com.dataflair.abstractvsinterface;
interface InterfaceOne
{
    abstract public void methodOne();
    public void methodTwo();
}


public class InterfaceDifference4 implements InterfaceOne{
    public void methodOne()
    {
        System.out.println("This method is abstract with the help of abstract keyword");
    }
    public void methodTwo()
    {
        System.out.println("This is an abstract method even without the help of abstract keyword");
    }
    public static void main(String[] args) 
    {
     
    InterfaceDifference4 object = new InterfaceDifference4();
    object.methodOne();
    object.methodTwo();   
    }

}

Output:

You can have protected and public abstract methods inside an abstract class.

package com.dataflair.abstractvsinterface;
abstract class AbstractClassOne
{
    abstract public void methodPublic();
    abstract protected void methodProtected();

}
public class AbstractClassDifference5 extends AbstractClassOne
{
    public void methodPublic()
    {
        System.out.println("This is a public method");
    }
    public void methodProtected()
    {
        System.out.println("This is a protected method");
    }
    public static void main(String[] args) 
    {
        AbstractClassDifference5 object = new AbstractClassDifference5();
        object.methodPublic();
        object.methodProtected();
    }
    
}

Output:

There can only be public abstract methods inside interfaces.

package com.dataflair.abstractvsinterface;
interface InterfaceOne
{
    public void methodOne();
}

public class InterfaceDifference5 implements InterfaceOne
{
    public void methodOne()
    {
        System.out.println("Interfaces can only have public abstract methods");

    }
    public static void main(String[] args) {
        InterfaceDifference5 object = new InterfaceDifference5();
        object.methodOne();
    }
    
}

Output:

An abstract class can have static, final or static final variables.

package com.dataflair.abstractvsinterface;
abstract class AbstractClassOne
{
    protected final int protecVar=50;
    public void printValue()
    {
        System.out.println("The protected Value is "+protecVar);
    }

}

public class AbstractClassDifference6 extends AbstractClassOne{
    public static void main(String[] args) {
     AbstractClassOne object = new AbstractClassDifference6();
     object.printValue();   
    }
    
}

Output:

Interfaces can only contain public static final variables.

package com.dataflair.abstractvsinterface;
interface InterfaceOne
{
    //They can have public static variables
    int publicStaticVar=50;
}

public class InterfaceExample6 implements InterfaceOne {
    public void readvalue()
    {
        System.out.println("The value of the variable is "+publicStaticVar);
    }
    public static void main(String[] args) {
        InterfaceExample6 object = new InterfaceExample6();
        object.readvalue();
    }
    
}

Output:

Reasons to use Abstract Classes in Java

• You can offer default functionality with the help of abstract classes.
• You can specify a particular template for future specific classes.
• Abstract classes allow you to reuse code.
• With the help of abstract classes you can define a common interface for your subclasses.

Reasons to use Interfaces in Java

• You can achieve 100% abstraction with the help of interfaces in Java
• You can resolve methods dynamically at runtime with the help of interfaces.
• You can separate the definition of a method from its inheritance hierarchy with the help of interfaces.
• You can also achieve loose coupling with the help of interfaces.

When should you use Java Interfaces?

You should use interfaces when:

• You want 100 percent abstraction
• You want to implement multiple inheritance in Java
• You are more concerned with the behavior of the class rather than who is implementing the behavior.
• You want a child class to implement all abstract methods in the interface.

When should you use Java Abstract Classes?

You should use abstract classes when:

• Your application has some code that needs to be shared amongst different classes. An abstract class would contain all the abstract methods. The child classes can redefine each of these abstract methods separately.
• There is a need to use non-static and non-final values inside a class so that an object can modify these variables.
• You need to have private or protected methods and variables. Abstract Classes can be useful for containing protected and private methods as well as variables.

Summary

In this article, we primarily learned about the prime differences between abstract classes and interfaces in Java. We also learned about their uses, and when to use which in programming. Strong knowledge of these concepts would aid in the better development of software.