Alright, fellow coder, let’s talk about double dispatch — a concept that sounds way fancier than it is. But trust me, once you get the hang of it, you’ll realize it’s just a neat trick for handling objects of two different types. And here’s the kicker: double dispatch is actually a form of multiple dispatch, which sounds way cooler than it is. But don’t worry, I’ll break it down nice and simple for you!

What is Runtime Dispatch?
In object-oriented programming, dispatch is the process of figuring out which method to call when we run a program. Imagine you have a method called makeSound() in different animal classes, like Dog and Cat. When you call makeSound() on an animal object, dispatching decides whether you get a “bark” or a “meow” at runtime, depending on whether the object is a Dog or a Cat.

Runtime dispatch specifically means that this decision-making happens while the program is running, as opposed to compile-time dispatch (when the compiler decides during code compilation). Most object-oriented languages support single dispatch (aka Method Overriding), but others like Julia take it even further with multiple dispatch. One thing to note is dispatch is not just about runtime. Some dispatches happen in compile time like method overloading. What we are going to discuss is something that happens at runtime.

How Does Double Dispatch Work?
Double dispatch is like a two-step dance. Here’s how it goes: the method gets called based on the type of the first object, and then inside that method, another method gets called based on the second object. So, two objects, two dispatches.

Let’s imagine you’re writing a program where you have shapes (like Circle and Square) and colors (like Red and Blue). You want to apply a color to a shape, but the behavior should depend on both the shape and the color. That's where double dispatch comes in!

Code Example in Java
Let me show you how this works with some Java code:

class Circle {
    public void changeColor(Color color) {
        color.applyToCircle(this);
    }
}

class Square {
    public void changeColor(Color color) {
        color.applyToSquare(this);
    }
}

interface Color {
    void applyToCircle(Circle circle);
    void applyToSquare(Square square);
}

class Red implements Color {
    public void applyToCircle(Circle circle) {
        System.out.println("Coloring circle red");
    }

    public void applyToSquare(Square square) {
        System.out.println("Coloring square red");
    }
}

class Blue implements Color {
    public void applyToCircle(Circle circle) {
        System.out.println("Coloring circle blue");
    }

    public void applyToSquare(Square square) {
        System.out.println("Coloring square blue");
    }
}

public class Main {
    public static void main(String[] args) {
        Circle circle = new Circle();
        Square square = new Square();
        Red red = new Red();
        Blue blue = new Blue();

        // First dispatch: the object calling the method
        circle.changeColor(red);   // Output: Coloring circle red
        square.changeColor(blue);  // Output: Coloring square blue
    }
}

What’s Going On Here?

First dispatch: When you call circle.changeColor(red), Java looks at the type of circle (which is a Circle) and calls the changeColor method on it. That’s your first dispatch.
Second dispatch: Inside the changeColor method, we call the applyToCircle method on the red object. That’s the second dispatch, and it’s determined by the type of red.
Why Is Double Dispatch Useful?
So why should you care about this double dispatch thing? Well, it’s super helpful when you need to make decisions based on the types of both objects involved in an operation. And guess what? You don’t have to change any of your existing classes if you want to add more shapes or more colors. You just add more methods to handle new combinations! Double dispatch is also useful if you want to understand and apply design patterns like the Visitor design pattern.

In simpler terms, double dispatch lets you do cool stuff without messing up your existing code. It’s like adding new toppings to your pizza without throwing away the crust.

Double dispatch is all about making method calls that depend on two different object types, and it’s super useful for scenarios where objects need to interact in different ways. The fun part is that it’s not limited to just one object — both are involved in the decision-making process. This makes double dispatch a great tool for flexible and extensible systems.

Now, go out there and start using double dispatch to make your code even more powerful. Happy coding! 😎