Abstraction in Java: Types of Abstraction Explained Examples

Programming languages are the foundation of digital transformation, enabling seamless communication between developers and computers. Among them, Abstraction in Java plays a crucial role in simplifying complex systems by hiding implementation details and exposing only essential functionalities. Java remains a dominant language due to its platform independence, object-oriented nature, and widespread applications in web development, enterprise software, and more.

With Java's continued relevance, mastering key concepts like Abstraction in Java is essential for developers aiming to excel in the competitive software industry. Abstraction enhances code maintainability, improves security, and fosters efficient software design. Understanding this principle not only strengthens programming skills but also increases job prospects, making it a valuable asset for aspiring Java developers.

In this blog, we will learn what abstraction in Java and abstraction in oops is with examples and discuss the way forward in a career in software engineering.
 

Get Software Engineering degrees online from the World’s top Universities. Earn Executive PG Programs, Advanced Certificate Programs, or Masters Programs to fast-track your career.

Read on to find out more about this. 

What Is Meant By Abstraction In OOP?

OOP stands for object-oriented programming known by four important tenets – Abstraction, Encapsulation, Inheritance and Polymorphism. Abstraction is the first pillar of OOP and is the process of selecting data to show only certain information to the end-user.

For example, while pressing the ignition button on our cars, most of us are concerned only with whether the car starts or not. We are never concerned about what goes behind the scene, from when we press the ignition to when the car starts up. If this event was a code, the process of abstraction could be used to filter out only the information of starting the car. In essence, abstraction in oop is a tool that helps reduce programming time, effort, and complexity. 

Read on to find out about abstraction in Java.

What is Abstraction In Java?

In Java, a class defined by the ‘abstract’ keyword is called an abstract class. It can be declared using abstract or non-abstract methods. But before we understand the abstract class, it is essential to learn what the abstraction method in Java is all about. 

Abstraction in Java is the process of masking implementation details from the user in a way to display only functionality. In other words, it displays only the essential information to a user while hiding the background details of the object. Thus, abstraction helps us filter details about what an object does and ditch the how of it. 

There are two ways of completing the abstraction method in Java – abstract class and interface. As mentioned above, an abstract class is a class that is declared abstract by using that particular keyword. It can be implemented by abstract or non-abstract methods but abstract classes require extensions and implementation of the abstract method java. 

Benefits of Abstraction

The use of data abstraction in Java offers several benefits. 

• Firstly, it enhances code reusability by providing a blueprint for creating objects with similar behaviour. With abstraction, classes can be designed to inherit common properties and methods from interfaces or abstract classes, reducing redundant code and promoting modular programming.
• Secondly, abstraction improves code maintainability. By encapsulating implementation details, changes to the underlying code do not affect the code that depends on the abstract representation.
• Furthermore, abstraction promotes code extensibility. Interfaces and abstract classes define a contract that concrete classes must adhere to. This enables developers to introduce new implementations without modifying the existing codebase.

Unlock your coding potential with our comprehensive free Java course! Join now to build real-world skills and accelerate your tech journey

Common Uses of Data Abstraction in Java

Data abstraction is widely used in Java programming to achieve various goals. 

• One common use case includes the implementation of libraries and frameworks. By providing an interface and abstract class, these libraries define a set of operations that developers can use to interact with the underlying functionality. This allows for consistent and standardized usage of the library across different projects.
• Another common use case is in designing user interfaces (UIs). Developers can create specific implementations of UI components using the abstract classes or interfaces provided by UI frameworks to define their structure and behaviour. 

Example of Data Abstraction in Java

To explain the concept of data abstraction, let’s consider an example of a shape hierarchy. We can define an abstract class called Shape, which declares an abstract method calculateArea(). This class serves as a blueprint for different shapes like Circle and Rectangle that inherit from it. Each concrete shape class must provide its implementation of the calculateArea() method.

abstract class Shape {
    public abstract double calculateArea();
}
class Circle extends Shape {
    private double radius;
    public Circle(double radius) {
        this.radius = radius;
    }
    @Override
    public double calculateArea() {
        return Math.PI * radius * radius;
    }
}
class Rectangle extends Shape {
    private double length;
    private double width;
    public Rectangle(double length, double width) {
        this.length = length;
        this.width = width;
    }
    @Override
    public double calculateArea() {
        return length * width;
    }
}
public class Main {
    public static void main(String[] args) {
        Shape circle = new Circle(5);
        Shape rectangle = new Rectangle(4, 6);
        System.out.println("Circle area: " + circle.calculateArea());
        System.out.println("Rectangle area: " + rectangle.calculateArea());
    }
}
+ rectangle.calculateArea()); } }

Abstract Method In Java: Examples With Explanations

An abstract method declares an object as abstract, and the object is not implemented. Here are some examples of the abstract method.

An abstract class with the abstract method

In the example below, Tea is the abstract class with only one abstract method implemented by the Honda class.

abstract class Tea{  
  abstract void run();  
}  
class Honda4 extends Tea{  
void run(){System.out.println("running safely");}  
public static void main(String args[]){  
 Tea obj = new Honda4();  
 obj.run();  
}  
} 
Outcome - running safely

An abstract class with the factory method

Figure is the abstract class implemented by the Rectangle and Circle classes in the example below. Here we don’t see the implementation class since it is hidden from the user. So to obtain the object of the implementation class, we use a method called the factory method. The factory method is a method that provides the instance of the class. 

abstract class Figure{  
abstract void draw();  
}  

//In real scenario, implementation is provided by others i.e. unknown by end user  

class Rectangle extends Figure{  
void draw(){System.out.println("drawing rectangle");}  
}  
class Circle1 extends Figure{  
void draw(){System.out.println("drawing circle");}  
}  

//In real scenario, method is called by programmer or user  

class TestAbstraction1{  

public static void main(String args[]){  

Figure s=new Circle1();//In a real scenario, object is provided through method, e.g., getFigure() method  

s.draw();  
}  
}  

Outcome - drawing circle

An abstract class with data member, constructor and methods

An abstract class has an abstract or non-abstract method, a data member, constructor and also main method. The example below explains this.

//Example of an abstract class that has abstract and non-abstract methods  

 abstract class Tea{

   Tea(){System.out.println(“tea is created”);}  

   abstract void run();  

   void changeGear()

{System.out.println(“gear changed”);}  

 }  

//Creating a Child class which inherits Abstract class  

 class Honda extends Tea{  
 void run(){System.out.println("running safely..");}  
 }  
//Creating a Test class which calls abstract and non-abstract methods  
 class TestAbstraction2{  
 public static void main(String args[]){  
  Tea obj = new Honda();  
  obj.run();  
  obj.changeGear();  
 }  
}  
Outcome – 
tea is created
running safely
Gear changed

Why do we use Abstract?

Abstract is a powerful tool to create better software designs and reduce complexity. Abstracting away unnecessary details helps to ensure that the code is easier to understand, test, and maintain. It also allows developers to focus primarily on the more important parts of their applications instead of getting bogged down in complex low-level details.

There are two main types of abstraction in Java: interface and abstract class.

Interface Abstraction is a way of defining the public methods that a particular type of object must implement without having to define how those methods work. This allows for code reuse and provides an easy way for developers to ensure that their objects meet certain standards when they interact with other components.

Abstract Class Abstraction is a more powerful form of abstraction than an interface. Unlike interfaces, abstract classes can contain both method declarations and implementations. This makes them ideal for situations where multiple implementations of the same functionality may exist, but all should share the same underlying structure.

Data Abstraction in Java is another type of abstraction used to simplify the data model of a program. Data abstraction allows developers to ignore unnecessary details and focus on the vital aspects of their programs. Abstracting irrelevant data makes it easier for developers to create cleaner, simpler, and more understandable code.

Abstraction in Java is an incredibly powerful tool for creating better software designs and reducing complexity. With its various types of abstraction, developers can easily define their objects’ public methods without having to worry about how they work. They can also use data abstraction to simplify complex models and focus on what matters most. Proper usage of Abstraction in Java can make software development much faster and easier!

How To Have A Successful Career As A Software Engineer?

Whether you are just starting off with programming languages or just looking to enhance your Java skills, a degree or professional certificate in software engineering is an excellent idea to further your career prospects. Having a certificate from a reputed institution is proof of aptitude, expertise and skillset that every employer values.

upGrad offers a unique Job-linked PG certification in software engineering that is the perfect short-term program to catapult your software engineering aspirations to the moon. It’s a five-month certification course with a high track record of producing industry-ready software professionals. It’s a training and polishing program designed for first-time technology job aspirants and provides specialization in MERN or Cloud-Native. Students learn Java, OODAP, DSA, HTML5, CSS3, JavaScript, SQL and NoSQL Databases and a lot more. 

upGrad specializes in designing unique gap-focussed programs designed especially for working professionals or final year students. This certificate program also includes flexible class hours and 360-degree career assistance. 

Conclusion

Software engineers are some of the most demanded professionals in the market. Career opportunities in software engineering promise high salaries and come with guarantees of long-term stability and professional growth. upGrad’s certification is an excellent addition to anyone’s resume. Thus, we would highly recommend that aspirants waste no time claiming this rare, extraordinary opportunity.