Difference Between Encapsulation and Abstraction Explained

Parameter 

Encapsulation 

Abstraction 

Objective 

Wraps data and method to form a single unit 

Hide complex and unnecessary details except for the important part 

Usage 

To maintain privacy to avoid unauthorized access

Decrease complexity by hiding the essential features 

Implementation 

Performed through access modifiers such as public, private and protected 

Done via abstract classes and interfaces 

Function 

Contains the information 

Gains the information 

Dependency 

Data is not necessary to be abstracted for encapsulation 

Data is encapsulated for abstraction 

Focus 

Involves ‘how’ object performs the action 

Involves ‘what’ action object performs

Offers solution at 

Deals with issues at the implementation level 

Deals with issues at the design level 

// Base class Vehicle (encapsulating internal details)

class Vehicle {

    // Private variables (encapsulation)

    private int fuelLevel;        // Fuel level in percentage (0 to 100)

    private boolean engineState;  // Engine state (true = running, false = stopped)

    // Constructor to initialize fuel level and engine state

    public Vehicle(int fuelLevel) {

        this.fuelLevel = fuelLevel;

        this.engineState = false;  // Engine is off by default

    }

    // Public method to get fuel level

    public int getFuelLevel() {

        return fuelLevel;

    }

    // Public method to set fuel level

    public void setFuelLevel(int fuelAmount) {

        if (fuelAmount >= 0 && fuelAmount <= 100) {

            this.fuelLevel = fuelAmount;

        } else {

            System.out.println("Invalid fuel level. Must be between 0 and 100.");

        }

    }

    // Public method to start the engine

    public void startEngine() {

        if (fuelLevel > 0) {

            engineState = true;

            System.out.println("Engine started.");

        } else {

            System.out.println("Cannot start engine. No fuel.");

        }

    }

    // Public method to stop the engine

    public void stopEngine() {

        engineState = false;

        System.out.println("Engine stopped.");

    }

    // Public method to check if engine is running

    public boolean isEngineRunning() {

        return engineState;

    }

}

// Derived class Car

class Car extends Vehicle {

    // Constructor for Car

    public Car(int fuelLevel) {

        super(fuelLevel);  // Initialize fuel level using Vehicle constructor

    }

    // Method for driving the car

    public void drive() {

        if (isEngineRunning()) {

            System.out.println("The car is driving.");

        } else {

            System.out.println("Start the engine first.");

        }

    }

}

// Derived class Motorcycle

class Motorcycle extends Vehicle {

    // Constructor for Motorcycle

    public Motorcycle(int fuelLevel) {

        super(fuelLevel);  // Initialize fuel level using Vehicle constructor

    }

    // Method for driving the motorcycle

    public void drive() {

        if (isEngineRunning()) {

            System.out.println("The motorcycle is driving.");

        } else {

            System.out.println("Start the engine first.");

        }

    }

}

// Main class to test the example

public class Main {

    public static void main(String[] args) {

        // Create a car and motorcycle with initial fuel levels

        Car myCar = new Car(50);

        Motorcycle myBike = new Motorcycle(10);

        // Try to drive the car and bike without starting the engine

        myCar.drive();  // Engine should be started first

        myBike.drive(); // Engine should be started first

        // Start the car engine and drive

        myCar.startEngine();

        myCar.drive();  // Now the car can drive

        // Set new fuel level for the bike and start the engine

        myBike.setFuelLevel(20);

        myBike.startEngine();

        myBike.drive();  // Now the motorcycle can drive

        // Stop the car engine

        myCar.stopEngine();

    }

}

Start the engine first.

Start the engine first.

Engine started.

The car is driving.

Invalid fuel level. Must be between 0 and 100.

Engine started.

The motorcycle is driving.

Engine stopped.

// Abstract class representing a generic Vehicle

abstract class Vehicle {

    // Encapsulated field representing the fuel level of the vehicle

    private int fuelLevel;

    // Constructor to initialize fuel level

    public Vehicle(int fuelLevel) {

        this.fuelLevel = fuelLevel;

    }

    // Getter and setter for fuel level (Encapsulation)

    public int getFuelLevel() {

        return fuelLevel;

    }

    public void setFuelLevel(int fuelLevel) {

        if (fuelLevel >= 0 && fuelLevel <= 100) {

            this.fuelLevel = fuelLevel;

        } else {

            System.out.println("Invalid fuel level. Must be between 0 and 100.");

        }

    }

    // Abstract method that forces subclasses to implement the drive behavior (Abstraction)

    public abstract void drive();

}

// Interface defining the service actions for vehicles

interface VehicleService {

    void serviceVehicle();  // Method to service the vehicle

}

// Concrete class Car that extends Vehicle and implements VehicleService

class Car extends Vehicle implements VehicleService {

    // Constructor for Car class

    public Car(int fuelLevel) {

        super(fuelLevel);  // Call the parent constructor to initialize fuel level

    }

    // Implementation of the drive method specific to Car

    @Override

    public void drive() {

        if (getFuelLevel() > 0) {

            System.out.println("Car is driving.");

        } else {

            System.out.println("No fuel! Can't drive the car.");

        }

    }

    // Implementation of the serviceVehicle method specific to Car

    @Override

    public void serviceVehicle() {

        System.out.println("Performing routine service on the car.");

    }

}

// Concrete class Motorcycle that extends Vehicle and implements VehicleService

class Motorcycle extends Vehicle implements VehicleService {

    // Constructor for Motorcycle class

    public Motorcycle(int fuelLevel) {

        super(fuelLevel);  // Call the parent constructor to initialize fuel level

    }

    // Implementation of the drive method specific to Motorcycle

    @Override

    public void drive() {

        if (getFuelLevel() > 0) {

            System.out.println("Motorcycle is driving.");

        } else {

            System.out.println("No fuel! Can't drive the motorcycle.");

        }

    }

    // Implementation of the serviceVehicle method specific to Motorcycle

    @Override

    public void serviceVehicle() {

        System.out.println("Performing routine service on the motorcycle.");

    }

}

// Main class to test the abstraction and interface implementation

public class Main {

    public static void main(String[] args) {

        // Create instances of Car and Motorcycle

        Car myCar = new Car(50);  // Car with 50% fuel

        Motorcycle myMotorcycle = new Motorcycle(20);  // Motorcycle with 20% fuel

        // Test driving functionality

        myCar.drive();  // Should print: "Car is driving."

        myMotorcycle.drive();  // Should print: "Motorcycle is driving."

        // Service the vehicles

        myCar.serviceVehicle();  // Should print: "Performing routine service on the car."

        myMotorcycle.serviceVehicle();  // Should print: "Performing routine service on the motorcycle."

        // Test cases where vehicles have no fuel

        myCar.setFuelLevel(0);

        myCar.drive();  // Should print: "No fuel! Can't drive the car."

        myMotorcycle.setFuelLevel(0);

        myMotorcycle.drive();  // Should print: "No fuel! Can't drive the motorcycle."

    }

}

Car is driving.

Motorcycle is driving.

Performing routine service on the car.

Performing routine service on the motorcycle.

No fuel! Can't drive the car.

No fuel! Can't drive the motorcycle.