Day 9 Java Learning Journey

Inner Classes & Anonymous Classes - Telusko Udemy Course

1

Inner Classes

An inner class is a class defined inside another class. We create inner classes when a class is only needed by its outer class and shouldn't be used independently by any other class.

Real-life Example: Amazon Order System

Think about when you place an order on Amazon:

• Order ID
• Total amount
• Delivery address
• Delivery status (packed, shipped, "Out for delivery")

The delivery status makes sense ONLY in the context of an order - a perfect candidate for an inner class!

public class Order {
    private int orderId;
    private int amount;
    
    public Order(int orderId, int amount) {
        this.orderId = orderId;
        this.amount = amount;
    }
    
    // Inner class - only relevant to Order
    class DeliveryStatus {
        private String status;
        
        public DeliveryStatus(String status) {
            this.status = status;
        }
        
        public void showStatus() {
            System.out.println("Order ID: " + orderId);
            System.out.println("Status: " + status);
        }
    }
    
    public static void main(String[] args) {
        Order order = new Order(101, 999);
        Order.DeliveryStatus ds = order.new DeliveryStatus("Out for delivery");
        ds.showStatus();
    }
}

2

Anonymous Inner Classes

Like Writing Sticky Notes

Just like writing sticky notes while reading a book - quick reminders without creating a separate notebook!

Real-life Example: Amazon Order Confirmation

When you place an order, a confirmation message pops up. This happens once, and we don't need a separate class for it. We create a tiny, nameless class just for this single action.

public interface Notes {
    void remember();
}

public class AnonymousInnerClass {
    public static void main(String[] args) {
        // Anonymous class implementing Notes interface
        Notes stickyNote = new Notes() {
            @Override
            public void remember() {
                System.out.println("Remember this formula: a² + b² = c²");
            }
        };
        
        stickyNote.remember();
    }
}

3

Abstract + Anonymous Classes Combination

Like a Half-Finished Assignment

An abstract class is like a half-finished plan. Remember school days when you'd start assignments and ask siblings to finish them for chocolates? That's abstraction!

Amazon Delivery Partner Example

Amazon has many delivery partners. They don't care who delivers as long as the order arrives. We can combine abstract classes with anonymous classes:

abstract class DeliveryPartner {
    abstract void deliver();
}

public class Delivery {
    public static void main(String[] args) {
        // Anonymous class extending abstract class
        DeliveryPartner partner = new DeliveryPartner() {
            @Override
            void deliver() {
                System.out.println("Your order will be delivered by bike");
            }
        };
        
        partner.deliver();
    }
}

Key Takeaways

Inner Classes

For tightly coupled components that only make sense together (like Order and DeliveryStatus).

Anonymous Classes

One-time use classes without formal declaration (like a quick confirmation popup).

Abstract + Anonymous

Quick implementation of abstract classes without creating concrete subclasses.

When to Use What?

Scenario	Best Choice	Real-life Example
Component only relevant to one class	Inner Class	DeliveryStatus inside Order
One-time implementation	Anonymous Class	Order confirmation message
Partial implementation needed	Abstract + Anonymous	Different delivery partners

Practice these concepts with your own e-commerce examples!

Try creating a shopping cart with inner classes for cart items, or payment confirmation with anonymous classes.

Happy coding!

Blog post created from Java learning notes - Day 9