Abstraction in Java

At a shop counter you pay by scanning a UPI code, tapping a card or using net banking. You don't need to know how the bank's servers talk to each other; you only need "pay this amount". Abstraction is that idea in code: expose what an object can do, and hide how it does it. Code that uses the object depends only on the "what", so the "how" can change, or be swapped for a completely different one, without breaking anything.

What, Not How

public class Checkout {
    interface PaymentMethod {
        String pay(long amount);
    }
 
    static class UpiPayment implements PaymentMethod {
        public String pay(long amount) {
            return "Paid Rs. " + amount + " by UPI";
        }
    }
 
    static class CardPayment implements PaymentMethod {
        public String pay(long amount) {
            return "Paid Rs. " + amount + " by card";
        }
    }
 
    static class NetBanking implements PaymentMethod {
        public String pay(long amount) {
            return "Paid Rs. " + amount + " by net banking";
        }
    }
 
    static void checkout(String customer, PaymentMethod method, long amount) {
        System.out.println(customer + ": " + method.pay(amount));
    }
 
    public static void main(String[] args) {
        checkout("Navika", new UpiPayment(), 499);
        checkout("Srihitha", new CardPayment(), 1250);
        checkout("Advitha", new NetBanking(), 3000);
    }
}

Navika: Paid Rs. 499 by UPI
Srihitha: Paid Rs. 1250 by card
Advitha: Paid Rs. 3000 by net banking

How it works

1. PaymentMethod says what a payment method can do: pay(amount). It has no code for how.
2. Each class supplies its own how.
3. checkout depends only on PaymentMethod. It doesn't know, or care, which class it's given. Adding a wallet payment later means writing one new class; checkout stays untouched.

Try it yourself: add a WalletPayment class and pay for Navika's second order with it.

Two Tools for Abstraction

Abstraction also exists without either: every well-named method is a small abstraction. Math.sqrt(2) hides the algorithm completely.

Abstraction vs Encapsulation

The two are often confused, because both "hide" something:

They work together: an interface (abstraction) is implemented by a class whose fields are private (encapsulation, see "Encapsulation in Java").

Common Mistakes

Designing the interface around one implementation. A PaymentMethod with getUpiId() isn't abstract; card payments have no UPI id.

Abstracting too early. One implementation with no second in sight rarely needs an interface yet.

Mixing up abstraction and encapsulation in interviews. Abstraction hides complexity; encapsulation hides data.

Interview Corner

Practice

1. Easy: Create an interface Shape with double area(), and Circle and Rectangle classes that implement it. Print both areas through Shape variables.
2. Harder: Write static long totalBill(PaymentMethod method, long[] items) that adds the items and pays the total. Call it with two different payment methods.

Key Takeaways