Before we go on to discussing individual Swing components, such as text fields and radio buttons, we briefly cover how to arrange these components inside a frame.
Of course, Java development environments have drag-and-drop GUI builders. Nevertheless, it is important to know exactly what goes on “under the hood” because even the best of these tools will usually require hand-tweaking.
1. Layout Managers
Let’s start by reviewing the program from Listing 10.4 that used buttons to change the background color of a frame.
The buttons are contained in a JPanet object and are managed by the flow layout manager, the default layout manager for a panel. Figure 11.4 shows what happens when you add more buttons to the panel. As you can see, a new row is started when there is no more room.
Moreover, the buttons stay centered in the panel, even when the user resizes the frame (see Figure 11.5).
In general, components are placed inside containers, and a layout manager determines the positions and sizes of components in a container.
Buttons, text fields, and other user interface elements extend the class Component. Components can be placed inside containers, such as panels. Containers can themselves be put inside other containers, so the class Container extends Component. Figure 11.6 shows the inheritance hierarchy for Component.
Each container has a default layout manager, but you can always set your own. For example, the statement
panet.setLayout(new GridLayout(4, 4));
uses the GridLayout class to lay out the components in four rows and four columns. When you add components to the container, the add method of the container passes the component and any placement directions to the layout manager.
2. Border Layout
The border layout manager is the default layout manager of the content pane of every JFrame. Unlike the flow layout manager, which completely controls the position of each component, the border layout manager lets you choose where you want to place each component. You can choose to place the component in the center, north, south, east, or west of the content pane (see Figure 11.7).
For example:
frame.add(component, BorderLayout.SOUTH);
The edge components are laid out first, and the remaining available space is occupied by the center. When the container is resized, the dimensions of the edge components are unchanged, but the center component changes its size. Add components by specifying a constant CENTER, NORTH, SOUTH, EAST, or WEST of the BorderLayout class. Not all of the positions need to be occupied. If you don’t supply any value, CENTER is assumed.
Unlike the flow layout, the border layout grows all components to fill the available space. (The flow layout leaves each component at its preferred size.) This is a problem when you add a button:
frame.add(yettowButton, BorderLayout.SOUTH); // don’t
Figure 11.8 shows what happens when you use the preceding code fragment. The button has grown to fill the entire southern region of the frame. And, if you were to add another button to the southern region, it would just displace the first button.
To solve this problem, use additional panels. For example, look at Figure 11.9. The three buttons at the bottom of the screen are all contained in a panel. The panel is put into the southern region of the content pane.
To achieve this configuration, first create a new JPanet object, then add the individual buttons to the panel. The default layout manager for a panel is a FtowLayout, which is a good choice for this situation. Add the individual buttons to the panel, using the add method you have seen before. The position and size of the buttons is under the control of the FtowLayout manager. This means the buttons stay centered within the panel and do not expand to fill the entire panel area. Finally, add the panel to the content pane of the frame.
var panel = new JPanet();
panet.add(yettowButton);
panet.add(btueButton);
panel.add(redButton);
frame.add(panel, BorderLayout.SOUTH);
The border layout expands the size of the panel to fill the entire southern region.
3. Grid Layout
The grid layout arranges all components in rows and columns like a spreadsheet. All components are given the same size. The calculator program in Figure 11.10 uses a grid layout to arrange the calculator buttons. When you resize the window, the buttons grow and shrink, but all buttons have identical sizes.
In the constructor of the grid layout object, you specify how many rows and columns you need.
panet.setLayout(new GridLayout(4, 4));
Add the components, starting with the first entry in the first row, then the second entry in the first row, and so on.
panet.add(new JButton(“1”));
panet.add(new JButton(“2”));
Of course, few applications have as rigid a layout as the face of a calculator. In practice, small grids (usually with just one row or one column) can be useful to organize partial areas of a window. For example, if you want to have a row of buttons of identical sizes, you can put the buttons inside a panel that is governed by a grid layout with a single row.
Source: Horstmann Cay S. (2019), Core Java. Volume I – Fundamentals, Pearson; 11th edition.