Abstraction in Java

Introduction

Abstraction means hiding internal implementation details and showing only the essential functionality of an object. Abstraction reduces complexity by allowing users to focus on what an object does instead of how it performs the operation.

For example, a person can drive a car using the steering wheel, brakes, and accelerator without understanding every internal part of the engine.

Abstraction

Features of Abstraction

Hides unnecessary implementation details
Shows only essential functionality
Reduces program complexity
Improves code organization
Makes implementation easier to modify
Allows different classes to implement the same operation differently

How Is Abstraction Achieved in Java?

Java mainly provides two ways to achieve abstraction:

Abstract classes
Interfaces

Abstract Class in Java

An abstract class is a class declared using the abstract keyword. It cannot be instantiated directly and is designed to be extended by other classes.

An abstract class can contain:

Abstract methods
Regular methods
Attributes
Constructors
Static methods

Abstract Method

An abstract method is declared without a method body. A concrete child class must provide its implementation.

abstract void start();

Abstract Class Example in Java

1// Abstract class represents a general vehicle
2abstract class Vehicle {
3
4    // Abstract method has no implementation
5    // Child classes must provide its implementation
6    abstract void start();
7
8    // Regular method contains a common implementation
9    void stop() {
10        System.out.println("Vehicle stopped."); 
11    }
12}
13
14// Car extends the abstract Vehicle class
15class Car extends Vehicle {
16
17    // Provide the implementation of the abstract method
18    @Override
19    void start() {
20        System.out.println("Car starts with a key."); 
21    }
22}
23
24public class Main {
25    public static void main(String[] args) {
26
27        // Create a Car object using a Vehicle reference
28        Vehicle vehicle = new Car();
29
30        // Call the implemented abstract method
31        vehicle.start(); // Output :- Car starts with a key.
32
33        // Call the regular method inherited from Vehicle
34        vehicle.stop(); // Output :- Vehicle stopped.
35
36        // An abstract class cannot be instantiated directly
37        // Vehicle v = new Vehicle(); // Compilation error
38    }
39}

In this example, Vehicle defines the required start() operation without explaining how a vehicle starts. The Car class provides the actual implementation.

Abstract method

Important Features of Abstract Classes

Declared using the abstract keyword
Cannot be instantiated directly
Can contain abstract and regular methods
Can contain attributes and constructors
Extended using the extends keyword
A class can extend only one abstract class

Interface in Java

An interface in Java defines a set of operations that implementing classes must provide. It specifies what a class should do without requiring one specific implementation.

An interface is declared using the interface keyword. A class uses the implements keyword to implement it.

1interface InterfaceName {
2    void methodName();
3}

Methods declared without a body in an interface are implicitly public and abstract.

Interface Example in Java

1// Interface defines the required payment operation
2interface Payment {
3
4    // Interface method has no implementation
5    void pay(double amount);
6}
7
8// CardPayment implements the Payment interface
9class CardPayment implements Payment {
10
11    // Provide the implementation of the interface method
12    @Override
13    public void pay(double amount) {
14        System.out.println("Paid " + amount + " using card."); 
15    }
16}
17
18public class Main {
19    public static void main(String[] args) {
20
21        // Create a CardPayment object using an interface reference
22        Payment payment = new CardPayment();
23
24        // Call the implemented interface method
25        payment.pay(500);  // Output :- Paid 500.0 using card.
26    }
27}

In this example, the Payment interface defines a pay() method. The CardPayment class decides how that payment operation is performed.

Interface

Important Features of Interfaces

Declared using the interface keyword
Cannot be instantiated directly
Implemented using the implements keyword
Defines common behaviour for implementing classes
A class can implement multiple interfaces
Implementing classes must provide the required method implementations

Abstract Class vs Interface

Abstract Class	Interface
Declared using `abstract class`	Declared using `interface`
Extended using `extends`	Implemented using `implements`
Can contain abstract and regular methods	Mainly defines behaviour that classes must implement
Can contain instance attributes	Fields are constants by default
Can have constructors	Cannot have constructors
A class can extend only one abstract class	A class can implement multiple interfaces
Suitable for closely related classes	Suitable for defining common behaviour across classes

Advantages of Abstraction

Reduced complexity: Unnecessary implementation details remain hidden.
Flexibility: Internal code can change without affecting its usage.
Reusability: Common behaviour can be shared through abstract classes.
Consistency: Interfaces can require multiple classes to follow the same structure.
Maintainability: Programs become easier to update and manage.

Abstraction vs Encapsulation

Abstraction hides implementation details and exposes essential behaviour.
Encapsulation protects data by restricting direct access to it.

Abstraction focuses on what an object does, while encapsulation focuses on protecting the object’s internal data.

Summary

Abstraction in Java hides internal implementation details and displays only essential functionality. Java achieves abstraction using abstract classes and interfaces.

Abstract classes can contain both abstract and regular methods, while interfaces mainly define operations that implementing classes must provide.