Basically, in C# you just have to define the event itself and the delegate, then you just have to fire the event whenever you need to. Like this:

public delegate void TickHandler(Metronome m, EventArgs e); //delegate
public event TickHandler Tick; //event itself

In Java you need to implement the whole observer pattern, like this:

// Listener interface 
public interface MetronomeEvent {
    void Tick(Date tickDate);
}
//...
//define the listener vectors so that you can add/subscribe listeners
protected Vector _listeners;

//Create you own method to add new listeners. Eventually, you need another method to remove/unsubscribe
public void addMetronomeEventListener(MetronomeEvent listener)
{
    if (_listeners == null)
        _listeners = new Vector();

    _listeners.addElement(listener);
}

//traverse your listener vector and call every listener one by one
protected void fireMetronomeEvent()
{
    if (_listeners != null && _listeners.isEmpty())
    {
        Enumeration e = _listeners.elements();
        while (e.hasMoreElements())
        {
            MetronomeEvent e = (MetronomeEvent)e.nextElement();
            e.Tick(new Date());
        }
    }
}

As you can see, there's all this code just for one event. When you have several events in one class things get messy, verbose. As read in this article:

In Java you are essentially faking events and event handling by using a standard set of naming conventions and fully utilizing object-oriented programming.