Dfyjkt

I would like to know why defmulti & defmethod are used?
What are the advantages?
And how do you use it? Please explain what is happening in the code.

In "general terms" you would call it a if/else on steroids and in "impress me" style you would name it with "dynamic dispatch", "runtime polymorphism" etc.

Lets say you want to define a function "Add" which should work for various data types like in case of Int it should add the numbers, in case of strings it should concat the strings. Now it is very simple to implement it using if else, basically you check the type of arguments and if they are integers then add them, if they are strings then concat them else throw exception. But the problem with this is that in case you want to add support for new data type in your Add function you will need to modify the Add function, which may not be possible in cases where you don't control the source of Add such as the case it is defined in some library etc.
defmulti and defmethod allows you to solve this problem i.e adding a new case to existing function without modifying its code.

(defmulti add (fn [a b] [(type a) (type b)]))

add is the function name, the anonymous function is your if/else, basically this will be called on your add arguments and the return value of this function will be checked if there is any implementation. Now lets implement it for Integer.

(defmethod add [Integer Integer] ([a b] (+ a b)))

[Integer Integer] is sort switch case on the return value of the anonymous function we defined in defmulti and then the implementation.

Similarly we can do for strings

(defmethod add [String String] ([a b] (str a b)))

Calling it with integers
(add (int 1) (int 2))

Calling it with strings
(add "hello" "world")

Calling it with something that doesn't match our if/else i.e not implementation yet for a case will result in an exception

From what I've observed after reading the answer (and using the example provided above), the following is also helpful to understand:

when you execute the command:

(add (int 5) (int 2))

What happens is that the 'add defmulti' is executed thus producing a list:

[Integer Integer]

with that produced, it looks for any 'add defmethod' that is identified with above list i.e.:

(add [Integer Integer])

And passes on the arguments that it received.

Another way of defining the multi methods so as to make the passing of arguments clear is:

(defmulti add (fn [a b] [(type a) (type b)]))
(defmethod add [Integer Integer] [a b] (+ a b))
(defmethod add [String String] [a b] (str a b))

Then run the function as:

(add 12 73)

or

(add "thank" "you")

Multimethods helps to call the methods based on params passed. It can call the respective methods based on type of argument/or based on some properties of an argument.
Example 1 Based on type

test=> (defmulti multiply (fn [a b] [(type a) (type b)]))
#'test/multiply
test=> (defmethod multiply [Integer Integer] [a b] (* a b))
#object[clojure.lang.MultiFn 0x189f7b45 "clojure.lang.MultiFn@189f7b45"]
test=> (defmethod multiply [String String] [a b] (str a b))
#object[clojure.lang.MultiFn 0x189f7b45 "clojure.lang.MultiFn@189f7b45"]
test=> (multiply 10 10)
test=> (multiply (int 10) (int 10))
100
test=> (multiply "10" "10")
"1010"

Example 2 Based on property

test=> (defmulti mn (fn[a b] ( < a b ) ))
#'test/mn
test=> (defmethod mn true [a b] (+ a b) )
#object[clojure.lang.MultiFn 0x700f6a44 "clojure.lang.MultiFn@700f6a44"]
test=> (defmethod mn false [a b] (- a b) )
#object[clojure.lang.MultiFn 0x700f6a44 "clojure.lang.MultiFn@700f6a44"]
test=> (mn 1 2)
3
test=> (mn 2 1)
1
test=> (mn 1 1)
0