Difference Between Abstract Class and Interface in Java

In object-oriented programming (OOP), both abstract classes and interfaces serve as fundamental constructs for defining contracts. They establish a blueprint for other classes, ensuring consistent implementation of methods and behaviors. However, they each come with distinct characteristics and use cases.

In this article, we will learn about abstract class vs interface in Java.

Difference Between Abstract Class and Interface

As we know that abstraction refers to hiding the internal implementation of the feature and only showing the functionality to the users. i.e., showing only the required features, and hiding how those features are implemented behind the scene. Whereas, an Interface is another way to achieve abstraction in Java. Both abstract class and interface are used for abstraction. An interface and an Abstract Class are required prerequisites.

Abstract Class in Java

• Definition: An abstract class is a class that cannot be instantiated directly (which means we can not create an object directly from an abstract class). An abstract class is like a blueprint for other classes.
• Method Implementation: An abstract class can contain both abstract methods (methods without an implementation) and concrete methods (methods with an implementation).
• Variables: Abstract classes can have member variables, including final, non-final, static, and non-static variables.
• Constructors: Abstract classes can have constructors, which can be used to initialize variables in the abstract class when it is instantiated by a subclass.

Example: This example demonstrates implementing abstract methods from a common base class (shape) and share common behavior.

// Abstract class Shape, serving as a blueprint for specific shape classes
abstract class Shape {
    // Name of the shape
    String objectName = " "; 

    // Constructor to initialize the name of the shape
    Shape(String name) {
        this.objectName = name;
    }

    // Concrete method to move the shape to a new position
    public void moveTo(int x, int y) {
        System.out.println(this.objectName + " has been moved to x = " + x + " and y = " + y);
    }

    // Abstract method to calculate the area of the shape
    abstract public double area();

    // Abstract method to draw the shape
    abstract public void draw();
}

// Rectangle class extending Shape and providing its own implementation
class Rectangle extends Shape {
     // Dimensions of the rectangle
    int length, width;

    // Constructor to initialize the rectangle's dimensions and name
    Rectangle(int length, int width, String name) {
        super(name);
        this.length = length;
        this.width = width;
    }

    // Implementation of draw method for rectangle
    @Override 
    public void draw() {
        System.out.println("Rectangle has been drawn ");
    }

    // Implementation of area method for rectangle
    @Override 
    public double area() {
        return (double)(length * width);
    }
}

// Circle class extending Shape and providing its own implementation
class Circle extends Shape {
    // Value of pi for circle area calculation
    double pi = 3.14; 
    // Radius of the circle
    int radius; 

    // Constructor to initialize the circle's radius and name
    Circle(int radius, String name) {
        super(name);
        this.radius = radius;
    }

    // Implementation of draw method for circle
    @Override 
    public void draw() {
        System.out.println("Circle has been drawn ");
    }

    // Implementation of area method for circle
    @Override 
    public double area() {
        return (double)(pi * radius * radius);
    }
}

// Main class to test the functionality of the shape classes
public class Geeks {
    public static void main(String[] args) {
        // Creating a Rectangle object and demonstrating its behavior
        Shape rect = new Rectangle(2, 3, "Rectangle");
        System.out.println("Area of rectangle: " + rect.area());
        rect.moveTo(1, 2);

        System.out.println();

        // Creating a Circle object and demonstrating its behavior
        Shape circle = new Circle(2, "Circle");
        System.out.println("Area of circle: " + circle.area());
        circle.moveTo(2, 4);
    }
}

Area of rectangle: 6.0
Rectangle has been moved to x = 1 and y = 2

Area of circle: 12.56
Circle has been moved to x = 2 and y = 4

Example: This example, demonstrating abstract class inheritance and method overriding.

// Abstract class Sunstar
abstract class Sunstar {
    // Abstract method printInfo
    abstract void printInfo();
}

// Employee class that extends the abstract class Sunstar
class Employee extends Sunstar {
    // Implementation of the abstract method printInfo
    void printInfo() {
        // Employee name
        String name = "Avinash"; 
        // Employee age
        int age = 21; 
        // Employee salary
        float salary = 222.2F; 
         // Print name
        System.out.println(name);
        // Print age
        System.out.println(age); 
        // Print salary
        System.out.println(salary); 
    }
}

// Base class to test the implementation
class Base {
    public static void main(String args[]) {
        // Create an Employee object
        Sunstar s = new Employee(); 
        // Call the printInfo method
        s.printInfo(); 
    }
}

Avinash
21
222.2

Features of an Abstract Class in Java

An abstract class in Java is a special type of class that cannot be instantiated directly and serves as a blueprint for other classes. It provides a way to define a common interface or behavior that can be shared by multiple related classes, but with specific implementations in each derived class.

Key features:

• Cannot be instantiated: We can not create an object from an abstract class.
• Combining Partial Implementation and Subclass Contract: Abstract classes can contain abstract methods (methods without implementations) that must be overridden by subclasses. It can also have concrete methods with implementations.
• Can contain both abstract and non-abstract methods: Abstract classes can have both abstract and non-abstract methods. Non-abstract methods have complete implementations and can be called directly.
• Can have constructors: Abstract classes can have constructors. These constructors are called when a subclass is created and also used to initialize variables in the abstract class.
• Can have member variables: Abstract classes can have member variables, which are variables that belong to an instance of the class. These variables can be final, non-final, static, or non-static.
• Can be used as a base class: Abstract classes can be used as a base class for other classes, which means they can be inherited by other classes. This allows for code reuse and the creation of a common interface or behavior for related classes.

Overall, abstract classes in Java are used to define a common interface or behavior that can be shared by multiple related classes, with specific implementations provided by each derived class.

Interface in Java

• Definition: An interface is a reference type in Java, it is similar to a class, and it is a collection of abstract methods and static constants.
• Method Implementation: All methods in an interface are by default abstract and must be implemented by any class that implements the interface.From Java 8, interfaces can have default and static methods with concrete implementations.From Java 9, interfaces can also have private methods.
• Variables: Variables declared in an interface are by default public, static, and final (constants).

Example: This example demonstrates interface implementation.

// Interface defining the method to draw an object
interface Drawable {
    void draw();
}

// Interface defining the method to move an object to a new position
interface Movable {
    void moveTo(int x, int y);
}

// Circle class implementing both Drawable and Movable interfaces
class Circle implements Drawable, Movable {
    double pi = 3.14; // Value of Pi for circle calculations
    int radius; // Radius of the circle

    // Constructor to initialize the radius of the circle
    Circle(int radius) {
        this.radius = radius;
    }

    // Implementation of the draw method from Drawable interface
    @Override 
    public void draw() {
        System.out.println("Circle has been drawn ");
    }

    // Implementation of the moveTo method from Movable interface
    @Override 
    public void moveTo(int x, int y) {
        System.out.println("Circle has been moved to x = " + x + " and y = " + y);
    }
}

// Main class to test the implementation of Circle class
public class Geeks {
    public static void main(String[] args) {
        // Create a Circle object
        Circle circle = new Circle(2);
        
        // Call the draw method
        circle.draw();
        
        // Call the moveTo method
        circle.moveTo(2, 4);
    }
}

Circle has been drawn 
Circle has been moved to x = 2 and y = 4

Features of an Interface in Java

An interface in Java is a reference type, similar to a class, that can contain only constants, method signatures, default methods, static methods, and nested types. Interfaces cannot contain instance fields. The methods in interfaces are abstract by default (except for default and static methods introduced in Java 8 and private methods in Java 9).

Key features:

• Define Methods: Interface tells what method a class must implement without providing the actual code for them.
• Supports Polymorphism: Interface supports polymorphism, it means object from different classes can be treated same if they implement the same interface.
• Promotes Flexibility: Interfaces allow classes to work together which promotes flexibility.
• Encourages Code Reusability: Different classes can implement the same interface and also share the common properties.

Overall, interfaces in Java are powerful tools for defining contracts and promoting flexibility, interoperability, and maintainability in software design.

Abstract class vs Interface 

By understanding these distinctions, you can make informed decisions about when to use abstract classes and interfaces in Java programming.

When to use what?

Consider using abstract classes if any of these statements apply to your situation:  

• If you have related classes that share common code, the best practice is to put that code in an abstract class, and let other classes extend it.
• You can define the non-static or non-final field(s) in the abstract class so that via a method you can access and modify the state of the object to which they belong.
• You can expect that the classes that extend an abstract class have many common methods or fields, or require access modifiers other than public (such as protected and private).

Consider using interfaces if any of these statements apply to your situation:  

• It is a total abstraction, all methods declared within an interface must be implemented by the class(es) that implements this interface.
• A class can implement more than one interface. It is called multiple inheritances.
• You want to specify the behavior of a data type without worrying about its implementation.

Interfaces vs Abstract Classes

Visit Course