The syntax of your code snippets is Java, but this answer is from the perspective of C++ as that's what most game engines are written in.
Usability. Message objects are flexible and easy to debug. Since message objects names are known at runtime, you can easily print them, assert on them, etc. without having to write any reflection or other systems. In languages with built in reflection (C#, Java), this is less of a benefit.
Speed. Doing a string-compare for every message * every recipient sent is significantly slower than the alternatives.
Numbered Message Types
Speed! Numbered message types (plus sensible message handling with switch statements) means that messages can be quickly discarded.
Usability. If you define all your message-numbers in one file, that file is going to be referenced everywhere and modified constantly (by every member of the team) leading to frequent conflicts in merging. Additionally, at debugging-time, it may not be immediately obvious what each message is when you see them pass by.
I'm not really sure how you'd implement this in Java, but my preferred means of doing events is by attaching a delegate to a given message name (or type). The front-end code would look something like this:
class SomeClass : Component
void onSomeEvent(const SomeEvent &args);
And in SomeClass.cpp
void SomeClass::onSomeEvent(const SomeEvent &args)
// resolve the event here
Usability AND speed. Events can be created for free, without editing any extra files, events can be handled each in their own function rather without the need for a HandleEvent() function on every class, and (if it's set up correctly), it is every bit as fast as using integers for events.
Complicated to write in the first place. The back-end implementation is a bit tricky. ConnectEvent, in the above example, is actually a macro that expands to a template to construct the delegate. Furthermore, the event-listening system in the middle needs to be able to handle objects being after registering for events without segfaulting, and other hairy considerations.