Abstract Class vs Interface in Java

A major aspect of mastering Java lies in understanding its object-oriented programming tools, particularly abstract classes and interfaces. These concepts are essential in creating flexible and reusable code structures. 

In this blog, we’ll delve into the key differences between abstract classes and interfaces, offering insights into their unique features and practical use cases, empowering you to craft cleaner, more efficient Java applications.

Suggested Read: OOP Concepts in Java

What is an Abstract Class in Java?

An abstract class in Java is a type of class that cannot be instantiated directly. It acts as a blueprint for other classes and is primarily used when you want to define some common behavior for related classes while leaving certain details to be implemented by the subclasses.

An abstract class may have both:

• Abstract methods: Methods that are declared but not implemented in the abstract class. Subclasses must provide the implementation.

• Concrete methods: Methods that are fully implemented in the abstract class and can be inherited by subclasses.

Abstract classes are ideal for scenarios where classes share some functionality but need to implement their unique versions of specific methods.

Code Example:

// Abstract class example
abstract class Animal {
    // Abstract method (does not have a body)
    abstract void makeSound();

    // Concrete method (has a body)
    void sleep() {
        System.out.println("This animal is sleeping.");
    }
}

// Subclass that extends the abstract class
class Dog extends Animal {
    // Providing implementation for the abstract method
    @Override
    void makeSound() {
        System.out.println("Woof! Woof!");
    }
}

// Main class to test the abstract class
public class Main {
    public static void main(String[] args) {
        Animal myDog = new Dog(); // Creating an object of the subclass
        myDog.makeSound();        // Calling the implemented method
        myDog.sleep();            // Calling the concrete method from abstract class
    }
}

Output:

Woof! Woof!  
This animal is sleeping.  

This example demonstrates how the abstract class Animal defines a structure with an abstract method (makeSound) and a concrete method (sleep). The Dog class provides its specific implementation for the makeSound method while reusing the sleep method from the abstract class.

Read this blog to understand Abstract Classes in Java in more detail.

Explore our Free Java Programming course to start your learning today

What is an Interface in Java?

An interface in Java is a reference type, similar to a class, that can contain only abstract methods (methods without a body) and constants (public static final variables). 

Interfaces allow you to define a contract that other classes can implement. When a class implements an interface, it agrees to provide the specific implementations for all the methods declared in the interface.

Interfaces are often used to represent common behaviors that can be shared across different classes, regardless of their class hierarchy.

Code Example: Basic Interface Implementation

// Interface definition
interface Animal {
    // Abstract method (no body)
    void sound();

    // Default method (can have a body)
    default void sleep() {
        System.out.println("This animal is sleeping.");
    }
}

// Implementing the interface in a class
class Dog implements Animal {
    // Providing implementation for the abstract method
    public void sound() {
        System.out.println("Woof! Woof!");
    }
}

// Main class to test the interface
public class Main {
    public static void main(String[] args) {
        Animal myDog = new Dog();  // Creating an object of the Dog class
        myDog.sound();             // Calling the implemented method
        myDog.sleep();             // Calling the default method from interface
    }
}

Output:

Woof! Woof!  
This animal is sleeping.  

In this example, the Animal interface defines an abstract method sound() and a default method sleep(). The Dog class implements the Animal interface and provides the implementation for the sound() method. It can also use the default sleep() method from the interface without needing to implement it.

Read this blog to understand Interface in Java in more detail.

Key Differences Between Abstract Class and Interface

Suggested Read:

• Access Modifiers in Java
• Inheritance in Java with Examples
• Methods in Java

When to Use Abstract Class vs. Interface?

In object-oriented programming (OOP), both abstract classes and interfaces are used to define abstract types, but they serve different purposes. Here’s when to use each:

1. Use an Abstract Class when:

• Shared Code Implementation: You want to provide some default behavior that can be shared among all derived classes. Abstract classes allow you to define methods with implementation.

• Inheritance: You are using inheritance to extend a base class. Abstract classes are suited for situations where the child classes share a common base class but also have specialized behavior.

• State Management: You need to store common fields (properties) that all subclasses can inherit. Abstract classes can have fields and constructors.

• Single Inheritance: Abstract classes are best used in languages that support only single inheritance (e.g., Java, C#), as a class can inherit only one abstract class.

Example:

abstract class Animal {
    String name;

    // Constructor
    public Animal(String name) {
        this.name = name;
    }

    // Concrete method
    public void sleep() {
        System.out.println(name + " is sleeping.");
    }

    // Abstract method
    abstract void makeSound();
}

2. Use an Interface when:

• Multiple Implementations: You want a class to implement multiple behaviors. In languages like Java and C#, a class can implement multiple interfaces but can inherit from only one class. Interfaces are ideal when you need to add functionality to different classes that are not in the same inheritance hierarchy.

• Behavior Definition: You are defining a contract or a set of methods that classes must implement, but without enforcing any shared behavior or state. Interfaces are about capabilities, not inheritance.

• Loose Coupling: You want to provide a common set of operations for disparate classes that might not share a common parent class. This is particularly useful in large systems with various modules or libraries.

• Decoupling the Code: Interfaces provide a way to decouple the code, making it more flexible. They enable polymorphism and abstraction while avoiding tight dependencies between objects.

Example:

interface CanFly {
    void fly();
}

class Bird implements CanFly {
    @Override
    public void fly() {
        System.out.println("Bird is flying");
    }
}

class Airplane implements CanFly {
    @Override
    public void fly() {
        System.out.println("Airplane is flying");
    }
}

Abstract Class and Interface in Java 8 and Beyond

Java 8 introduced several enhancements that change the way abstract classes and interfaces are used. Below are key updates that apply to both:

Changes in Abstract Class (Java 8 and Beyond)

1. Default Methods: Java 8 allows abstract classes to have default methods, which are methods with a body. This provides a way to add new methods to an abstract class without breaking the existing code.
   Example:

abstract class Animal {
    abstract void sound();
    
    // Default method with implementation
    public void sleep() {
        System.out.println("Animal is sleeping");
    }
}

2. Static Methods: Java 8 allows static methods in abstract classes. These methods belong to the class, not to instances of the class.
   Example:

abstract class Animal {
    public static void breathe() {
        System.out.println("Breathing...");
    }
}

Learn about classes in Java with this free course.

Changes in Interface (Java 8 and Beyond)

1. Default Methods:
   • Java 8 introduced default methods in interfaces. These are methods with a body, allowing interfaces to provide a default implementation. This helps avoid breaking existing implementations when new methods are added to an interface.
     Example:

interface Animal {
    void sound(); // abstract method
    
    // Default method with implementation
    default void sleep() {
        System.out.println("Animal is sleeping");
    }
}

2. Static Methods: Static methods can now be defined in interfaces. They must be called using the interface name and cannot be overridden.
   Example:

interface Animal {
    static void breathe() {
        System.out.println("Breathing...");
    }
}

3. Functional Interfaces: Java 8 introduced the concept of functional interfaces, which are interfaces with exactly one abstract method. These interfaces are used primarily with lambda expressions and method references.
   Example:

@FunctionalInterface
interface MyFunctionalInterface {
    void doSomething(); // Single abstract method
}

4. Multiple Default Methods: Java 8 allows interfaces to have multiple default methods, and if a class implements multiple interfaces that contain conflicting default methods, the class must provide an implementation to resolve the conflict.
   Example:

interface Animal {
    default void sound() {
        System.out.println("Animal sound");
    }
}

interface Bird {
    default void sound() {
        System.out.println("Bird sound");
    }
}

class Parrot implements Animal, Bird {
    @Override
    public void sound() {
        System.out.println("Parrot sound");
    }
}

Conclusion

Understanding the differences and use cases of abstract classes and interfaces in Java is essential for writing clean, efficient, and maintainable code. With the advancements introduced in Java 8 and beyond, developers can leverage features like default and static methods to design more flexible applications.

Mastering these concepts is a key part of building a strong foundation in Java programming. To further enhance your skills, Great Learning’s Full Stack Software Development program offers comprehensive training in both front-end and back-end technologies, preparing you for a successful career in software development.