Abstraction in Java

Last Updated : 15 Dec, 2023

Abstraction in Java is the process in which we only show essential details/functionality to the user. The non-essential implementation details are not displayed to the user.

In this article, we will learn about abstraction and what abstract means.

Simple Example to understand Abstraction:

Television remote control is an excellent example of abstraction. It simplifies the interaction with a TV by hiding the complexity behind simple buttons and symbols, making it easy without needing to understand the technical details of how the TV functions.

What is Abstraction in Java?

In Java, abstraction is achieved by interfaces and abstract classes. We can achieve 100% abstraction using interfaces.

Data Abstraction may also be defined as the process of identifying only the required characteristics of an object ignoring the irrelevant details. The properties and behaviours of an object differentiate it from other objects of similar type and also help in classifying/grouping the objects.

Abstraction Real-Life Example:

Consider a real-life example of a man driving a car. The man only knows that pressing the accelerators will increase the speed of a car or applying brakes will stop the car, but he does not know how on pressing the accelerator the speed is actually increasing, he does not know about the inner mechanism of the car or the implementation of the accelerator, brakes, etc in the car. This is what abstraction is.

Java Abstract classes and Java Abstract methods

An abstract class is a class that is declared with an abstract keyword.
An abstract method is a method that is declared without implementation.
An abstract class may or may not have all abstract methods. Some of them can be concrete methods
A method-defined abstract must always be redefined in the subclass, thus making overriding compulsory or making the subclass itself abstract.
Any class that contains one or more abstract methods must also be declared with an abstract keyword.
There can be no object of an abstract class. That is, an abstract class can not be directly instantiated with the new operator.
An abstract class can have parameterized constructors and the default constructor is always present in an abstract class.

Algorithm to implement abstraction in Java

Determine the classes or interfaces that will be part of the abstraction.
Create an abstract class or interface that defines the common behaviours and properties of these classes.
Define abstract methods within the abstract class or interface that do not have any implementation details.
Implement concrete classes that extend the abstract class or implement the interface.
Override the abstract methods in the concrete classes to provide their specific implementations.
Use the concrete classes to implement the program logic.

When to use abstract classes and abstract methods?

There are situations in which we will want to define a superclass that declares the structure of a given abstraction without providing a complete implementation of every method. Sometimes we will want to create a superclass that only defines a generalization form that will be shared by all of its subclasses, leaving it to each subclass to fill in the details.

Consider a classic “shape” example, perhaps used in a computer-aided design system or game simulation. The base type is “shape” and each shape has a color, size, and so on. From this, specific types of shapes are derived(inherited)-circle, square, triangle, and so on — each of which may have additional characteristics and behaviours. For example, certain shapes can be flipped. Some behaviours may be different, such as when you want to calculate the area of a shape. The type hierarchy embodies both the similarities and differences between the shapes.

Abstract Class in Java

Java Abstraction Example

Example 1:

Java

// Java program to illustrate the 
// concept of Abstraction 
abstract class Shape { 
    String color; 
  
    // these are abstract methods 
    abstract double area(); 
    public abstract String toString(); 
  
    // abstract class can have the constructor 
    public Shape(String color) 
    { 
        System.out.println("Shape constructor called"); 
        this.color = color; 
    } 
  
    // this is a concrete method 
    public String getColor() { return color; } 
} 
class Circle extends Shape { 
    double radius; 
  
    public Circle(String color, double radius) 
    { 
  
        // calling Shape constructor 
        super(color); 
        System.out.println("Circle constructor called"); 
        this.radius = radius; 
    } 
  
    @Override double area() 
    { 
        return Math.PI * Math.pow(radius, 2); 
    } 
  
    @Override public String toString() 
    { 
        return "Circle color is " + super.getColor() 
            + "and area is : " + area(); 
    } 
} 
class Rectangle extends Shape { 
  
    double length; 
    double width; 
  
    public Rectangle(String color, double length, 
                     double width) 
    { 
        // calling Shape constructor 
        super(color); 
        System.out.println("Rectangle constructor called"); 
        this.length = length; 
        this.width = width; 
    } 
  
    @Override double area() { return length * width; } 
  
    @Override public String toString() 
    { 
        return "Rectangle color is " + super.getColor() 
            + "and area is : " + area(); 
    } 
} 
public class Test { 
    public static void main(String[] args) 
    { 
        Shape s1 = new Circle("Red", 2.2); 
        Shape s2 = new Rectangle("Yellow", 2, 4); 
  
        System.out.println(s1.toString()); 
        System.out.println(s2.toString()); 
    } 
}

Output

Shape constructor called
Circle constructor called
Shape constructor called
Rectangle constructor called
Circle color is Redand area is : 15.205308443374602
Rectangle color is Yellowand area is : 8.0

Example 2:

Java

// Java Program to implement 
// Java Abstraction 
  
// Abstract Class declared 
abstract class Animal { 
    private String name; 
  
    public Animal(String name) { this.name = name; } 
  
    public abstract void makeSound(); 
  
    public String getName() { return name; } 
} 
  
// Abstracted class 
class Dog extends Animal { 
    public Dog(String name) { super(name); } 
  
    public void makeSound() 
    { 
        System.out.println(getName() + " barks"); 
    } 
} 
  
// Abstracted class 
class Cat extends Animal { 
    public Cat(String name) { super(name); } 
  
    public void makeSound() 
    { 
        System.out.println(getName() + " meows"); 
    } 
} 
  
// Driver Class 
public class AbstractionExample { 
    // Main Function 
    public static void main(String[] args) 
    { 
        Animal myDog = new Dog("Buddy"); 
        Animal myCat = new Cat("Fluffy"); 
  
        myDog.makeSound(); 
        myCat.makeSound(); 
    } 
}

Output

Buddy barks
Fluffy meows

Explanation of the above Java program:

This code defines an Animal abstract class with an abstract method makeSound(). The Dog and Cat classes extend Animal and implement the makeSound() method. The main() method creates instances of Dog and Cat and calls the makeSound() method on them.

This demonstrates the abstraction concept in Java, where we define a template for a class (in this case Animal), but leave the implementation of certain methods to be defined by subclasses (in this case makeSound()).

Interface

Interfaces are another method of implementing abstraction in Java. The key difference is that, by using interfaces, we can achieve 100% abstraction in Java classes. In Java or any other language, interfaces include both methods and variables but lack a method body. Apart from abstraction, interfaces can also be used to implement interfaces in Java.

Implementation: To implement an interface we use the keyword “implements” with class.

Java

// Define an interface named Shape 
interface Shape { 
    double calculateArea(); // Abstract method for 
                            // calculating the area 
} 
  
// Implement the interface in a class named Circle 
class Circle implements Shape { 
    private double radius; 
  
    // Constructor for Circle 
    public Circle(double radius) { this.radius = radius; } 
  
    // Implementing the abstract method from the Shape 
    // interface 
    public double calculateArea() 
    { 
        return Math.PI * radius * radius; 
    } 
} 
  
// Implement the interface in a class named Rectangle 
class Rectangle implements Shape { 
    private double length; 
    private double width; 
  
    // Constructor for Rectangle 
    public Rectangle(double length, double width) 
    { 
        this.length = length; 
        this.width = width; 
    } 
  
    // Implementing the abstract method from the Shape 
    // interface 
    public double calculateArea() { return length * width; } 
} 
  
// Main class to test the program 
public class Main { 
    public static void main(String[] args) 
    { 
        // Creating instances of Circle and Rectangle 
        Circle myCircle = new Circle(5.0); 
        Rectangle myRectangle = new Rectangle(4.0, 6.0); 
  
        // Calculating and printing the areas 
        System.out.println("Area of Circle: "
                           + myCircle.calculateArea()); 
        System.out.println("Area of Rectangle: "
                           + myRectangle.calculateArea()); 
    } 
}

Output

Area of Circle: 78.53981633974483
Area of Rectangle: 24.0

Advantages of Abstraction

Here are some advantages of abstraction:

It reduces the complexity of viewing things.
Avoids code duplication and increases reusability.
Helps to increase the security of an application or program as only essential details are provided to the user.
It improves the maintainability of the application.
It improves the modularity of the application.
The enhancement will become very easy because without affecting end-users we can able to perform any type of changes in our internal system.
Improves code reusability and maintainability.
Hides implementation details and exposes only relevant information.
Provides a clear and simple interface to the user.
Increases security by preventing access to internal class details.
Supports modularity, as complex systems can be divided into smaller and more manageable parts.
Abstraction provides a way to hide the complexity of implementation details from the user, making it easier to understand and use.
Abstraction allows for flexibility in the implementation of a program, as changes to the underlying implementation details can be made without affecting the user-facing interface.
Abstraction enables modularity and separation of concerns, making code more maintainable and easier to debug.

Disadvantages of Abstraction in Java

Here are the main disadvantages of abstraction in Java:

Abstraction can make it more difficult to understand how the system works.
It can lead to increased complexity, especially if not used properly.
This may limit the flexibility of the implementation.
Abstraction can add unnecessary complexity to code if not used appropriately, leading to increased development time and effort.
Abstraction can make it harder to debug and understand code, particularly for those unfamiliar with the abstraction layers and implementation details.
Overuse of abstraction can result in decreased performance due to the additional layers of code and indirection.

Also Read:

Interfaces in Java

Abstract classes in Java

Difference between abstract class and interface

abstract keyword in Java