2.布局管理器（FlowLayout、BorderLayout、GridLayout、GridBagLayout）

发布时间：2024年01月18日

布局管理器

2. 布局管理器

Java布局管理器是用来定义和控制Java图形用户界面（GUI）中组件的布局和排列的工具。它们负责根据不同的布局策略，将组件放置在容器中，并根据容器的大小和组件的属性来确定它们在界面上的位置和大小。

在Java中，常用的布局管理器有以下几种：

  1. FlowLayout（流式布局）：FlowLayout按照添加的顺序依次将组件放置在一行中，如果一行放不下，则自动换行。它会根据组件的大小自动调整它们在容器中的位置。

  2. BorderLayout（边界布局）：BorderLayout将容器分为五个区域：北、南、东、西、中。它将组件按照北、南、东、西的顺序放置，而中间的区域会自动扩展以填满剩余空间。

  3. GridLayout（网格布局）：GridLayout将容器按照行和列的网格划分，然后将组件按照网格的顺序放置。所有的网格大小相等，这就意味着所有组件都会尽量占据相同的空间。

  4. GridBagLayout（网格包布局）：GridBagLayout是最灵活的布局管理器，它可以根据需要自由地定位和调整组件的大小。它使用一个网格来确定组件的位置，并使用组件的约束属性来定义大小和位置。

在程序中可以通过调用容器对象的setLayout()方法设置布局管理器，通过布局管理器可以自动的进行组件的布局管理。

2.1 FlowLayout

FlowLayout（流式布局）是按照添加的顺序将组件依次放置在一行中，如果一行放不下，则自动换行。

FlowLayout会根据组件的大小自动调整它们在容器中的位置。

FlowLayout有以下几个特点：

  • 组件的顺序和添加顺序一致

    FlowLayout会按照组件被添加的顺序来放置它们，不管它们的大小和其他属性。

  • 自动换行

    如果一行放不下所有的组件，FlowLayout会自动将剩余的组件放置在下一行。

  • 组件会自动居中对齐

    FlowLayout的默认对齐方式是居中对齐，即使容器的宽度比组件的总宽度要大。

  • 组件之间有默认的间距

    FlowLayout会为组件之间添加默认的水平和垂直间距，可以通过设置容器的水平和垂直间距属性来调整间距大小。

2.1.1 构造方法

构造方法描述举例
FlowLayout()创建一个默认的流布局对象，水平方向的对齐方式为居中对齐。FlowLayout flowLayout = new FlowLayout();
FlowLayout(int align)创建一个流布局对象，可以指定水平方向的对齐方式。FlowLayout flowLayout = new FlowLayout(FlowLayout.LEFT);
FlowLayout(int align, int hgap, int vgap)创建一个流布局对象，可以指定水平方向对齐方式、水平和垂直间距。FlowLayout flowLayout = new FlowLayout(FlowLayout.RIGHT, 10, 10);
FlowLayout(int align, int hgap, int vgap)创建一个流布局对象，可以指定水平方向对齐方式、水平和垂直间距。FlowLayout flowLayout = new FlowLayout(FlowLayout.CENTER, 20, 20);
其中，align 参数指定水平方向的对齐方式，可以使用以下常量：
- FlowLayout.LEFT：左对齐
- FlowLayout.RIGHT：右对齐
- FlowLayout.CENTER：居中对齐
- FlowLayout.LEADING：从左到右对齐（由国家和区域设置决定）
- FlowLayout.TRAILING：从右到左对齐（由国家和区域设置决定）

hgap 参数指定水平间距，vgap 参数指定垂直间距。

以下是一些具体的示例：

  1. 创建一个默认的流布局对象，水平方向的对齐方式为居中对齐：
FlowLayout flowLayout = new FlowLayout();
  1. 创建一个流布局对象，水平方向的对齐方式为左对齐：
FlowLayout flowLayout = new FlowLayout(FlowLayout.LEFT);
  1. 创建一个流布局对象，水平方向的对齐方式为居中对齐，水平和垂直间距为10个像素：
FlowLayout flowLayout = new FlowLayout(FlowLayout.CENTER, 10, 10);
  1. 创建一个流布局对象，水平方向的对齐方式为右对齐，水平和垂直间距为20个像素：
FlowLayout flowLayout = new FlowLayout(FlowLayout.RIGHT, 20, 20);

2.1.2 常见属性

属性描述
alignment组件在容器中的对齐方式
hgap组件之间的水平间距
vgap组件之间的垂直间距

2.1.3 常用方法

方法描述举例
void setAlignment(int align)设置水平方向的对齐方式FlowLayout flowLayout = new FlowLayout();
flowLayout.setAlignment(FlowLayout.LEFT);
int getAlignment()获取当前水平方向的对齐方式int alignment = flowLayout.getAlignment();
void setHgap(int hgap)设置水平间距FlowLayout flowLayout = new FlowLayout();
flowLayout.setHgap(10);
int getHgap()获取当前水平间距int hgap = flowLayout.getHgap();
void setVgap(int vgap)设置垂直间距FlowLayout flowLayout = new FlowLayout();
flowLayout.setVgap(10);
int getVgap()获取当前垂直间距int vgap = flowLayout.getVgap();
void setAlignOnBaseline(boolean alignOnBaseline)设置在基线上对齐组件FlowLayout flowLayout = new FlowLayout();
flowLayout.setAlignOnBaseline(true);
boolean getAlignOnBaseline()判断是否在基线上对齐组件boolean alignOnBaseline = flowLayout.getAlignOnBaseline();
void setLayoutAlignment(int alignment)设置布局的对齐方式FlowLayout flowLayout = new FlowLayout();
flowLayout.setLayoutAlignment(FlowLayout.LEADING);
int getLayoutAlignment()获取当前布局的对齐方式int layoutAlignment = flowLayout.getLayoutAlignment();
int getLayoutAlignmentX(Container target)返回此布局是否应该将组件的 X 位置对齐到此布局的 X 对齐方式int layoutAlignmentX = flowLayout.getLayoutAlignmentX(container);
int getLayoutAlignmentY(Container target)返回此布局是否应该将组件的 Y 位置对齐到此布局的 Y 对齐方式int layoutAlignmentY = flowLayout.getLayoutAlignmentY(container);
void addLayoutComponent(String name, Component comp)加入指定名称的组件flowLayout.addLayoutComponent(“button1”, button1);
void removeLayoutComponent(Component comp)移除指定的组件flowLayout.removeLayoutComponent(button1);
Dimension preferredLayoutSize(Container target)计算流布局的首选大小Dimension preferredSize = flowLayout.preferredLayoutSize(container);
Dimension minimumLayoutSize(Container target)计算流布局的最小大小Dimension minimumSize = flowLayout.minimumLayoutSize(container);
void layoutContainer(Container target)对容器进行布局flowLayout.layoutContainer(container);
String toString()返回布局管理器的字符串表示形式String layoutString = flowLayout.toString();

【注意】这里的举例中的变量 flowLayout 是一个 FlowLayout 对象，而 container 是一个容器组件，比如 JPanel。

2.1.4 代码示例

import java.awt.FlowLayout;
import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JPanel;

public class FlowLayoutExample {

    public static void main(String[] args) {
        // 创建 JFrame 窗口
        JFrame frame = new JFrame("FlowLayout Example");

        // 设置窗口关闭操作
        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

        // 创建一个 JPanel，用于放置组件
        JPanel panel = new JPanel();

        // 创建 FlowLayout 布局管理器，并设置对齐方式和组件之间的间距
        FlowLayout layout = new FlowLayout(FlowLayout.CENTER, 10, 10);
        
        // 设置 JPanel 的布局管理器为 FlowLayout
        panel.setLayout(layout);

        // 创建 5 个 JButton，并添加到 JPanel 中
        JButton button1 = new JButton("Button 1");
        panel.add(button1);

        JButton button2 = new JButton("Button 2");
        panel.add(button2);

        JButton button3 = new JButton("Button 3");
        panel.add(button3);

        JButton button4 = new JButton("Button 4");
        panel.add(button4);

        JButton button5 = new JButton("Button 5");
        panel.add(button5);

        // 将 JPanel 添加到 JFrame 的内容面板中
        frame.getContentPane().add(panel);

        // 设置 JFrame 的大小
        frame.setSize(300, 200);

        // 设置 JFrame 可见
        frame.setVisible(true);
    }
}

在这个例子中，创建了一个名为FlowLayoutExample的类，并在main方法中进行了布局设置和组件的创建和添加。

2.1.5 注意事项

  1. 顺序添加组件：FlowLayout按照组件的添加顺序进行排列，从左到右，从上到下。

    因此，添加组件的顺序会影响它们在容器中的位置。

  2. 组件大小自适应：FlowLayout会自动调整组件的大小以适应容器的大小。

    这意味着组件可能会被压缩或延伸，以适应可用空间。可以使用setPreferredSize方法来设置组件的首选大小。

  3. 对齐方式：FlowLayout支持多种对齐方式，包括居中对齐、左对齐、右对齐和两端对齐。

    可以在创建FlowLayout对象时指定对齐方式，例如FlowLayout.CENTER、FlowLayout.LEFT、FlowLayout.RIGHT或FlowLayout.LEADING（从左向右的文本方向）。

  4. 组件间距：FlowLayout允许为组件之间设置水平和垂直间距。

    可以在创建FlowLayout对象时指定间距的值，例如FlowLayout(FlowLayout.CENTER, 10, 10) 将水平间距和垂直间距都设置为10像素。

  5. 容器的自动换行：FlowLayout布局的默认行为是在达到容器边界时自动换行。

    这意味着当组件不能完全放在一行上时，它们会被移到下一行。可以使用FlowLayout.LEFT或FlowLayout.LEADING对齐方式来控制在换行时组件的对齐方式。

  6. 不支持组件的定位：FlowLayout不支持直接控制组件的精确位置。

    组件的位置由布局管理器根据对齐方式和组件的大小进行计算。

2.2 BorderLayout

BorderLayout是一个经典的布局管理器，它将容器划分为五个区域：北(North)、南(South)、东(East)、西(West)和中心(Center)。每个区域都可以容纳一个组件，并根据窗口大小自动调整组件的大小和位置。

  1. 五个区域：

    • 北(North)：位于容器的顶部，通常用来放置标题栏、菜单栏或者工具栏等。
    • 南(South)：位于容器的底部，通常用来放置状态栏、进度条或者按钮等。
    • 东(East)：位于容器的右侧，通常用来放置边栏、导航栏或者附加控件等。
    • 西(West)：位于容器的左侧，通常用来放置边栏、导航栏或者附加控件等。
    • 中心(Center)：位于容器的中央，通常用来放置主要内容，例如面板、表格、图片等。

  2. 大小调整：

    • 默认情况下，中心区域会占据剩余的空间，并且会根据窗口的大小自动调整其大小。
    • 其他四个区域的大小通常由其所包含的组件的大小决定，可以使用setPreferredSize方法设置组件的首选大小。

  3. 添加和移除组件：

    • 使用add方法将组件添加到BorderLayout中的指定区域，并且在没有指定区域时，默认将组件添加到中心区域。
    • 可以使用remove方法将组件从布局中移除。

  4. 布局控制：

    • BorderLayout布局管理器可以通过构造函数显式指定默认组件之间的水平和垂直间距。
    • 可以使用setHgap和setVgap方法设置组件之间的水平间距和垂直间距。
    • 可以使用setAlignment方法设置组件在其区域内的对齐方式，例如LEFT、CENTER、RIGHT等。

2.2.1 构造方法

构造方法描述
BorderLayout()创建一个新的BorderLayout布局管理器，使用默认的水平和垂直间距（0）。
BorderLayout(int hgap, int vgap)创建一个新的BorderLayout布局管理器，并指定水平和垂直间距。

例如：

import javax.swing.*;
import java.awt.*;

public class BorderLayoutExample {
    public static void main(String[] args) {
        // 创建一个新的JFrame并设置标题
        JFrame frame = new JFrame("BorderLayout Example");

        // 创建一个新的JPanel，使用BorderLayout布局管理器，默认间距为0
        JPanel panel1 = new JPanel(new BorderLayout());
        JButton button1 = new JButton("Button 1");
        panel1.add(button1, BorderLayout.CENTER);
        frame.getContentPane().add(panel1, BorderLayout.NORTH);

        // 创建一个新的JPanel，使用BorderLayout布局管理器，水平间距为10，垂直间距为5
        JPanel panel2 = new JPanel(new BorderLayout(10, 5));
        JButton button2 = new JButton("Button 2");
        panel2.add(button2, BorderLayout.CENTER);
        frame.getContentPane().add(panel2, BorderLayout.SOUTH);

        // 设置窗口的大小和可见性
        frame.setSize(300, 200);
        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        frame.setVisible(true);
    }
}

上述代码演示了两个使用不同构造方法的例子：

  • 第一个例子中的panel1使用了默认的构造方法，没有指定水平和垂直间距，所以间距为默认值（0）。
  • 第二个例子中的panel2使用了带有参数的构造方法，水平间距为10，垂直间距为5。

2.2.2 常见属性

属性描述
NORTH区域的北部（上方）
SOUTH区域的南部（下方）
WEST区域的西部（左侧）
EAST区域的东部（右侧）
CENTER区域的中心
HORIZONTAL设置水平间距
VERTICAL设置垂直间距
LINE_START区域的开始（左侧），对于从右到左的语言环境是右侧
LINE_END区域的结束（右侧），对于从右到左的语言环境是左侧
PAGE_START页面的顶部
PAGE_END页面的底部

2.2.3 常用方法

方法描述
setHgap(int hgap)设置组件的水平间距。
setVgap(int vgap)设置组件的垂直间距。
setGap(int hgap, int vgap)设置组件的水平和垂直间距。
getHgap()获取组件的水平间距。
getVgap()获取组件的垂直间距。
addLayoutComponent(String name, Component comp)添加组件到布局中，并指定位置的名称。
removeLayoutComponent(Component comp)从布局中移除组件。
preferredLayoutSize(Container target)返回容器的首选布局尺寸。
minimumLayoutSize(Container target)返回容器的最小布局尺寸。
maximumLayoutSize(Container target)返回容器的最大布局尺寸。
layoutContainer(Container parent)布局容器的组件。

2.2.4 代码示例

下面是一些例子说明：

  1. 添加组件到布局中，并指定位置的名称
import javax.swing.*;
import java.awt.*;

public class BorderLayoutExample {
    public static void main(String[] args) {
        // 创建一个新的JFrame并设置标题
        JFrame frame = new JFrame("BorderLayout Example");
        frame.setLayout(new BorderLayout());

        JButton button1 = new JButton("Button 1");
        frame.add(button1, BorderLayout.NORTH);

        JButton button2 = new JButton("Button 2");
        frame.add(button2, BorderLayout.CENTER);

        // 设置窗口的大小和可见性
        frame.setSize(300, 200);
        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        frame.setVisible(true);
    }
}
  1. 移除布局中的组件
import javax.swing.*;
import java.awt.*;

public class BorderLayoutExample {
    public static void main(String[] args) {
        // 创建一个新的JFrame并设置标题
        JFrame frame = new JFrame("BorderLayout Example");
        frame.setLayout(new BorderLayout());

        JButton button1 = new JButton("Button 1");
        frame.add(button1, BorderLayout.NORTH);

        JButton button2 = new JButton("Button 2");
        frame.add(button2, BorderLayout.CENTER);

        // 移除按钮1
        frame.remove(button1);

        // 设置窗口的大小和可见性
        frame.setSize(300, 200);
        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        frame.setVisible(true);
    }
}
  1. 获取容器的首选布局尺寸、最小布局尺寸和最大布局尺寸
import javax.swing.*;
import java.awt.*;

public class BorderLayoutExample {
    public static void main(String[] args) {
        // 创建一个新的JFrame并设置标题
        JFrame frame = new JFrame("BorderLayout Example");
        frame.setLayout(new BorderLayout());

        JButton button1 = new JButton("Button 1");
        frame.add(button1, BorderLayout.NORTH);

        JButton button2 = new JButton("Button 2");
        frame.add(button2, BorderLayout.CENTER);

        // 获取容器的首选布局尺寸
        Dimension preferredSize = frame.getPreferredSize();
        System.out.println("Preferred size: " + preferredSize);

        // 获取容器的最小布局尺寸
        Dimension minimumSize = frame.getMinimumSize();
        System.out.println("Minimum size: " + minimumSize);

        // 获取容器的最大布局尺寸
        Dimension maximumSize = frame.getMaximumSize();
        System.out.println("Maximum size: " + maximumSize);

        // 设置窗口的大小和可见性
        frame.setSize(300, 200);
        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        frame.setVisible(true);
    }
}

2.2.5 注意事项

在使用BorderLayout时，有几点需要注意：

  1. BorderLayout将组件分为五个区域：北(NORTH)、南(SOUTH)、东(EAST)、西(WEST)和中(CENTER)。

    每个区域只能包含一个组件。

  2. 默认情况下，组件将会填充其区域的所有可用空间。

    想要组件按照其首选大小进行布局，则可以设置其首选尺寸（preferred size）。

  3. 组件在添加到BorderLayout容器时，默认会按照以下顺序添加：北、南、东、西、中。

  4. 如果某个区域没有设置组件，那么它将不会占用任何空间。

  5. 当调整容器的大小时，BorderLayout会自动调整各个区域的大小以适应新的容器尺寸。

  6. 如果在同一个区域添加了多个组件，只有最后一个添加的组件会被显示，其他的组件将被覆盖。

  7. 可以使用setHgap(int hgap)和setVgap(int vgap)方法来设置水平间距（hgap）和垂直间距（vgap），以调整不同区域之间的间距。

  8. BorderLayout是Java的默认布局管理器，所以当你不指定布局管理器时，容器默认会使用BorderLayout。

    但是，如果你显式地设置了其他布局管理器，那么应该记得将其重置回BorderLayout，否则布局可能会出现问题。

2.3 GridLayout

GridLayout是Java中常用的布局管理器之一，它将容器分割成一个网格，并且每个单元格可以放置一个组件。

  1. 组件排列方式：

    • 默认情况下，组件按照从左到右、从上到下的顺序排列在网格中。

    • 如果组件的数量大于网格的单元格数，那么它们将会自动填充多个单元格。

    • 如果组件的数量少于网格的单元格数，那么多出的单元格将保持空白。

  2. 网格的调整：

    • 当改变容器的大小时，GridLayout会自动调整网格的大小，以适应新的容器尺寸。

    • 所有的单元格将会按照相同的尺寸进行调整，以保持整齐的布局。

  3. 间距调整：

    • GridLayout允许你设置水平和垂直间距，以调整单元格之间的间距。水平间距指的是单元格之间的横向间距，而垂直间距指的是单元格之间的纵向间距。

    • 可以通过构造函数或者使用setHgap(int hgap)和setVgap(int vgap)方法来设置间距。

    • 如果不设置间距，默认为0。

  4. 组件的添加方式：

    • 组件按照从左到右、从上到下的顺序被添加到单元格中。

    • 可以使用add(Component comp)方法将组件添加到容器中。

2.3.1 构造方法

构造方法示例
GridLayout()GridLayout layout = new GridLayout();
GridLayout(int rows, int cols)GridLayout layout = new GridLayout(3, 4);
GridLayout(int rows, int cols, int hgap, int vgap)GridLayout layout = new GridLayout(2, 3, 10, 10);

例如：

  1. GridLayout():

    • 创建一个默认的GridLayout对象，只有一个单元格。
    • 示例：GridLayout layout = new GridLayout();

  2. GridLayout(int rows, int cols):

    • 创建一个具有指定行数和列数的GridLayout对象。
    • 示例：GridLayout layout = new GridLayout(3, 4);
    • 创建一个3行4列的GridLayout，总共有12个单元格。

  3. GridLayout(int rows, int cols, int hgap, int vgap):

    • 创建一个具有指定行数、列数、水平和垂直间距的GridLayout对象。
    • 示例：GridLayout layout = new GridLayout(2, 3, 10, 10);
    • 创建一个2行3列的GridLayout，水平和垂直间距均为10像素。

2.3.2 常用属性

属性描述
rows指定容器中的行数。
columns指定容器中的列数。
hgap组件之间的水平间距。
vgap组件之间的垂直间距。

2.3.3 常用方法

下面是GridLayout的所有方法以表格形式输出，并附带示例：

方法描述示例
void setRows(int rows)设置GridLayout的行数。layout.setRows(2);
int getRows()获取GridLayout的行数。int rows = layout.getRows();
void setColumns(int cols)设置GridLayout的列数。layout.setColumns(3);
int getColumns()获取GridLayout的列数。int cols = layout.getColumns();
void setHgap(int hgap)设置GridLayout的水平间距。layout.setHgap(10);
int getHgap()获取GridLayout的水平间距。int hgap = layout.getHgap();
void setVgap(int vgap)设置GridLayout的垂直间距。layout.setVgap(10);
int getVgap()获取GridLayout的垂直间距。int vgap = layout.getVgap();
void addLayoutComponent(Component comp, Object constraints)向GridLayout中添加组件，并指定约束条件。layout.addLayoutComponent(label, "cell 0 0");
void removeLayoutComponent(Component comp)从GridLayout中移除指定的组件。layout.removeLayoutComponent(button);
void layoutContainer(Container parent)对容器中的组件进行布局。layout.layoutContainer(container);
Dimension preferredLayoutSize(Container parent)获取GridLayout的首选布局大小。Dimension size = layout.preferredLayoutSize(container);
Dimension minimumLayoutSize(Container parent)获取GridLayout的最小布局大小。Dimension size = layout.minimumLayoutSize(container);
void invalidateLayout(Container parent)使容器中的布局无效，需要重新计算布局。layout.invalidateLayout(container);

2.3.4 代码示例

import java.awt.GridLayout;
import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JPanel;

public class GridLayoutExample {
  public static void main(String[] args) {
    JFrame frame = new JFrame("GridLayout Example");
    frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

    JPanel panel = new JPanel();
    panel.setLayout(new GridLayout(3, 3)); // 使用3行3列的GridLayout

    // 创建并添加按钮到面板
    for (int i = 1; i <= 9; i++) {
      JButton button = new JButton("Button " + i);
      panel.add(button);
    }

    frame.add(panel);
    frame.pack();
    frame.setVisible(true);
  }
}

这个示例程序创建了一个使用3行3列的GridLayout布局的JFrame窗口。然后，它创建了9个JButton组件，并将它们添加到JPanel面板中。最后，该面板被添加到JFrame窗口中，并显示出来。

2.3.5 注意事项

  1. GridLayout是一个等分布局管理器，将容器的可用空间平均分配给每个组件，所以所有的组件大小都将相等。

    如果希望某些组件具有不同的大小，可以考虑使用其他布局管理器。

  2. GridLayout的行数和列数是固定的，一旦确定，不能动态地改变。

    如果需要动态地添加或删除组件，可以考虑使用其他灵活的布局管理器，如GridBagLayout。

  3. 组件在GridLayout中按照添加的顺序依次排列。

    如果需要更高级的布局控制，可以考虑使用其他布局管理器，如BorderLayout或GridBagLayout。

  4. 当容器中的组件数量超过了GridLayout的行数和列数时，GridLayout会自动在新的一行或者新的一列进行布局。

  5. GridLayout的每个格子都具有相同的大小，因此，如果一个组件的大小超过了这个格子的大小，该组件会被截断或者溢出。

    可以考虑使用其他布局管理器或者设置组件的大小以适应GridLayout的格子。

  6. 如果某个格子没有组件填充，GridLayout会自动调整该格子的大小，以保证所有的格子都具有相同的大小。

  7. GridLayout的构造函数可以接受行数和列数作为参数，可以根据需要进行调整。

    如果参数为0，那么GridLayout会根据组件的数量自动计算行数和列数。

2.4 GridBagLayout

GridBagLayout是Java Swing中的一种灵活且功能强大的布局管理器，它允许在容器中以网格形式布置组件，并能够在组件之间指定各种约束条件。

使用GridBagLayout，可以在容器中创建一个网格，每个网格单元可以放置一个组件。在网格单元中，可以指定组件的位置、大小以及对其方式等约束条件，使得组件在布局中的位置和尺寸更加灵活和精确。

特性：

  1. 约束条件（Constraints）：GridBagLayout使用GridBagConstraints对象来指定组件在布局中的位置和大小等约束条件。GridBagConstraints包含了许多属性，如gridx、gridy、gridwidth、gridheight、weightx、weighty、fill、anchor等，可以通过设置这些属性来精确控制组件的布局。

  2. 网格（Grid）：GridBagLayout将容器划分为一组网格，每个网格单元可以放置一个组件。组件可以占据多个网格单元，这样可以实现组件的合并和跨越。

  3. 网格单元（Grid Cell）：每个网格单元是布局的一个基本单位，组件可以放置在网格单元的左上角，也可以放置在网格单元的中心或者其他位置，具体取决于约束条件。

  4. 网格包装（Grid Wrap）：当组件的位置超过了网格范围时，可以通过设置约束条件中的gridwidth或gridheight属性来实现组件在网格中的跨越，即组件在多个网格单元中展开。

  5. 填充（Fill）：GridBagConstraints的fill属性用于指定组件在其网格单元中的填充方式。可以设置为NONE、HORIZONTAL、VERTICAL或BOTH，控制组件在水平方向、垂直方向或两个方向上是否填充其可用空间。

  6. 对齐（Anchor）：GridBagConstraints的anchor属性用于指定组件在其网格单元中的对齐方式。可以设置为CENTER、NORTH、NORTHEAST、EAST、SOUTHEAST、SOUTH、SOUTHWEST、WEST或NWEST，控制组件在其网格单元中的对齐方式。

  7. 权重（Weight）：GridBagConstraints的weightx和weighty属性用于指定组件在容器的可用空间中所占的权重。通过设置权重，可以控制组件在容器中的分配空间，以适应容器的调整。

2.4.1 构造方法

构造方法描述
GridBagLayout()创建一个新的GridBagLayout实例。
GridBagLayout(LayoutManagerInfo layoutInfo)创建一个新的GridBagLayout实例，并指定LayoutManagerInfo对象，该对象定义了GridBagLayout的布局信息。

示例用法：

  1. 使用无参构造方法创建GridBagLayout实例：
import java.awt.GridBagLayout;
import javax.swing.JFrame;
import javax.swing.JButton;

public class GridBagLayoutExample {
    public static void main(String[] args) {
        // 创建一个新的GridBagLayout实例
        GridBagLayout layout = new GridBagLayout();

        // 创建一个JFrame窗口
        JFrame frame = new JFrame("GridBagLayout Example");
        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        frame.setLayout(layout);

        // 添加组件到窗口中
        JButton button1 = new JButton("Button 1");
        frame.add(button1);

        JButton button2 = new JButton("Button 2");
        frame.add(button2);

        JButton button3 = new JButton("Button 3");
        frame.add(button3);

        // 设置窗口大小并可见
        frame.setSize(300, 200);
        frame.setVisible(true);
    }
}
  1. 使用带参构造方法创建GridBagLayout实例：
import java.awt.GridBagLayout;
import java.awt.GridBagConstraints;
import javax.swing.JFrame;
import javax.swing.JButton;

public class GridBagLayoutExample {
    public static void main(String[] args) {
        // 创建一个新的GridBagLayout实例，并指定LayoutManagerInfo对象
        GridBagLayout layout = new GridBagLayout(new GridBagConstraints());

        // 创建一个JFrame窗口
        JFrame frame = new JFrame("GridBagLayout Example");
        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        frame.setLayout(layout);

        // 添加组件到窗口中
        JButton button1 = new JButton("Button 1");
        frame.add(button1);

        JButton button2 = new JButton("Button 2");
        frame.add(button2);

        JButton button3 = new JButton("Button 3");
        frame.add(button3);

        // 设置窗口大小并可见
        frame.setSize(300, 200);
        frame.setVisible(true);
    }
}

2.4.2 常用属性

属性描述
gridx组件所在的网格单元的水平位置。
gridy组件所在的网格单元的垂直位置。
gridwidth组件跨越的网格单元的数量（在水平方向上）。
gridheight组件跨越的网格单元的数量（在垂直方向上）。
weightx组件在水平方向上的相对权重，决定当容器的宽度改变时组件的尺寸变化。
weighty组件在垂直方向上的相对权重，决定当容器的高度改变时组件的尺寸变化。
anchor组件在其网格单元中的对齐方式。
fill组件在其网格单元中的填充方式。
insets组件与其所在单元格边界之间的内边距（上、下、左、右）。
ipadx组件内部的水平填充大小，增加组件的内容区域尺寸（水平方向）。
ipady组件内部的垂直填充大小，增加组件的内容区域尺寸（垂直方向）。

2.4.3 常用方法

方法名说明举例
void setConstraints(Component comp, GridBagConstraints constraints)设置组件的约束条件。GridBagConstraints gbc = new GridBagConstraints();
gbc.gridx = 0;
gbc.gridy = 0;
gbl.setConstraints(component, gbc);
void addLayoutComponent(Component comp, Object constraints)向布局管理器添加组件以及其约束条件。gbl.addLayoutComponent(component, constraints);
void removeLayoutComponent(Component comp)从布局管理器中移除指定的组件。gbl.removeLayoutComponent(component);
Dimension minimumLayoutSize(Container target)返回布局管理器在指定容器中所建议的最小尺寸。Dimension minSize = gbl.minimumLayoutSize(container);
Dimension preferredLayoutSize(Container target)返回布局管理器在指定容器中所建议的首选尺寸。Dimension prefSize = gbl.preferredLayoutSize(container);
Dimension maximumLayoutSize(Container target)返回布局管理器在指定容器中所建议的最大尺寸。Dimension maxSize = gbl.maximumLayoutSize(container);
float getLayoutAlignmentX(Container target)返回布局管理器的水平对齐方式。float alignmentX = gbl.getLayoutAlignmentX(container);
float getLayoutAlignmentY(Container target)返回布局管理器的垂直对齐方式。float alignmentY = gbl.getLayoutAlignmentY(container);
void invalidateLayout(Container target)使布局管理器无效。gbl.invalidateLayout(container);

2.4.4 代码示例

以下是一个使用 GridBagLayout 的简单代码示例：

import java.awt.GridBagConstraints;
import java.awt.GridBagLayout;
import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JPanel;

public class GridBagLayoutExample {
    public static void main(String[] args) {
        JFrame frame = new JFrame("GridBagLayout Example");
        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

        JPanel panel = new JPanel();
        panel.setLayout(new GridBagLayout());

        JButton button1 = new JButton("Button 1");
        GridBagConstraints gbc1 = new GridBagConstraints();
        gbc1.gridx = 0;
        gbc1.gridy = 0;
        gbc1.fill = GridBagConstraints.HORIZONTAL;
        panel.add(button1, gbc1);

        JButton button2 = new JButton("Button 2");
        GridBagConstraints gbc2 = new GridBagConstraints();
        gbc2.gridx = 1;
        gbc2.gridy = 0;
        gbc2.fill = GridBagConstraints.HORIZONTAL;
        panel.add(button2, gbc2);

        JButton button3 = new JButton("Button 3");
        GridBagConstraints gbc3 = new GridBagConstraints();
        gbc3.gridx = 0;
        gbc3.gridy = 1;
        gbc3.gridwidth = 2;
        gbc3.fill = GridBagConstraints.BOTH;
        panel.add(button3, gbc3);

        frame.add(panel);
        frame.pack();
        frame.setVisible(true);
    }
}

在这个示例中，创建了一个 JFrame，并向其添加一个 JPanel 作为内容面板。然后，在 JPanel 上使用 GridBagLayout 进行布局。

通过创建 GridBagConstraints 对象并设置其属性，可以控制每个组件在容器中的位置和大小。在这个例子中，创建了三个 JButton，并使用 GridBagConstraints 确定它们的位置和尺寸。

2.4.5 注意事项

在使用 GridBagLayout 进行布局时，有几个注意事项需要考虑：

  1. GridBagConstraints 属性：GridBagConstraints 是用于确定组件在容器中的位置和尺寸的对象。

    需要通过设置其属性来控制组件的位置、跨越的行列数、大小以及填充方式等。在使用 GridBagLayout 时，仔细考虑和调整 GridBagConstraints 的各个属性，以确保组件正确地布局。

  2. 组件的添加顺序：组件的添加顺序对布局结果有影响。

    GridBagLayout 会根据组件的添加顺序来确定它们在容器中的位置。如果组件被跳过或添加顺序不正确，可能导致意外的布局结果。确保以正确的顺序添加组件。

  3. 填充方式：使用 fill 属性来控制组件在其单元格中的大小。

    GridBagConstraints 中的 fill 属性有多个选项，如 GridBagConstraints.HORIZONTAL、GridBagConstraints.VERTICAL 和 GridBagConstraints.BOTH。根据组件的需求，在水平方向、垂直方向或两个方向上适当地设置填充方式。

  4. 单元格的合并和跳跃：使用 gridwidth 和 gridheight 属性可以跨越多个单元格。

    这允许你将组件放置在占据多个单元格的位置。注意，合并的单元格必须为空（没有其他组件占据）。如果是跳跃放置组件，则跳过的单元格应为空。

  5. 重要组件的权重：如果你要调整某个组件的大小，可以为其设置 weightx 和 weighty 属性。

    这些属性决定了当容器的大小发生变化时，组件在水平和垂直方向上的相对权重。通过适当调整这些权重，可以改变组件的大小调整行为。

  6. Insets 和 Anchor：要在组件的周围添加空白区域，可以使用 insets 属性来设置内边距。

    Insets 属性可以控制组件与其所在单元格的边界之间的间距。此外，使用 anchor 属性可以将组件固定在其单元格中的特定方位，默认为 GridBagConstraints.CENTER。

  7. GridBagLayout 的复杂性：GridBagLayout 是一个相对复杂的布局管理器，对于简单的布局需求来说可能有点繁琐。

    它适合于需要更精确和灵活的布局的情况，但同时需要花费更多的时间和精力来调整和控制布局结果。

文章来源:https://blog.csdn.net/kuxiaoyang/article/details/135673046
本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。
最新文章