It is a pattern that can be applied to any language, provided that the language was written with an environment that permits reassigning names associated with blocks of code.
In the computer, code and data exists in memory. In programming languages, we use names to refer to those "chunks" of memory.
int a = 0;
would "name" some number of bytes of memory "a". It would also "assign" that memory the byte value corresponding to 0. Depending on the type system,
int add(int first, int second) {
return first + second;
}
would "name" some number of bytes of memory "add". It would also "assign" that memory to contain the machine instructions to look into the call stack for two "int" numbers, add them together, and put the result in the appropriate place on the call stack.
In a type system that separates (and maintains) names to blocks of code, the end result is that you can easily pass blocks of code around by reference much in the same way you can variable memory around by reference. The key is to make sure the type system "matches" only compatible types, otherwise passing around the blocks of code might induce errors (like returning a long when originally defined to return an int).
In Java, all types resolve to a "signature" which is a string representation of the method name and "type". Looking at the add example provided, the signature is
// This has a signature of "add(I,I)I"
int add(int first, int second) {
return first + second;
}
If Java supported (as Clojure does) method name assignment, it would have to expand on its declared type system rules, and allow method name assignment. A fake example of method assignment would logically look like
subtract = add;
but this would require the need to declare subtract, with a strongly typed (to match Java) "type".
public subtract(I,I)I;
And without some care, such declarations can easily tread upon already-defined parts of the language.
But to get back to your answer, in languages that support such, the names basically are pointers to blocks of code, and can be reassigned provided you don't break the expectations of input and return parameters.
