17.4. Event Handling Models

17.4.1 Polling Model Continuously checks if an event has occurred — inefficient and outdated in most applications.

The polling model is a technique used in event handling where the program repeatedly checks or 'polls' to see if any events have occurred. This means it is constantly running a check to see if something like a user action has taken place, rather than waiting for the event to happen. While this method is straightforward, it can be inefficient because it wastes resources by checking repeatedly, even when no events are present. Most modern applications have moved away from this method because there are better alternatives available.

Imagine a child repeatedly asking their parent if it's time for dinner. The child is busy and can’t do anything else during this time, and the parent is likely to get annoyed by the constant interruptions. Instead, it would be better if the child did something else and the parent called them when dinner was ready. This is similar to how better models work, waiting for an event to occur rather than just checking constantly.

17.4.2 Interrupt/Callback Model Uses callback functions that are triggered asynchronously. This is the most common model in modern applications.

The interrupt/callback model enhances efficiency by using callback functions, which are only executed when an event occurs. In this model, the program can continue executing other code and only reacts when an event happens, like a user clicking a button. Instead of a constant check, the program can be 'interrupted' or notified when something significant happens, making it a preferred choice for modern applications due to better resource management.

Consider a waiter in a restaurant who is busy serving other customers. Instead of hovering over a table to see if someone needs something, the customers can ring a bell when they want attention. This way, the waiter can serve other tables without wasting time and effort. The callback functions serve the same purpose by only triggering a response when necessary.

17.4.3 Delegation Event Model (Used in Java) • Separates event generation from event handling. • Components generate events, and listeners handle them via interfaces like ActionListener, KeyListener, etc.

The delegation event model differentiates the components that generate events from the ones that handle them. For instance, a button generates a 'click' event, which is then handled by a listener, such as an ActionListener. This approach promotes a cleaner, more organized structure by separating concerns; it allows for better management of events since different components can work independently before invoking the specific responses needed. By utilizing defined interfaces, developers can easily plug in different behaviors without altering the component that generates the events.

Imagine a concert where you have different bands performing. Each band is responsible for their performance (event generation), but the concert organizers manage everything like ticket sales, seating, and schedules (event handling). This separation allows one band to perform without interfering with others, and it keeps the concert running smoothly, much like how the delegation model keeps event handling organized and efficient in programming.

--