What is Abstraction in Java?
Abstraction is one of the four main pillars of Object-Oriented Programming (OOP) — along with Encapsulation, Inheritance, and Polymorphism.
Abstraction means hiding internal implementation details and showing only the essential features of an object.
It allows you to focus on what an object does instead of how it does it.
Real-life Example
Think of driving a car:
- You press the accelerator to move, brake to stop.
- You don’t need to know how the engine or gears work internally.
That’s abstraction — only important details are shown to the user.
Why Abstraction?
- Reduces code complexity
- Improves security (by hiding implementation)
- Makes code reusable and maintainable
- Helps achieve loose coupling
How Abstraction Works in Java
In Java, abstraction can be achieved in two main ways:
- Using Abstract Classes
- Using Interfaces
Abstract Class in Java
- An abstract class is a class declared with the keyword
abstract. - It can include abstract methods (without body) and concrete methods (with body).
- You cannot create objects of an abstract class directly.
Syntax
abstract class ClassName {
abstract void methodName(); // Abstract method (no body)
void normalMethod() { // Concrete method
System.out.println("This is a concrete method");
}
}
Example – Abstract Class
abstract class Animal {
abstract void sound(); // Abstract method
void sleep() {
System.out.println("Animal is sleeping");
}
}
class Dog extends Animal {
void sound() {
System.out.println("Dog barks");
}
}
public class AbstractClassExample {
public static void main(String[] args) {
Animal a = new Dog(); // Reference of abstract class
a.sound();
a.sleep();
}
}
Output:
Dog barks
Animal is sleeping
Something About Abstract Classes
- Cannot be instantiated directly
- Can contain both abstract and concrete methods
- Can have constructors, fields, and static methods
- Subclasses must override all abstract methods
- Used for partial abstraction
Abstract Methods in Java
- An abstract method is declared using the keyword
abstractand does not have a body. - It defines a method signature, but the actual implementation is provided in subclasses.
Syntax
abstract returnType methodName();
Example – Abstract Method
abstract class Shape {
abstract void draw(); // Abstract method
}
class Circle extends Shape {
void draw() {
System.out.println("Drawing a Circle");
}
}
class Rectangle extends Shape {
void draw() {
System.out.println("Drawing a Rectangle");
}
}
public class AbstractMethodExample {
public static void main(String[] args) {
Shape s = new Circle();
s.draw();
}
}
Output:
Drawing a Circle
Interface in Java
- An interface is a fully abstract type that contains only method declarations (no implementation).
- It is used to achieve 100% abstraction and multiple inheritance in Java.
Syntax
interface InterfaceName {
void method1(); // implicitly public and abstract
}
Example – Interface
interface Vehicle {
void start(); // abstract method
}
class Car implements Vehicle {
public void start() {
System.out.println("Car starts with a key");
}
}
class Bike implements Vehicle {
public void start() {
System.out.println("Bike starts with a button");
}
}
public class InterfaceExample {
public static void main(String[] args) {
Vehicle v = new Car();
v.start();
}
}
Output:
Car starts with a key
Interface – Java 8 Enhancements
From Java 8 onwards, interfaces can also have:
- default methods → with implementation
- static methods → called using the interface name
Example – Default & Static Methods in Interface
interface Test {
void show(); // abstract method
default void display() {
System.out.println("Default method in interface");
}
static void print() {
System.out.println("Static method in interface");
}
}
class Example implements Test {
public void show() {
System.out.println("Implemented show() method");
}
}
public class InterfaceFeatures {
public static void main(String[] args) {
Example obj = new Example();
obj.show();
obj.display();
Test.print();
}
}
Output:
Implemented show() method
Default method in interface
Static method in interface
Diagram Concept – Abstract Class vs Interface
[Abstract Class: Vehicle]
/ \\
[Car] (extends) [Bike] (extends)
- start() - start()
- stop()
[Interface: Payment]
-----------------------------
| pay(amount) |
-----------------------------
/ | \\
CreditCardPayment PayPalPayment UPIPayment
Explanation:
- Abstract class Vehicle: can have concrete methods (
stop()) and abstract methods (start()). - Interface Payment: only method declarations; multiple classes implement it.
- Abstraction hides internal workings from the user.
Difference Between Abstract Class and Interface
| Feature | Abstract Class | Interface |
|---|---|---|
| Abstraction Level | Partial (0–100%) | Full (100%) |
| Methods | Abstract + Concrete | Abstract, default, static |
| Access Modifiers | Can be any (public, protected, private) | All methods are public |
| Variables | Instance or static | Always public static final |
| Inheritance | Single inheritance | Multiple inheritance |
| Keyword | extends | implements |
| Use Case | Common base with shared logic | Define contract or capability |
When to Use What
| Use Case | Prefer |
|---|---|
| You want to share common code | Abstract Class |
| You want to define only a contract | Interface |
| You need multiple inheritance | Interface |
| Partial implementation required | Abstract Class |
Points to Remember
- Abstraction hides unnecessary implementation details.
- Achieved via abstract classes (partial) and interfaces (complete).
- Improves readability, reusability, and maintainability.
- Widely used in frameworks (like JDBC, Collections, Spring).
Real-World Example – Abstraction in Java
Scenario: Payment System
We have multiple types of payments (Credit Card, PayPal, UPI), but the user only interacts with a generic Payment interface. The implementation details are hidden — classic abstraction.
// Interface for abstraction
interface Payment {
void pay(double amount); // abstract method
}
// Implementation 1: Credit Card Payment
class CreditCardPayment implements Payment {
public void pay(double amount) {
System.out.println("Paid " + amount + " using Credit Card");
}
}
// Implementation 2: PayPal Payment
class PayPalPayment implements Payment {
public void pay(double amount) {
System.out.println("Paid " + amount + " using PayPal");
}
}
// Implementation 3: UPI Payment
class UPIPayment implements Payment {
public void pay(double amount) {
System.out.println("Paid " + amount + " using UPI");
}
}
// Client code
public class PaymentDemo {
public static void main(String[] args) {
Payment payment;
// User chooses Credit Card
payment = new CreditCardPayment();
payment.pay(1000);
// User switches to PayPal
payment = new PayPalPayment();
payment.pay(500);
}
}
Output:
Paid 1000 using Credit Card
Paid 500 using PayPalSummary Table
| Concept | Description | Example |
|---|---|---|
| Abstract Class | Base class with both abstract and normal methods | abstract class Shape |
| Abstract Method | Declared without a body, implemented in subclass | abstract void draw() |
| Interface | Fully abstract type, supports multiple inheritance | interface Vehicle |
| Default Method | Method with body in interface (Java 8+) | default void show() |