The main promise of Julia’s multiple dispatch is that it allows the obvious code to do the right thing and dispatch to fast specialised methods for a large variety of types, which tends to make programs more composable.
Another way to look at it is that the language is designed to be able to express a full numeric tower, i.e. different int and float types, complex and arbitrary precision numbers, suitable upcasting when types don’t match. One desirable property is that a + b should generally end up calling the same function as b + a. Try to think about how you would do this with Java-style overloading, even if the overloading was more dynamic and looked at the runtime type and all methods up the class’ ancestors. And how would you extend this to add a new numeric type (say dual numbers.) IIRC, the Julia strategy mostly uses some type-level programming to figure out a suitable shared type for a and b (which basically only runs at JIT-compilation-time), then coerces them both to that type, then adds them.
Scheme and Common Lisp manage to pricide quite big complicated numeric towers but they are basically entirely impossible to extend with custom types.
Julia shows this tradeoff isn't necessary.
If you want that in the JVM, you can use Groovy, which does just that.
class Fire{}
class Water {}
class Grass {}
class Ice {}
def eff(Fire f, Grass g) { 'burn' }
def eff(Fire f, Ice ice) { 'melt' }
def eff(Water w, Grass g) { 'grow' }
def eff(Water w, Ice ice) { 'freeze' }
def eff(a, b) { 'undefined' }
println eff(new Fire(), new Grass())
println eff(new Fire(), new Ice())
println eff(new Water(), new Grass())
println eff(new Water(), new Ice())
println eff(new Ice(), new Water())
Prints:burn melt grow freeze undefined
EDIT: to make it even more obvious there's no difference:
class Fire{}
class Water {}
class Grass {}
class Ice {}
def eff(Fire f, Grass g) { 'burn' }
def eff(Fire f, Ice ice) { 'melt' }
def eff(Water w, Grass g) { 'grow' }
def eff(Water w, Ice ice) { 'freeze' }
def eff(a, b) { 'undefined' }
// hide compile-time types
Object fire = new Fire()
Object grass = new Grass()
Object ice = new Ice()
Object water = new Water()
println eff(fire, grass)
println eff(fire, ice)
println eff(water, grass)
println eff(water, ice)
println eff(ice, water)
Prints: burn
melt
grow
freeze
undefined
After reading this post and this stackexchange link[0], I'm not sure it is that complicated. The behaviour in the post can be explained as Julia picking the most specific function that fits based on the runtime type (i.e. uncovering the underlying concrete type at runtime and checking for an implementation). In fact the stackexchange answer mentions that dynamic languages don't differentiate between overloading and multiple dispatch at all, since everything is resolved at runtime. So, overloading and multiple dispatch seem more like that same concept but are one is eagerly resolved while the other is lazily resolved.
[0] https://softwareengineering.stackexchange.com/a/125088