Java Abstraction

Java Abstraction is a fundamental concept in object-oriented programming (OOP) that allows you to create complex systems by focusing on essential characteristics while hiding unnecessary details. It is one of the key principles of OOP, along with encapsulation, inheritance, and polymorphism. Abstraction helps in achieving modularity, reusability, and maintainability in your code.

In Java, abstraction is implemented using abstract classes and interfaces. An abstract class is a class that cannot be instantiated but can be extended by other classes. It may contain abstract methods (methods without implementation) as well as concrete methods (methods with implementation). Abstract classes are typically used as base classes for other classes to inherit common behavior.

On the other hand, an interface in Java is a contract that defines a set of methods that a class must implement. It provides a way to achieve full abstraction, as it only declares the method signatures without any implementation details. Classes can implement one or multiple interfaces, allowing them to provide specific behavior according to the interface contract.


Here’s an example that demonstrates the use of abstraction in Java:

// Abstract class
abstract class Shape {
    // Abstract method
    public abstract void draw();

    // Concrete method
    public void printDescription() {
        System.out.println("This is a shape.");

// Concrete class extending the abstract class
class Circle extends Shape {
    public void draw() {
        System.out.println("Drawing a circle.");

// Concrete class implementing an interface
class Rectangle implements Shape {
    public void draw() {
        System.out.println("Drawing a rectangle.");

public class Main {
    public static void main(String[] args) {
        // Creating objects of concrete classes
        Circle circle = new Circle();
        Rectangle rectangle = new Rectangle();

        // Calling abstract method through objects
        circle.draw();      // Output: Drawing a circle.
        rectangle.draw();   // Output: Drawing a rectangle.

        // Calling concrete method through objects
        circle.printDescription();     // Output: This is a shape.
        rectangle.printDescription();  // Output: This is a shape.

In the above example, the Shape class is an abstract class that declares an abstract method draw() and a concrete method printDescription(). The Circle class extends the Shape class and provides an implementation for the draw() method. The Rectangle class implements the Shape interface and also provides an implementation for the draw() method.

By using abstraction, we can treat both the Circle and Rectangle objects as Shape objects, allowing us to write code that is more flexible and reusable. We can call the draw() method on both objects without worrying about the specific implementation details, thus achieving the benefits of abstraction.