Java Events: is there a direct Java analogue to Qt's signals/slots & C#'s delegate?

[Michael J. Williams]

I am a Java newbie, but actively learning the language. Does Java provide a simple syntax that allows the developer to define, subscribe to, raise/activate, then receive notification of events that are coordinated entirely within his/her use of native Java syntax? (As a newbie) I am studying (staring at) lambda and anonymous inner class examples, but I haven't, yet, come even close to understanding how to use them for general-purpose, event-driven logic in Java, if possible. My Qt/C++ and C# experience has enjoyed lots of success with Qt's signals/slots feature and C#'s delegate feature.

If you know of any very simple examples of this type of general-purpose event support, within native Java syntax, please provide links, or code examples. I appreciate your time and consideration! Best wishes!

Here is a simplistic example of my use of C#'s delegate feature for general application event processing :

//
// C#, delegateExample.cs - simple event processing example
//

using System;
using System.Threading;

namespace csDelegateExample
{
    public class	Widget
					{	public string wSerialNum { get; set; }	}

    public class	WidgetEventArgs : EventArgs
					{	public Widget Widget { get; set; }	}

    public class 	MachineShop
    {
		//	define event and subscription mechanism
		public event EventHandler<WidgetEventArgs> ehSubscribers;
        
		// fabricate and test a new widget, then notify subscribers of completion
        public void StampAndTestNewWidget( Widget inWidget)
        {
            Console.WriteLine( "building widget ..." );		
            Thread.Sleep( 2500 );							// perform our task
            Console.WriteLine( "widget completed ..." );
            
			// notify any event "subscribers" that this widget build has completed 
            if ( ehSubscribers == null )
				Console.WriteLine( "no subscribers to notify ..." );
			else
			{
				Console.WriteLine( "notifying subscriber(s) ..." );
				ehSubscribers(this, new WidgetEventArgs() { Widget = inWidget } );
			}
        }
    }
    
    public class 	InventoryDept
    {	public void OnWidgetCompletion(object source, WidgetEventArgs e)
        {	Console.WriteLine( "preparing for serial # : " + e.Widget.wSerialNum ); }
    }

    public class 	MainLogic
    {	static void Main( string[] args)
        {
			var widget			= new Widget() 			{ wSerialNum = "7157" };
            var machineShop		= new MachineShop();	// event publisher
            var inventoryDept	= new InventoryDept();	// event subscriber;
            
			//	register a "completion event" subscriber
            machineShop.ehSubscribers += inventoryDept.OnWidgetCompletion;
            
            machineShop.StampAndTestNewWidget( widget);	//	create a new widget
            Console.ReadKey();
            return;
        }
    }
}

[Mike. J. Thompson]

I don't know C#, but from reading your example I assume EventHandlers is an in-built type provided by C# specifically for raising events?

If so then no, Java does not come with built in support like that. There are Observable/Observer interfaces that contain methods related to event handling, but you have to provide your own implementations and handle registration of event handlers yourself.

What's more it is not in my opinion a good idea to use those interfaces. They are not type safe because they pass events as Object. There was a nice discussion of why it was a poor attempt and why it is not a good idea to produce general purpose implementations of design patterns by Kevlin Henney. I forget the name of that book at the minute though.

In my current project I wrote my own version of Observer/Observable that are generic and type safe, and that provide pre and post event notifications too. There may well be a third party library out there that does something similar too (probably better than what I wrote).