Building Swing Components

Suppose you build a window with several buttons and labels. Somebody has to decide where each piece sits, how far apart they are, and what happens when the window is stretched or shrunk. In Java, that decision is not hard-coded into each component. Instead, a container hands the job to a separate object that knows how to arrange whatever it is given. Understanding that handoff is the first step toward building graphical interfaces that look deliberate rather than accidental.

This article follows one question from start to finish: when you place several components into a container, what actually determines where each one ends up? You will meet the object responsible for that answer, watch it work through a concrete case, and then test your own reasoning on a small example.

The important idea is that the arrangement rule is an object you choose, separate from the components themselves. A button does not know whether it belongs in a row or a grid; the container's layout manager makes that call. Java provides a variety of standard layout managers for this purpose. This article looks at three of them: FlowLayout, BorderLayout, and GridLayout. Only FlowLayout is explained in detail here, and BorderLayout and GridLayout are named so you can recognize them when you meet them later.

Read the diagram as a relationship, not a sequence. The container owns the components and also points to one layout manager. Changing the layout manager changes the arrangement rule without touching the components it arranges. The components are the things being placed; the layout manager is the object that decides the placement.

The word to notice is passed. You do not write a layout manager into the component, and you do not ask the button where it should go. You create a layout manager object and hand it to the container through setLayout(). From then on, the container consults that object whenever it needs to position the components it holds. Layout managers are classes in the java.awt package, so the names you will meet are the standard ones that Java supplies.

FlowLayout is the simplest of the three layout managers covered here. Its rule can be stated in a few words: it lines components up in a row across the container. Each component is drawn at its preferred size, which is the size that component itself reports as ideal. The layout manager does not stretch components to fill space, and it does not decide sizes on its own.

The before and after views show the effect of narrowing the container. In the wide container, all five buttons fit on one row. In the narrow container, A, B, and C still fit on the first row, but D does not, so D starts a second row and E follows it there. Only the placement of D and E changed. Their size did not, and neither did the order of the buttons. The narrower width simply forced a row break earlier in the sequence.

You do not always have to choose a layout manager. A JPanel uses a FlowLayout by default. Unless you specify something else by calling the panel's setLayout() method, the panel will arrange its components in rows using the FlowLayout rule described above.