Difference between Abstraction and Encapsulation in Java with Examples

Abstraction and Encapsulation are two fundamental concepts of Object-Oriented Programming in Java. Both help in designing secure, maintainable, and flexible applications, but they serve different purposes. Understanding their difference is important for writing clean and scalable code.

• Both are core principles of OOP in Java
• Help in improving code security and maintainability
• Often used together but solve different problems

Abstraction

Abstraction focuses on hiding implementation details and showing only the essential features of an object. It allows you to define what an object does without explaining how it does it.

• Achieved using abstract classes and interfaces
• Hides complex logic from the user
• Improves flexibility and reduces code complexity

Real-Life Example: When you drive a car, you just use the steering, brake, and accelerator. You don’t need to know how the engine works internally.

abstract class Vehicle {
    abstract void start(); // abstract method
}

class Car extends Vehicle {
    void start() {
        System.out.println("Car starts with key");
    }
}

public class Geeks{
    public static void main(String[] args) {
        Vehicle v = new Car();
        v.start();
    }
}

Car starts with key

Explanation: The Vehicle class declares an abstract method start() without implementation and Car class provides the actual implementation of the start() method. User only calls start() without knowing how it works internally (implementation is hidden).

Encapsulation

Encapsulation focuses on wrapping data (variables) and methods into a single unit and restricting direct access to the data. It protects the internal state of an object.

• Achieved using private variables and getter/setter methods
• Provides data security and control
• Helps in maintaining integrity of data

Real-Life Example: A bank account does not allow direct access to balance. You can only access or modify it through methods like deposit() or withdraw().

class Student {
    private int marks; // private variable

    public int getMarks() {
        return marks;
    }

    public void setMarks(int marks) {
        if(marks >= 0) {
            this.marks = marks;
        }
    }
}

public class  Geeks{
    public static void main(String[] args) {
        Student s = new Student();
        s.setMarks(90);
        System.out.println(s.getMarks());
    }
}

90

Explanation: The variable marks is declared as private, so it cannot be accessed directly. The getMarks() method is used to read the value, and setMarks() is used to update it. This ensures controlled access and prevents invalid data from being assigned.

Abstraction vs Encapsulation