What is Abstraction in Java?

In object-oriented programming, the concept of abstraction is a cornerstone of efficiency and maintainability. Java, renowned for its elegant design, offers a robust framework for implementing abstraction, allowing developers to simplify complex systems, enhance code structure, and improve reusability. This article looks deep into the world of abstraction in Java, focusing on the pivotal role played by the Java abstract class and the mechanics of abstract methods.

By the end of this article, you will not only grasp the essence of abstraction but also be equipped to apply it effectively in your Java coding projects. If you are interested in upskilling yourself in this domain, we have listed a number of Java Certification Courses that you can pursue.

Abstraction in Java

Abstraction in Java is the process of simplifying complex reality by modelling classes based on essential properties and behaviours. It involves defining the structure of a class while leaving the implementation details to its subclasses. This allows developers to create a blueprint for classes, ensuring consistency and efficiency in code design. Here is a code snippet to understand the concept:

abstract class Shape {

abstract void draw(); // Abstract method

}

class Circle extends Shape {

void draw() {

// Class creation to draw a circle

System.out.println("Drawing a circle");

}

}

Also Read:

• Top Java Bootcamp Courses To Pursue Right Now!
• Top 7 Java Developer Interview Questions and Answers
• Top 30 Design Patterns Programs in Java, Star, Number and Character

Java Abstract Class

A Java abstract class is a fundamental building block for abstraction. It is a class that cannot be instantiated and may have abstract methods, which are methods without a body. Abstract classes serve as a foundation for other classes and are designed to be extended by sub-classes. They encapsulate common attributes and behaviours while allowing for customisation by derived classes.

Abstract Method in Java

An abstract method in Java is a method declared without an implementation. These methods are meant to be defined in concrete subclasses, ensuring that each subclass provides its unique implementation. Abstract methods serve as a contract that derived classes must adhere to, enforcing consistency in the behaviour of the subclasses.

Also Read:

• Top 20 Courses on JavaScript for Beginners
• 20+ Online Courses to Learn ReactJS
• Reverse a String in Java

Achieving Abstraction in Java

To achieve abstraction in Java, follow these steps:

Create an Abstract Class: Start by defining a Java abstract class that encapsulates common properties and behaviours.

Declare Abstract Methods: Within the abstract class, declare abstract methods that specify the methods subclasses must implement.

Extend the Abstract Class: Develop concrete subclasses that extend the abstract class and provide implementations for the abstract methods.

Instantiate Subclasses: Create instances of the concrete subclasses and use them in your code.

Abstract in Java Example

Let us look at an abstract Java class example to illustrate abstraction in Java using a Java abstract class:

// Define an abstract class
abstract class Shape {
String color;
Shape(String color) {
this.color = color;
}
// Declare an abstract method for calculating area
abstract double calculateArea();
}
// Create a concrete subclass
class Circle extends Shape {
double radius;
Circle(String color, double radius) {
super(color);
this.radius = radius;
}
// Implement the abstract method for circle area
double calculateArea() {
return Math.PI * radius * radius;
}
}
// Create another concrete subclass
class Rectangle extends Shape {
double length;
double width;
Rectangle(String color, double length, double width) {
super(color);
this.length = length;
this.width = width;
}
// Implement the abstract method for rectangle area
double calculateArea() {
return length * width;
}
}
public class AbstractionExample {
public static void main(String[] args) {
Circle circle = new Circle("Red", 5.0); //Creating a new Circle object
Rectangle rectangle = new Rectangle("Blue", 4.0, 6.0);
System.out.println("Circle Area: " + circle.calculateArea());
System.out.println("Rectangle Area: " + rectangle.calculateArea());
}
}

In this example, we define an abstract class ‘Shape’ with an abstract method ‘calculateArea()’. We create two concrete subclasses, ‘Circle’ and ‘Rectangle’, which implement the ‘calculateArea()’ method with their specific area calculation logic.

Data Abstraction in Java

Data abstraction in Java focuses on hiding the internal details and showing only the necessary functionalities of an object. It simplifies complex data structures and operations, making them more accessible and understandable. Data abstraction is achieved through the use of classes, interfaces, and access modifiers.

Abstract Class Example in Java

Here is an abstraction in Java real time example, which demonstrates data abstraction in OOPs:

// Define an abstract class for Bank
abstract class Bank {
int accountNumber;
String accountHolder;
Bank(int accountNumber, String accountHolder) {
this.accountNumber = accountNumber;
this.accountHolder = accountHolder;
}
abstract void checkBalance();
void displayAccountInfo() {
System.out.println("Account Number: " + accountNumber);
System.out.println("Account Holder: " + accountHolder);
}
}
// Create a concrete subclass for a specific bank
class SBI extends Bank {
double balance;
SBI(int accountNumber, String accountHolder, double balance) {
super(accountNumber, accountHolder);
this.balance = balance;
}
void checkBalance() {
System.out.println("Available Balance in SBI: $" + balance);
}
}
public class BankExample {
public static void main(String[] args) {
SBI sbiAccount = new SBI(123456, "John Doe", 1000.0);
sbiAccount.displayAccountInfo();
sbiAccount.checkBalance();
}
}

In this abstract class program in Java, we have an abstract class ‘Bank’ with an abstract method ‘checkBalance()’. The concrete subclass ‘SBI’ extends ‘Bank’ and provides an implementation for ‘checkBalance()’. The ‘displayAccountInfo()’ method is inherited from the abstract class.

Also Read:

• Free Java Courses & Certifications
• Free Javascript Courses & Certifications

How to Achieve Abstraction in Java

Define an Abstract Class: Create an abstract class that encapsulates common attributes and behaviours.

Declare Abstract Methods: Within the abstract class, declare abstract methods that specify behaviours to be implemented by subclasses.

Create Concrete Subclasses: Develop concrete subclasses that extend the abstract class and provide implementations for the abstract methods.

Instantiate Subclasses: Create instances of concrete subclasses and utilise their functionalities.

Abstraction in Java Real-Time Example

One common abstraction in Java real time example is the use of JDBC (Java Database Connectivity) to interact with databases. JDBC provides an abstract interface for connecting to different databases, and various database vendors implement this interface with their specific drivers. This abstraction allows developers to write database code without being tied to a particular database system.

Data Abstraction Example in Java

Data abstraction is prevalent in everyday Java programming. A classic example is working with a List data structure. Developers use high-level List interfaces without needing to know the internal implementation details of specific List classes like ArrayList or LinkedList. This level of abstraction simplifies programming and promotes code reusability.

Related: Java Certification Courses by Top Providers

• Udemy Java Certification Courses
• Udacity Java Certification Courses
• Coursera Java Certification Courses
• Edureka Java Certification Courses
• Intellipaat Java Certification Courses
• Coding Ninjas Java Certification Courses
• Microsoft Corporation Java Certification Courses
• Amazon Web Services Java Certification Courses

Conclusion

Abstraction in Java, achieved through abstract classes and abstract methods, is a powerful tool for simplifying complex systems and building modular, maintainable code. By defining essential attributes and behaviours in abstract classes, you can create a strong foundation for your application's architecture. As you explore the world of Java programming, remember that abstraction is a key concept that can lead to more efficient and scalable software.