Understanding Java Callback Mechanism Through a Classroom Analogy

The author introduces the Java callback mechanism, noting that beginners often find it confusing and that many online explanations are either too brief or overly simplistic. To make the concept clearer, a progressive story set in a kindergarten is used.

Chapter 1 – The Origin Story : A teacher writes "1 + 1 = " on the board and asks a student (Xiaoming) to fill the blank. Xiaoming computes the result himself. The corresponding Student class and a test program are shown, illustrating a direct method call without any callback.

public class Student {
    private String name = null;
    public Student(String name) { this.name = name; }
    public void setName(String name) { this.name = name; }
    private int calcADD(int a, int b) { return a + b; }
    public void fillBlank(int a, int b) {
        int result = calcADD(a, b);
        System.out.println(name + "心算:" + a + " + " + b + " = " + result);
    }
}

public class Test {
    public static void main(String[] args) {
        int a = 1, b = 1;
        Student s = new Student("小明");
        s.fillBlank(a, b);
    }
}

The output confirms that the whole process is performed by the Student instance, with no callback involved.

Chapter 2 – The Teacher’s Trick : The teacher now asks a harder question "168 + 291 = ". Xiaoming receives a simple calculator from a classmate (Xiaohong). A Calculator class with an add method is introduced, and Student is modified to use this calculator via a private useCalculator method.

public class Calculator {
    public int add(int a, int b) { return a + b; }
}

public class Student {
    // ... previous members ...
    private int useCalculator(int a, int b) {
        return new Calculator().add(a, b);
    }
    public void fillBlank(int a, int b) {
        int result = useCalculator(a, b);
        System.out.println(name + "使用计算器:" + a + " + " + b + " = " + result);
    }
}

The test program now prints the result obtained through the calculator, still without a callback.

Chapter 3 – The Super Calculator (Callback Appears) : To handle even larger numbers, a SuperCalculator is created. Its add method receives the two operands and a reference to the Student object. After computing the sum, it calls back the student's fillBlank method to display the result.

public class SuperCalculator {
    public void add(int a, int b, Student xiaoming) {
        int result = a + b;
        xiaoming.fillBlank(a, b, result);
    }
}

public class Student {
    // ... previous members ...
    public void callHelp(int a, int b) {
        new SuperCalculator().add(a, b, this);
    }
    public void fillBlank(int a, int b, int result) {
        System.out.println(name + "求助小红计算:" + a + " + " + b + " = " + result);
    }
}

The test shows Xiaoming delegating the addition to the super calculator, which then invokes the callback to fill the blank.

Chapter 4 – Generalising with an Interface : To support different kinds of customers (students, sellers, etc.), an interface doJob with a fillBlank method is defined. SuperCalculator now accepts any doJob implementation. Both Student and a new Seller class provide inner classes that implement doJob , allowing the same calculator to serve multiple roles.

public interface doJob {
    void fillBlank(int a, int b, int result);
}

public class SuperCalculator {
    public void add(int a, int b, doJob customer) {
        int result = a + b;
        customer.fillBlank(a, b, result);
    }
}

// Student implementation
public class Student {
    // ... fields and constructors ...
    public void callHelp(int a, int b) {
        new SuperCalculator().add(a, b, new doHomeWork());
    }
    class doHomeWork implements doJob {
        public void fillBlank(int a, int b, int result) {
            System.out.println(name + "求助小红计算:" + a + " + " + b + " = " + result);
        }
    }
}

// Seller implementation
public class Seller {
    // ... fields and constructors ...
    public void callHelp(int a, int b) {
        new SuperCalculator().add(a, b, new doHomeWork());
    }
    class doHomeWork implements doJob {
        public void fillBlank(int a, int b, int result) {
            System.out.println(name + "求助小红算账:" + a + " + " + b + " = " + result + "元");
        }
    }
}

A final test creates a Student and a Seller , each invoking callHelp . The output demonstrates that both parties receive their respective formatted results, confirming that the callback mechanism works uniformly across different client types.

Conclusion : By gradually extending the example—from direct computation to interface‑based callbacks—the article makes the abstract concept of Java callbacks concrete and shows how they enable asynchronous or delegated processing while keeping the caller’s logic separate.