Replicating C#-style events in Java using reflection
ArrayList&lt;Method&gt; Methods;
    ArrayList&lt;Object&gt; DeclaringClasses;


Two things: firstly, you're using C# naming conventions rather than Java. Secondly, code to the interface: the fields should be List&lt;XYZ&gt; rather than ArrayList&lt;XYZ&gt;.

    public boolean AddListener(Object Class, String MethodName)


Class isn't an obvious name for something which isn't a class. And given that you're using java.lang.Class inside the method without fully qualifying the name, it has even more potential to confuse.

            Method MTR = Class.getClass().getMethod(MethodName, Object.class, Object.class); // MTR = Method To Register.


If you have to add a comment explaining the name, perhaps you chose the wrong name? What's wrong with Method method = ...?

            if(Methods.contains(MTR))
                return false;


So I can't have the event notify two different objects of the same class?

    public boolean RemoveListener(Object Class, String MethodName)
    {
        try
        { 
            DeclaringClasses.remove(Class);
            return Methods.remove(Class.getClass().getMethod(MethodName, Object.class, Object.class)); 
        }


Buggy. Collection.remove removes one instance of the object, but you're making no attempt to ensure it's the right one. If I register two methods on the same object, this could remove the wrong instance of the object, which would then make objects and methods not line up correctly.

In fact, it's even worse than that: if I register a method on one object and then remove it on another, or register one method on an object and then remove a different one, I'll end up with Methods and DeclaringClasses not even being the same size.

Also, why would you want to call getMethod again unless the method hasn't been registered? If the method has been registered, you've already resolved it; if it hasn't, you don't need to resolve it except to check for typos.

The best way to store the resolved methods is probably Map&lt;Tuple&lt;Object, String&gt;, Method&gt;: that allows you to iterate through the entry set in the Raise method and to efficiently implement RemoveListener.

            catch(IllegalAccessException error)
            { }


No. Swallowing exceptions like that is bad, especially when you've done nothing to prevent them occurring. You should check in AddListener whether the method is accessible, and throw an exception there if it isn't. Then here you should log an error for debugging purposes.

Other issues to consider:


Thread-safety. This has no thread-safety whatsoever.
Typing. If you're going to emulate C#'s events then don't just emulate the ungenericised EventHandler. At the very least, emulate EventHandler&lt;T&gt;. Because Java's generics aren't reified this requires a bit of boilerplate:

public class Event&lt;T&gt;
{
    private final Class&lt;T&gt; typeParam;

    public Event(Class&lt;T&gt; typeParam)
    {
        this.typeParam = typeParam;
    }


You can now use typeParam in the Class.getMethod call.