Unit 9: Abstract Class & Interface

Opening Hook — Every Aadhaar Verification Is a Java Interface in Action

Learning Outcomes — 12 Bloom's Taxonomy Mapped

Concept Explanation — Abstract Classes & Interfaces from Scratch

1. Abstract Class

Plain English: An abstract class is like an incomplete blueprint. Imagine an architect draws a building blueprint but leaves the "interior design" section blank — saying "whoever builds this MUST fill in the interiors." The blueprint provides walls, foundation, and plumbing (concrete methods), but the interior (abstract method) is left for the builder to decide. You cannot live in a blueprint — you can't instantiate an abstract class.

Java
// Abstract class — the incomplete blueprint
abstract class Shape {
    protected String color;

    // Constructor — yes, abstract classes can have constructors!
    public Shape(String color) {
        this.color = color;
        System.out.println("Shape constructor called: " + color);
    }

    // Abstract methods — NO body, subclass MUST implement
    public abstract double area();
    public abstract double perimeter();

    // Concrete method — shared by all shapes
    public void displayInfo() {
        System.out.println("Color: " + color);
        System.out.println("Area: " + area());
        System.out.println("Perimeter: " + perimeter());
    }
}

// Concrete subclass — Circle
class Circle extends Shape {
    private double radius;

    public Circle(double radius, String color) {
        super(color);           // calls Shape constructor
        this.radius = radius;
    }

    @Override
    public double area() {
        return Math.PI * radius * radius;
    }

    @Override
    public double perimeter() {
        return 2 * Math.PI * radius;
    }
}

// Concrete subclass — Rectangle
class Rectangle extends Shape {
    private double length, width;

    public Rectangle(double length, double width, String color) {
        super(color);
        this.length = length;
        this.width = width;
    }

    @Override
    public double area() {
        return length * width;
    }

    @Override
    public double perimeter() {
        return 2 * (length + width);
    }
}

// Driver
public class ShapeDemo {
    public static void main(String[] args) {
        Shape c = new Circle(7, "Red");
        Shape r = new Rectangle(10, 5, "Blue");

        c.displayInfo();
        System.out.println("---");
        r.displayInfo();

        // Shape s = new Shape("Green"); // ❌ ERROR: cannot instantiate abstract class
    }
}

2. Interface

Plain English: If an abstract class is an incomplete blueprint, an interface is a pure contract. Think of it like a government regulation: "Every restaurant MUST have a fire exit, a hygiene certificate, and a customer feedback system." The regulation doesn't say HOW to implement them — a dhaba and a 5-star hotel will do it differently — but both MUST comply. That's an interface.

Java
// Interface — the pure contract
interface Payable {

    // Abstract method — implementing class MUST define this
    double calculatePay();

    // Default method (Java 8+) — provides a default implementation
    default String getPaySlip() {
        return "Payment of ₹" + formatAmount(calculatePay()) + " processed.";
    }

    // Static method (Java 8+) — utility, called on interface itself
    static double convertToUSD(double inr) {
        return inr / 83.5;  // approximate rate
    }

    // Private method (Java 9+) — helper for default methods
    private String formatAmount(double amount) {
        return String.format("%.2f", amount);
    }
}

// Employee — full-time, monthly salary
class Employee implements Payable {
    String name;
    double monthlySalary;

    public Employee(String name, double monthlySalary) {
        this.name = name;
        this.monthlySalary = monthlySalary;
    }

    @Override
    public double calculatePay() {
        return monthlySalary;
    }

    @Override
    public String toString() {
        return "Employee: " + name;
    }
}

// Freelancer — paid per project
class Freelancer implements Payable {
    String name;
    int hoursWorked;
    double hourlyRate;

    public Freelancer(String name, int hoursWorked, double hourlyRate) {
        this.name = name;
        this.hoursWorked = hoursWorked;
        this.hourlyRate = hourlyRate;
    }

    @Override
    public double calculatePay() {
        return hoursWorked * hourlyRate;
    }

    @Override
    public String toString() {
        return "Freelancer: " + name;
    }
}

// Driver — Polymorphism via interface
public class PayableDemo {
    public static void main(String[] args) {
        Payable[] workers = {
            new Employee("Amit", 75000),
            new Freelancer("Priya", 120, 500),
            new Employee("Rahul", 90000),
            new Freelancer("Sneha", 80, 750)
        };

        for (Payable w : workers) {
            System.out.println(w);
            System.out.println(w.getPaySlip());
            System.out.println("In USD: $" + String.format("%.2f",
                Payable.convertToUSD(w.calculatePay())));
            System.out.println();
        }
    }
}

Multiple Interface Implementation

Java
interface Taxable {
    double TAX_RATE = 0.18;   // implicitly public static final
    double calculateTax();
}

interface Insurable {
    double getInsurancePremium();
}

// A class can implement MULTIPLE interfaces — Java's multiple inheritance!
class FullTimeEmployee implements Payable, Taxable, Insurable {
    String name;
    double salary;

    public FullTimeEmployee(String name, double salary) {
        this.name = name;
        this.salary = salary;
    }

    @Override public double calculatePay()           { return salary; }
    @Override public double calculateTax()           { return salary * TAX_RATE; }
    @Override public double getInsurancePremium()   { return salary * 0.02; }
}

3. Interface vs Abstract Class — Comprehensive Comparison

4. Functional Interface & @FunctionalInterface

A functional interface is an interface with exactly one abstract method (SAM — Single Abstract Method). It can have any number of default and static methods. Functional interfaces are the foundation of lambda expressions in Java 8+.

Java
@FunctionalInterface
interface Greeting {
    void greet(String name);  // exactly ONE abstract method
}

public class LambdaDemo {
    public static void main(String[] args) {
        // Traditional anonymous class
        Greeting g1 = new Greeting() {
            @Override
            public void greet(String name) {
                System.out.println("Namaste, " + name + "!");
            }
        };

        // Lambda expression — same thing, one line!
        Greeting g2 = name -> System.out.println("Hello, " + name + "!");

        g1.greet("Amit");   // Namaste, Amit!
        g2.greet("Priya");  // Hello, Priya!
    }
}

5. Marker Interfaces

A marker interface is an interface with zero methods. It simply "marks" or "tags" a class as having a certain capability. The JVM or framework checks instanceof to grant special treatment.

Java
import java.io.*;

// Without Serializable → NotSerializableException at runtime
class Student implements Serializable {
    private static final long serialVersionUID = 1L;
    String name;
    int rollNo;

    public Student(String name, int rollNo) {
        this.name = name;
        this.rollNo = rollNo;
    }
}

6. Interface Segregation Principle (ISP)

Part of the SOLID principles. "No client should be forced to depend on methods it does not use." Instead of one fat interface, create multiple small, focused interfaces.

Java
// ❌ BAD: Fat interface — forces all workers to implement every method
interface Worker {
    void code();
    void test();
    void deployToCloud();
    void managePeople();
    void designUI();
}

// ✅ GOOD: Segregated interfaces — each role implements only what it needs
interface Coder       { void code(); }
interface Tester      { void test(); }
interface DevOps      { void deployToCloud(); }
interface Manager     { void managePeople(); }
interface Designer    { void designUI(); }

// A full-stack developer implements only relevant interfaces
class FullStackDev implements Coder, Tester, Designer {
    @Override public void code()     { System.out.println("Writing Java code..."); }
    @Override public void test()     { System.out.println("Running JUnit tests..."); }
    @Override public void designUI() { System.out.println("Designing responsive UI..."); }
}

7. Strategy Pattern Using Interface (Brief)

The Strategy Pattern lets you define a family of algorithms, encapsulate each one as an interface implementation, and make them interchangeable at runtime. Think of it like a GPS app offering multiple route strategies: fastest, shortest, scenic — all implementing the same RouteStrategy interface.

Java
interface PaymentStrategy {
    void pay(double amount);
}

class UPIPayment implements PaymentStrategy {
    @Override public void pay(double amount) {
        System.out.println("Paid ₹" + amount + " via UPI (PhonePe/GPay)");
    }
}

class CardPayment implements PaymentStrategy {
    @Override public void pay(double amount) {
        System.out.println("Paid ₹" + amount + " via Credit/Debit Card");
    }
}

class ShoppingCart {
    private PaymentStrategy strategy;

    public void setPaymentStrategy(PaymentStrategy strategy) {
        this.strategy = strategy;
    }

    public void checkout(double amount) {
        strategy.pay(amount);  // strategy is interchangeable!
    }
}

8. Comparable & Comparator — Sorting with Interfaces

Java
import java.util.*;

// Comparable — natural ordering (built into the class)
class StudentRecord implements Comparable<StudentRecord> {
    String name;
    double cgpa;

    public StudentRecord(String name, double cgpa) {
        this.name = name;
        this.cgpa = cgpa;
    }

    // Natural ordering by CGPA (descending — highest first)
    @Override
    public int compareTo(StudentRecord other) {
        return Double.compare(other.cgpa, this.cgpa);  // descending
    }

    @Override
    public String toString() {
        return name + " (CGPA: " + cgpa + ")";
    }
}

// Comparator — external, custom ordering
class NameComparator implements Comparator<StudentRecord> {
    @Override
    public int compare(StudentRecord a, StudentRecord b) {
        return a.name.compareTo(b.name);  // alphabetical by name
    }
}

public class SortDemo {
    public static void main(String[] args) {
        List<StudentRecord> students = new ArrayList<>(Arrays.asList(
            new StudentRecord("Ravi", 8.5),
            new StudentRecord("Anita", 9.2),
            new StudentRecord("Kiran", 7.8),
            new StudentRecord("Deepa", 9.5)
        ));

        // Sort by CGPA (uses Comparable — natural order)
        Collections.sort(students);
        System.out.println("By CGPA (desc): " + students);

        // Sort by Name (uses Comparator)
        students.sort(new NameComparator());
        System.out.println("By Name (asc):  " + students);

        // Sort by CGPA ascending using lambda (Comparator)
        students.sort((a, b) -> Double.compare(a.cgpa, b.cgpa));
        System.out.println("By CGPA (asc):  " + students);
    }
}

Learn by Doing — 3-Tier Lab: Payable System

Problem Set — Syntax, Programming, Industry & Interview

Syntax Questions (5)

SQ-1: Find the Errors

Java
abstract class Vehicle {
    abstract void start() {
        System.out.println("Starting...");
    }
}
// Error: abstract method cannot have a body. Remove the braces and body.

SQ-2: Will This Compile?

Java
interface Printable {
    int MAX = 100;
    void print();
}
class Doc implements Printable {
    public void print() { System.out.println(MAX); }
}
// ✅ Yes, it compiles. MAX is implicitly public static final. print() is properly overridden with public.

SQ-3: What's Wrong?

Java
interface Drawable {
    void draw();
    protected void erase();  // ❌ ERROR
}
// Error: interface methods cannot be protected. They are implicitly public.

SQ-4: Missing Override

Java
abstract class Animal {
    abstract void sound();
    abstract void move();
}
class Dog extends Animal {
    void sound() { System.out.println("Bark"); }
}
// ❌ ERROR: Dog must implement move() or be declared abstract itself.

SQ-5: Interface Variable Assignment

Java
interface Config {
    int TIMEOUT = 30;
}
class AppConfig implements Config {
    void update() { TIMEOUT = 60; }  // ❌ ERROR
}
// Error: TIMEOUT is implicitly final. Cannot be reassigned.

Programming Questions (8)

PQ-1: Create an abstract class Vehicle with abstract method fuelEfficiency() and concrete method displayInfo(). Implement for Car (petrol) and ElectricBike (battery).

PQ-2: Design an interface Sortable with method sort(int[] arr). Implement it in BubbleSorter and SelectionSorter. Demonstrate strategy pattern by switching sorters at runtime.

PQ-3: Create interfaces Readable and Writable. Create a class TextFile that implements both. Create a class ReadOnlyFile that implements only Readable. Demonstrate interface segregation.

PQ-4: Write a functional interface MathOperation with method double operate(double a, double b). Use lambda expressions to implement add, subtract, multiply, and divide. Use a method that takes MathOperation as parameter.

PQ-5: Create abstract class Database with abstract methods connect() and query(String sql), and concrete method close(). Implement for MySQLDB and MongoDB.

PQ-6: Design a Notification interface hierarchy: interface Notification (send()), EmailNotification, SMSNotification, PushNotification. Process an array of Notification objects polymorphically.

PQ-7: Create a class Product implementing Comparable<Product> (sort by price). Create two Comparator implementations: by name and by rating. Sort a list of 5 products in 3 different ways.

PQ-8: Build a Validator<T> functional interface with boolean validate(T value). Create validators for email format, phone number (10 digits), and age (18–60) using lambda expressions.

Industry-Oriented Questions (3)

IQ-1: A food delivery app like Swiggy has different restaurant types: VegRestaurant, NonVegRestaurant, CloudKitchen. Design an abstract class Restaurant with abstract method calculateDeliveryCharge(double distance). Each restaurant type has different delivery logic. Show how polymorphism simplifies order processing.

IQ-2: An e-commerce platform like Flipkart needs to support multiple payment methods. Design a PaymentGateway interface with methods processPayment(double amount) and refund(String transactionId). Implement for UPI, Credit Card, and Net Banking. Explain how this design enables adding new payment methods without modifying existing code (Open-Closed Principle).

IQ-3: IRCTC needs to implement different ticket pricing strategies: Tatkal, Premium Tatkal, General, and Senior Citizen. Design this using the Strategy Pattern with an interface PricingStrategy. Show how a BookingEngine can switch strategies without changing its code.

Interview Questions (3)

INT-1: "Can we have a constructor in an abstract class? If yes, when is it called? Can we have a constructor in an interface? Why or why not?" — TCS, Infosys, Wipro frequently ask this.

INT-2: "A class implements two interfaces that both have a default method log() with different implementations. What happens? How do you resolve it?" — Google, Amazon, Flipkart ask this to test Java 8 knowledge.

INT-3: "You're designing a plugin system for an IDE. Should you use abstract class or interface for the plugin contract? Justify your choice with concrete reasoning." — JetBrains, IntelliJ, Eclipse Foundation design interviews.

MCQ Assessment Bank — 30 Questions (Bloom's Mapped)

Remember / Identify (Q1–Q6)

Understand / Explain (Q7–Q12)

Apply / Implement (Q13–Q18)

abstract class A { A() { System.out.print("A "); } }
class B extends A { B() { System.out.print("B "); } }
public class Test { public static void main(String[] a) { new B(); } }

interface X { default void show() { System.out.print("X "); } }
interface Y { default void show() { System.out.print("Y "); } }
class Z implements X, Y {
    public void show() { X.super.show(); Y.super.show(); }
}
new Z().show();

Analyze / Compare (Q19–Q23)

interface SmartDevice {
    void makeCall(); void sendSMS(); void browseWeb();
    void takePhoto(); void playMusic();
}

Evaluate / Justify (Q24–Q27)

interface Processor {
    void process();
    default void log() { System.out.println("Logging..."); }
    static void version() { System.out.println("v1.0"); }
}

Create / Design (Q28–Q30)

Short Answer Questions (8)

SA-1: What is an abstract class? Can it have constructors?

Answer: An abstract class is a class declared with the abstract keyword that cannot be instantiated directly. It may contain both abstract methods (without body) and concrete methods (with body). Yes, abstract classes can have constructors. These constructors are called when a concrete subclass is instantiated — the subclass constructor calls super() which invokes the abstract class constructor. This is used to initialize common fields shared by all subclasses.

SA-2: Differentiate between abstract and final keywords.

Answer: abstract means "incomplete — must be extended/overridden." final means "complete — cannot be extended/overridden." They are opposites. An abstract class MUST be subclassed; a final class CANNOT be subclassed. An abstract method MUST be overridden; a final method CANNOT be overridden. You cannot use both together on the same class or method — abstract final class Foo is a compile error.

SA-3: What are default methods in interfaces? Why were they introduced?

Answer: Default methods are interface methods with a body, declared using the default keyword (Java 8+). They were introduced to solve the interface evolution problem: before Java 8, adding a new method to an interface broke all existing implementing classes. With default methods, new methods can be added with a default implementation, maintaining backward compatibility. For example, the forEach() method was added to Iterable as a default method in Java 8 without breaking millions of existing implementations.

SA-4: Explain the concept of multiple inheritance through interfaces with an example.

Answer: Java doesn't allow a class to extend multiple classes (avoids diamond problem with state). However, a class CAN implement multiple interfaces, achieving multiple inheritance of behaviour. Example: class SmartPhone implements Callable, Browsable, Photographable. SmartPhone inherits the contracts of all three interfaces and provides implementations for each. This is safe because interfaces (traditionally) don't carry state — just method contracts.

SA-5: What is a functional interface? Name three built-in functional interfaces.

Answer: A functional interface is an interface with exactly one abstract method (SAM — Single Abstract Method). It can have multiple default/static methods. The @FunctionalInterface annotation is optional but recommended. Three built-in functional interfaces: (1) Predicate<T> — boolean test(T t), (2) Function<T,R> — R apply(T t), (3) Consumer<T> — void accept(T t). Functional interfaces are the basis for lambda expressions.

SA-6: What is the Interface Segregation Principle?

Answer: The Interface Segregation Principle (ISP) is one of the SOLID principles. It states: "No client should be forced to depend on methods it does not use." Instead of one large, general-purpose interface, create multiple small, specific interfaces. Example: Instead of interface Machine { void print(); void scan(); void fax(); }, create interface Printable, interface Scannable, interface Faxable. A simple printer implements only Printable, not unused methods.

SA-7: Differentiate between Comparable and Comparator.

Answer: Comparable<T> defines natural ordering inside the class itself — the class implements compareTo(T o) returning an int. Only one ordering possible. Comparator<T> defines external custom ordering — a separate class/lambda implements compare(T a, T b). Multiple orderings possible. Use Comparable for the default sort (e.g., Students by roll number), Comparator for alternate sorts (by name, by CGPA).

SA-8: What are marker interfaces? How do they differ from annotations?

Answer: Marker interfaces are interfaces with zero methods that "tag" a class with a capability. Examples: Serializable, Cloneable, Remote. The JVM/framework checks instanceof to grant special treatment. Since Java 5, annotations (e.g., @Entity, @Deprecated) serve a similar purpose but are more flexible — they can carry metadata (key-value pairs). Marker interfaces define a type (can be used in polymorphism), while annotations are metadata only. Both are valid; modern Java prefers annotations for new designs.

Long Answer Questions (3)

LA-1: Explain abstract classes and interfaces in detail. Compare them across 10 parameters with examples. When should you use each?

Answer:

Abstract Class: An abstract class is a class declared with the abstract keyword. It cannot be instantiated directly. It may contain: abstract methods (no body — subclasses must implement), concrete methods (with body — shared by all subclasses), instance variables (any access modifier), constructors (called during subclass initialization), and static methods.

Interface: An interface is a reference type defined with the interface keyword. It specifies a contract that implementing classes must follow. Since Java 8: abstract methods, default methods (with body), static methods. Since Java 9: private methods. Variables are implicitly public static final. No constructors. Supports multiple inheritance.

When to use Abstract Class: When classes share an IS-A relationship with common state and behaviour. Example: abstract class BankAccount → SavingsAccount, CurrentAccount share accountNumber, balance, deposit(), withdraw().

When to use Interface: When defining a CAN-DO capability across unrelated classes. Example: interface Printable → both a Document and a Photo can be printable, but they're not related by inheritance.

LA-2: Explain functional interfaces, lambda expressions, and their connection. Write a program demonstrating a custom functional interface with lambda usage.

Answer:

A functional interface is an interface with exactly one abstract method (SAM). The @FunctionalInterface annotation ensures the compiler enforces this constraint. Functional interfaces are the target types for lambda expressions — concise anonymous function syntax introduced in Java 8.

Lambda expressions provide a shorthand for implementing functional interfaces. Instead of writing a full anonymous class with boilerplate code, you write: (parameters) -> expression or (parameters) -> { statements; }.

Connection: Lambda expressions ONLY work with functional interfaces. When the compiler sees a lambda, it looks at the target type (which must be a functional interface) and maps the lambda to the single abstract method.

Java
@FunctionalInterface
interface StringProcessor {
    String process(String input);
}

public class FunctionalDemo {
    static String applyProcessor(String text, StringProcessor sp) {
        return sp.process(text);
    }

    public static void main(String[] args) {
        StringProcessor toUpper   = s -> s.toUpperCase();
        StringProcessor addPrefix = s -> "[LOG] " + s;
        StringProcessor reverse   = s -> new StringBuilder(s).reverse().toString();

        System.out.println(applyProcessor("hello java", toUpper));    // HELLO JAVA
        System.out.println(applyProcessor("server started", addPrefix)); // [LOG] server started
        System.out.println(applyProcessor("interface", reverse));      // ecafretni
    }
}

LA-3: Design and implement a complete system using both abstract classes and interfaces. Explain your design choices.

Answer — E-Commerce Order Processing System:

The system processes orders from different channels (online, in-store, wholesale) with different payment methods and shipping options. Here's the design rationale:

• abstract class Order — shared state (orderId, items, totalAmount) and common behaviour (addItem, calculateTotal) → IS-A relationship
• interface Payable — payment contract for any payment method → CAN-DO capability
• interface Shippable — shipping contract for deliverable orders → CAN-DO capability
• interface Returnable — return/refund contract → not all orders are returnable

Java
abstract class Order {
    String orderId;
    double totalAmount;

    public Order(String orderId, double totalAmount) {
        this.orderId = orderId;
        this.totalAmount = totalAmount;
    }
    abstract String getOrderType();
    void printSummary() {
        System.out.println(getOrderType() + " | ID: " + orderId + " | ₹" + totalAmount);
    }
}

interface Shippable  { double calculateShipping(); String getTrackingId(); }
interface Returnable { boolean initiateReturn(String reason); }

class OnlineOrder extends Order implements Shippable, Returnable {
    public OnlineOrder(String id, double amt) { super(id, amt); }
    @Override String getOrderType()        { return "ONLINE"; }
    @Override public double calculateShipping() { return totalAmount > 499 ? 0 : 49; }
    @Override public String getTrackingId()     { return "TRK-" + orderId; }
    @Override public boolean initiateReturn(String r) { return true; }
}

class InStoreOrder extends Order {
    public InStoreOrder(String id, double amt) { super(id, amt); }
    @Override String getOrderType() { return "IN-STORE"; }
    // No shipping, no returns — ISP at work!
}

Design Choice: Order is abstract because all orders share state (orderId, totalAmount). Shippable and Returnable are interfaces because not all orders need them (in-store orders don't ship). This follows Interface Segregation — each class only implements what it needs.

Lab Program 9 — Abstract and Nested Classes

Java
abstract class Shape {
    protected String name;
    protected String color;

    // Constructor
    public Shape(String name, String color) {
        this.name = name;
        this.color = color;
    }

    // Abstract methods — subclasses MUST implement
    public abstract double area();
    public abstract double perimeter();

    // Concrete method — shared by all shapes
    public void display() {
        System.out.println("┌─────────────────────────────────┐");
        System.out.println("│ Shape: " + name);
        System.out.println("│ Color: " + color);
        System.out.println("│ Area: " + ShapeHelper.format(area()));
        System.out.println("│ Perimeter: " + ShapeHelper.format(perimeter()));
        System.out.println("└─────────────────────────────────┘");
    }

    // ═══ Static Nested Class — ShapeHelper ═══
    static class ShapeHelper {
        // Format a double to 2 decimal places
        public static String format(double value) {
            return String.format("%.2f", value);
        }

        // Compare two shapes by area
        public static Shape largerByArea(Shape s1, Shape s2) {
            return s1.area() >= s2.area() ? s1 : s2;
        }

        // Check if a shape is "large" (area > 100)
        public static boolean isLarge(Shape s) {
            return s.area() > 100;
        }

        // Print summary of multiple shapes
        public static void printSummary(Shape[] shapes) {
            double totalArea = 0;
            for (Shape s : shapes) {
                totalArea += s.area();
            }
            System.out.println("\n📊 Summary: " + shapes.length + " shapes");
            System.out.println("Total Area: " + format(totalArea));
        }
    }
}

// ═══ Circle — extends Shape ═══
class Circle extends Shape {
    private double radius;

    public Circle(double radius, String color) {
        super("Circle", color);
        this.radius = radius;
    }

    @Override
    public double area() {
        return Math.PI * radius * radius;
    }

    @Override
    public double perimeter() {
        return 2 * Math.PI * radius;
    }
}

// ═══ Rectangle — extends Shape ═══
class Rectangle extends Shape {
    private double length, width;

    public Rectangle(double length, double width, String color) {
        super("Rectangle", color);
        this.length = length;
        this.width = width;
    }

    @Override
    public double area() {
        return length * width;
    }

    @Override
    public double perimeter() {
        return 2 * (length + width);
    }
}

// ═══ Driver ═══
public class Lab9ShapeDemo {
    public static void main(String[] args) {
        Circle c1 = new Circle(7, "Red");
        Circle c2 = new Circle(3.5, "Green");
        Rectangle r1 = new Rectangle(12, 8, "Blue");
        Rectangle r2 = new Rectangle(5, 5, "Yellow");

        // Display each shape
        Shape[] shapes = {c1, c2, r1, r2};
        for (Shape s : shapes) {
            s.display();
        }

        // Use static nested class helper methods
        Shape larger = Shape.ShapeHelper.largerByArea(c1, r1);
        System.out.println("Larger shape: " + larger.name +
            " (Area: " + Shape.ShapeHelper.format(larger.area()) + ")");

        System.out.println("Is Circle(7) large? " + Shape.ShapeHelper.isLarge(c1));
        System.out.println("Is Rectangle(5x5) large? " + Shape.ShapeHelper.isLarge(r2));

        Shape.ShapeHelper.printSummary(shapes);
    }
}

Industry Spotlight — A Day in the Life

Earn With It — API Contract Design

Chapter Summary & Code Tweet

🐦 Code Tweet (Under 280 Characters)

Earning Checkpoint — What You've Built

✅ Unit 9 complete. MCQs: 30. Lab 9 covered. Ready for Unit 10!

[QR: Link to EduArtha video tutorial — Abstract Class & Interface]