Abstract Class Vs Interface Javatpoint

MUAZHAN

6 min read

·

Jun 22, 2024

38

Share

Abstract Class vs Interface in Java

This article will explore the differences between abstract classes and interfaces in Java. Both are powerful tools for achieving abstraction in object-oriented programming, but they serve different purposes. Understanding these differences is crucial for choosing the right approach for your specific needs.

Abstract Classes

Abstract classes are classes that cannot be instantiated directly. They act as blueprints for other classes, providing a common structure and functionality. Abstract classes can have both abstract methods (methods without implementation) and concrete methods (methods with implementation).

Key Features of Abstract Classes:

• Abstract Methods: An abstract method is declared with the keyword abstract and has no body. Subclasses must provide implementation for these abstract methods.
• Concrete Methods: Abstract classes can have concrete methods that provide default implementation. These methods can be inherited by subclasses.
• Constructors: Abstract classes can have constructors, which are used to initialize the state of the class when a subclass is instantiated.
• State: Abstract classes can have instance variables and can hold data.

Example of Abstract Class:

abstract class Shape {
    private int side;

    public Shape(int side) {
        this.side = side;
    }

    public abstract double calculateArea();

    public int getSide() {
        return side;
    }
}

In this example:

• Shape is an abstract class that cannot be instantiated directly.
• calculateArea() is an abstract method that must be implemented by subclasses.
• getSide() is a concrete method that provides default implementation.

Subclasses of Abstract Classes:

class Square extends Shape {

    public Square(int side) {
        super(side);
    }

    @Override
    public double calculateArea() {
        return side * side;
    }
}

In this example:

• Square is a subclass of Shape.
• It implements the calculateArea() method.

Interfaces

Interfaces are blueprints for classes that specify a set of methods that a class must implement. They do not provide any implementation for these methods. Interfaces are used to achieve abstraction and polymorphism.

Key Features of Interfaces:

• Abstract Methods: All methods in an interface are abstract and have no body.
• No State: Interfaces cannot have instance variables or hold data.
• Multiple Inheritance: A class can implement multiple interfaces, enabling multiple inheritance of methods.
• Constants: Interfaces can define constants, which are static final variables.

Example of Interface:

interface Drawable {
    void draw();
}

In this example:

• Drawable is an interface that defines the draw() method.
• Any class implementing Drawable must provide its own implementation for the draw() method.

Classes Implementing Interfaces:

class Circle implements Drawable {

    @Override
    public void draw() {
        System.out.println("Drawing a circle");
    }
}

In this example:

• Circle is a class that implements the Drawable interface.
• It provides its own implementation for the draw() method.

Key Differences between Abstract Classes and Interfaces

Choosing between Abstract Classes and Interfaces

• Use Abstract Classes:
  • When you need to provide default implementation for some methods.
  • When you need to define state and behavior for the class.
• Use Interfaces:
  • When you need to specify a set of methods that classes must implement without providing implementation.
  • When you need to achieve multiple inheritance.

Ultimately, the choice between abstract classes and interfaces depends on the specific requirements of your program. Understanding the differences between them is crucial for making informed decisions.