Java equivalent of C# Delegates (queues methods of various classes to be executed)

Actually there is no exact counterpart for delegates in Java. But there are constructs that mimic their behavior.

Java 8

Functional interfaces

The concept that comes closes to delegates in Java 8 is that of functional interfaces.

For example, if you have a C# delegate:

delegate void Runnable();

in Java, you would create a functional interface like:

@FunctionalInterface
public interface Runnable {
    void run();
}

The nice thing about functional interfaces is they can be used easily in lambda expressions.

Example

So, let's suppose you have the following class:

public class SomeClass {
    public static void someStaticMethod() {
    }

    public void someMethod() {
    }
}

Lambda expressions and method references

With Java 8, you get lambda expressions.

List<Runnable> queue = new ArrayList<>();
queue.add(() -> someMethod());
queue.add(() -> someStaticMethod());

There is a short-hand named method reference for this, if you actually simply call a method:

List<Runnable> queue = new ArrayList<>();
queue.add(this::someMethod);
queue.add(SomeClass::someStaticMethod);

Java 7

With Java 7, the only thing you can use is anonymous classes:

List<Runnable> queue = new ArrayList<>();
queue.add(new Runnable() {
    public void run() {
        someMethod();
    }
});
queue.add(new Runnable() {
    public void run() {
        someStaticMethod();
    }
});

I hope this was not too much information, so you can still learn. ;-) However, I like my answer to be useful also for other people looking up this question.

Extracted from https://msdn.microsoft.com/en-gb/library/aa288459(v=vs.71).aspx :

A delegate in C# is similar to a function pointer in C or C++. Using a delegate allows the programmer to encapsulate a reference to a method inside a delegate object. The delegate object can then be passed to code which can call the referenced method, without having to know at compile time which method will be invoked. Unlike function pointers in C or C++, delegates are object-oriented, type-safe, and secure.

That said, Java does not have delegates like C#. However, since Java 8, we do have some sort of function pointers by using method references and functional interfaces.

As you politely requested, I am not going to tell you exactly how to implement this code, but you should be able to come up with a solution with this information.