16.2. AWT (Abstract Window Toolkit)

• Part of Java's original GUI toolkit (java.awt). • Uses native platform components (heavyweight).

AWT stands for Abstract Window Toolkit, and it is the original graphical user interface kit provided by Java. It is part of the package named java.awt. One important characteristic of AWT is that it utilizes native components from the operating system, which means it relies on the platform's native look and feel. This is referred to as being 'heavyweight'. Heavyweight components are those that directly make use of the system's graphics capabilities, but this can lead to inconsistencies in appearance across different platforms.

Imagine building a house using materials sourced from the local hardware store. The quality and look of your house will depend heavily on vendors available in that particular region. Similarly, when using AWT, the appearance and behavior of the application will depend on the underlying operating systems.

• AWT follows a component hierarchy:

• Object
• Component
• Container
  • Window
    • Frame
    • Dialog
  • Panel

In AWT, components are organized in a hierarchical structure. At the top of the hierarchy is the 'Object' class, from which all classes derive. Under this, we have 'Component', which is the base class for all user interface components. Components can be further categorized as 'Container' or 'Window'. A 'Container' can hold other components. It has two primary types: 'Window', which encompasses 'Frame' and 'Dialog'. The 'Panel' is another type of container but is usually used to group components within a window.

Think of the AWT hierarchy as a family tree. At the top, you have the great-grandparents (Object) who give rise to grandparents (Component). The parents (Container) then give birth to children (Window, Frame, and Dialog). Just like how family members can gather in a home, components can be brought together in containers to form a GUI.

• Button java.awt.Button • Label java.awt.Label • TextField java.awt.TextField • TextArea java.awt.TextArea • Checkbox java.awt.Checkbox • Choice (dropdown) java.awt.Choice • List java.awt.List

AWT provides a variety of components that developers can use to create interactive applications. Each component serves a specific purpose. For example, a 'Button' (java.awt.Button) is an element that users can click on to perform an action. A 'Label' (java.awt.Label) is used to display text on the screen. The 'TextField' (java.awt.TextField) allows users to enter single-line text, while 'TextArea' (java.awt.TextArea) is for multi-line text. 'Checkbox' (java.awt.Checkbox) offers a way for users to make a binary choice, 'Choice' (java.awt.Choice) is used for dropdown selections, and 'List' (java.awt.List) enables the display of a list of items where users can make selections.

Consider AWT components like various tools in a toolbox. The 'Button' is like a hammer you use to drive in nails (perform an action). The 'Label' is the instructional sticker on a toolbox that tells you what each tool does. 'TextField' is akin to a measuring tape that can be pulled out to input a specific measurement. Just as every tool has a purpose, so does each AWT component in building a user interface.

• FlowLayout • BorderLayout • GridLayout • CardLayout

Layout managers in AWT handle the arrangement of components within a container. Four common types of layout managers include:

1. FlowLayout: This arranges components in a left-to-right flow, similar to lines of text in a paragraph. When the container's width is filled, components wrap to the next line.
2. BorderLayout: This divides the container into five regions: North, South, East, West, and Center, allowing you to place components in specific areas.
3. GridLayout: This organizes components in a rectangular grid with equal-sized cells, each containing one component.
4. CardLayout: This enables switching between different sets of components (like flipping through cards), making it useful when you want to show one panel at a time.

You can think of layout managers as the design of a room. FlowLayout is like arranging furniture in a way that it follows a natural flow from one piece to another without tight constraints. BorderLayout is like zoning a room into specific areas for various activities. GridLayout is akin to a chessboard where every square has an equal share of space, and CardLayout is like a filing cabinet where you can flip through tabs to find a particular document quickly.

• Based on Delegation Event Model. • Components generate events. • Listeners handle them.

AWT implements a framework for event handling called the Delegation Event Model. In this model, components (like buttons) can generate events (like clicks). However, instead of the components managing the events directly, they delegate this responsibility to event listeners. Developers implement listeners that define how an application should respond to specific events. For example, when a button is clicked, an event is generated, and an associated listener will handle that event and execute the defined action. This separation keeps code organized and enhances reusability.

Think of the Delegation Event Model like a restaurant. A customer (the component) places an order (event), but instead of preparing the meal themselves, they hand it off to a waiter (the listener). The waiter takes the order to the kitchen (the event-handling logic) and brings back the completed meal. This way, the customer doesn’t need to juggle cooking while attending to their dining experience.

--