精华内容
下载资源
问答
  • Java布局管理器

    千次阅读 2018-10-21 02:17:11
    Java组件布局由布局管理器对象来管理;布局管理器会确定组件打大小和位置;在容器发生变化是做出动态调整。 二、布局管理器的分类  FlowLayout:流式布局管理器  BorderLayout:边界布局管理器  GridLayout:...

    一、布局管理器概念:各组件在容器中的大小以及摆放位置。实现跨平台特性并获得动态布局的效果;Java组件布局由布局管理器对象来管理;布局管理器会确定组件打大小和位置;在容器发生变化是做出动态调整。

    二、布局管理器的分类

           FlowLayout:流式布局管理器

           BorderLayout:边界布局管理器

           GridLayout:网格布局管理器

           GridBagLayout:网格组布局管理器

           GardLayout:卡片布局管理器

           BoxLayout:箱式布局管理器

           SpringLayout:弹簧布局管理器

    1、FlowLayout:流式布局管理器

          组件加入容器的顺序是从左到右,容器大小改变时组件大小不改变,位置会改变

    代码如下:

    package Layout;
    import java.awt.*;
    import javax.swing.*;
    
    class FlowLayoutDemo {
    	JFrame frame;
    	JButton button1,button2,button3,button4,button5,button6;
    	public FlowLayoutDemo(String title) {
    		frame = new JFrame(title);
    		frame.setSize(260, 150);
    		button1 = new JButton("按钮一");
    		button2 = new JButton("按钮二");
    		button3 = new JButton("按钮三");
    		button4 = new JButton("按钮四");
    		button5 = new JButton("按钮五");
    		button6 = new JButton("按钮六");
    		
    		//设置流式布局管理器
    		frame.getContentPane().setLayout(new FlowLayout());
    		frame.add(button1);
    		frame.add(button2);
    		frame.add(button3);
    		frame.add(button4);
    		frame.add(button5);
    		frame.add(button6);
    		frame.setLocationRelativeTo(null);
    		frame.setVisible(true);
    		frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
    	}
    }
    
    package Layout;
    
    public class FlowLayoutDemo_App {
    
    	public static void main(String[] args) {
    		new FlowLayoutDemo("FlowLayout");
    	}
    
    }
    

    运行结果:

    public  FlowLayout():构造方法,新建流式布局管理器

    public  FlowLayout(int  align):构造方法,新建有指定对齐方式的管理器,比如向左、向右、居中

    .....................

    2、 BorderLayout:边界布局管理器

           边界布局管理器将容器分为EAST(东区)、WEST(西区)、SOUTH(南区)、NORTH(北区)、CENTER(中心区),组件放入区域后将自动铺满区域或则最多可以放置一个组件,要在一个区域放置多个组件时就要在该区域放置一个中间层容器,再将组件放到容器中;中间区域没有放置组件这个区域依然会保留,其他的则不会。

    代码如下:

    package Layout;
    import java.awt.*;
    import javax.swing.*;
    
    class BorderLayoutDemo {
    	JFrame frame;
    	JButton buttonEAST,buttonWEST,buttonSOUTH,buttonNORTH,buttonCENTER;
    	public BorderLayoutDemo(String title) {
    		frame = new JFrame(title);
    		frame.setSize(450, 300);
    		Container container = frame.getContentPane();
    		
    		//设置为边界布局,组件水平距离和垂直间距都为2
    		container.setLayout(new BorderLayout(2,2));
    		buttonEAST = new JButton("东区");
    		buttonWEST = new JButton("西区");
    		buttonSOUTH =new JButton("南区");
    		buttonNORTH = new JButton("北区");
    		buttonCENTER = new JButton("中心区");
    		buttonEAST.setBackground(Color.red);
    		buttonWEST.setBackground(Color.gray);
    		buttonSOUTH.setBackground(Color.LIGHT_GRAY);
    		buttonNORTH.setBackground(Color.darkGray);
    		buttonCENTER.setBackground(Color.yellow);
    		
    		frame.add(BorderLayout.EAST,buttonEAST);
    		frame.add(BorderLayout.WEST, buttonWEST);
    		frame.add(BorderLayout.SOUTH, buttonSOUTH);
    		frame.add(BorderLayout.NORTH, buttonNORTH);
    		frame.add(BorderLayout.CENTER, buttonCENTER);
    		frame.setLocationRelativeTo(null);
    		frame.setVisible(true);
    		frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
    	}
    }
    
    package Layout;
    
    public class BorderLayoutDemo_App {
    
    	public static void main(String[] args) {
    		new BorderLayoutDemo("BorderLayout");
    	}
    
    }
    

    运行结果:

    public  BorderLayout():构造方法,创建边界布局管理器,组件之间距离为0

    public  BorderLayout(int  hgap,int  vgap):构造方法,新建指定组件间距的边界布局管理器

    public  void setHgap(int hgap):设置组件之间的水平距离

    public  void setVgap(int  vgap):设置组件之间的垂直距离

    3、  GridLayout:网格布局管理器

    网格布局管理器将容器平均分成若干行、若干列,每个网格的高和宽都相同、只能放置一个组件,组件放到容器时,按照添加顺序从左到右、从上到下放入网格。

    代码如下:

    package Layout;
    import javax.swing.*;
    import java.awt.*;
    
    class GridLayoutDemo {
    	JFrame frame;
    	JButton btn1,btn2,btn3,btn4,btn5,btn6,btn7;
    	GridLayoutDemo() {
    		frame = new JFrame("GridLayout");
    		Container container = frame.getContentPane();
    		
    		//创建三行三列的网格布局管理器
    		container.setLayout(new GridLayout(3, 3));
    		btn1 = new JButton("按钮1");
    		btn2 = new JButton("按钮2");
    		btn3 = new JButton("按钮3");
    		btn4 = new JButton("按钮4");
    		btn5 = new JButton("按钮5");
    		btn6 = new JButton("按钮6");
    		btn7 = new JButton("按钮7");
    		
    		frame.add(btn1);
    		frame.add(btn2);
    		frame.add(btn3);
    		frame.add(btn4);
    		frame.add(btn5);
    		frame.add(btn6);
    		frame.add(btn7);
    		frame.setSize(550, 300);
    		frame.setLocationRelativeTo(null);
    		frame.setVisible(true);
    		frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
    	}
    }
    
    package Layout;
    
    public class GridLayoutDemo_App {
    
    	public static void main(String[] args) {
    		new GridLayoutDemo();
    	}
    
    }
    

    运行结果:

    网格布局的特点:

    (1)、组件在容器中呈网状分布

    (2)、网格的宽度相同,等于容器的宽度除网格的列数,高度相同,等于容器的高度除网格的行数

    (3)、从左到右、从上到下排列

    (4)、容器大小改变,组件的相对位置不会改变,大小会改变

    (5)、添加的组件数超过设定的网格数,布局自动增加网格数,原则是保持行数不变

    4、GardLayout:卡片布局管理器

    主要用于处理多个组件共享同一显示空间的情况

    代码如下:

    package Layout;
    import java.awt.*;
    import java.awt.event.MouseAdapter;
    import java.awt.event.MouseEvent;
    
    import javax.swing.*;
    
    class CradLayoutDemo extends MouseAdapter{
    	JFrame frame;
    	JPanel panel;
    	JLabel label;
    	JButton btn;
    	Container contentPan;
    	CardLayout cardLayout;  //声明卡片布局管理器对象
    	CradLayoutDemo(){
    		frame = new JFrame("CardLayout");
    		contentPan = frame.getContentPane();  //getContentPane()方法获得JFrame的内容面板
    		cardLayout = new CardLayout();  //创建卡片布局管理器
    		contentPan.setLayout(cardLayout);    //为frame设置卡片布局管理器
    		
    		//创建组件
    		panel = new JPanel();
    		JLabel labelPanel = new JLabel("这是一个面板");
    		panel.add(labelPanel);
    		label = new JLabel("这是一个标签");
    		btn = new JButton("这是一个按钮");
    		
    		//将组件添加到frame中,每个组件赋予一个名字
    		frame.add(panel,"panel");
    		frame.add(label,"label");
    		frame.add(btn,"btn");
    		frame.add(panel,"panel");
    		
    		//显示面板
    		cardLayout.show(contentPan, "panel");
    		
    		frame.setSize(540, 380);
    		frame.setLocationRelativeTo(null);
    		frame.setVisible(true);
    		frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
    		
    		//组件的事件注册
    		panel.addMouseListener(this);
    		label.addMouseListener(this);
    		btn.addMouseListener(this);
    	}
    	
    	public void mouseClicked(MouseEvent e) {
    		cardLayout.next(contentPan);
    	}
    	
    }
    
    package Layout;
    
    import java.awt.CardLayout;
    
    public class CradLayoutDemo_App {
    
    	public static void main(String[] args) {
    		new CradLayoutDemo();
    	}
    
    }
    

    运行结果:

     

    展开全文
  • 主要介绍了Java Swing组件布局管理器之FlowLayout(流式布局),结合实例形式分析了Swing组件布局管理器FlowLayout流式布局的常用方法及相关使用技巧,需要的朋友可以参考下
  • 深入Java布局管理器

    2020-12-22 20:52:50
    Java的GUI界面定义是由awt类和swing类来完成的。它在布局管理上面采用了容器和布局管理分离的方案。也是说,容器只管将其他小件放...  现在我们来看Java布局管理器的具体实现。我们前面说过,Java中的容器类(Contai
  • 主要介绍了JAVA布局管理器与面板组合代码实例,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
  • NUMPAGES GridBagLayout布局的讲解 刚学Java图形界面设计时很重要的一点就是界面的布局有很多种布局管理器其中功能最强大的就是GridBagLayout GridBagLayout管理有一个GridBagConstraints约束该约束的作用就是控制...
  • java 布局管理器

    2012-09-18 11:11:40
    java布局管理器测试代码,绝对能运行,环境为jdk1.6下
  • 主要介绍了Java弹簧布局管理器使用方法详解,需要的朋友可以参考下
  • 主要介绍了Java编程使用卡片布局管理器,结合实例形式分析了java基于swing组件的卡片布局管理器具体实现与使用技巧,需要的朋友可以参考下
  • Java布局管理器组件

    千次阅读 多人点赞 2016-05-09 19:25:26
    Java布局管理器组件所谓布局管理,就是为容器内的组件提供若干布局策略,每个容器都拥有某种默认布局管理,用于负责其内部组件的排列。目前开发中,常用的布局管理有BorderKayout、FlowLayout、GridLayout、...

    Java布局管理器组件

    所谓布局管理器,就是为容器内的组件提供若干布局策略,每个容器都拥有某种默认布局管理器,用于负责其内部组件的排列。目前开发中,常用的布局管理器有BorderLayout、FlowLayout、GridLayout、GridBagLayout、CardLayout、BoxLayout、SpringLayout、GroupLayout等:

    • 布局管理器种类
    • BorderLayout
    • FlowLayout
    • GridLayout
    • GridBagLayout
    • CardLayout
    • BoxLayout
    • SpringLayout
    • GroupLayout

    布局管理器种类

    种类说明
    BorderLayout它将容器分为5个部分,即东、南、西、北、中,每一个区域中可以容纳一个组件,使用的时候也是通过BorderLayout中的5个方位长量来确定组件所在位置
    FlowLayout是按加入的先后顺序从左到右排列,一行排满了,再换行,继续从从左到右排列。每一行的组件都是居中排列的
    GridLayout是将整个布局空间划分成若干行乘若干列的网格区域。组件就位于这些网格区域内
    GridBagLayout是通过网格进行划分,可以看到每个组都占据一个网格,也可以一个组件占据几个网格。有点类似GridLayout,但比它复杂
    CardLayout将容器中的每一个组件当作一个卡片,因此仅有一个卡片可见,最初显示容器时,增加到 CardLayout对象的第一个组件可见
    BoxLayout通过允许在容器中水平或垂直的方式安排多个组件
    SpringLayout通过定义组件边沿关系来实现布局
    GroupLayout指定在一个窗体上组件彼此之间的关系,例如一个位置关系或对其关系

    以上布局管理器各有特色,适用于不同的场合。
    布局管理器能将各种组件在顶层容器内排列的井井有条,那么,布局管理器为什么能够有如此能力?它是如何工作的呢?下面将讲述有关布局管理的工作原理。


    在创建好顶层框架后,会调用JFrame的pack方法,用于指定顶层框架所必须的首选大小。而这个首选大小是框架的内容窗口大小与框架菜单栏的大小之和。内容窗口的布局管理器主要负责计算内容窗口的首选大小,例如要使用一个具有两列的GridLayout来布局,那么系统会将所有的组件大小都设置为一样的,并且使得每个组件的高度和宽度与所有组件中高度和宽度最大的组件相同。通过这种方式计算出内容窗口的首选大小。然后,根据每个组件的大小,按照先后或在坐标位置,将之放入到布局管理器所布局的组件中去。


    和 AWT相同,为了容器中组件能实现与平台无关的自动合理排列,Swing也采用了布局管理器来管理组件的排放、位置、大小等布置任务,在此基础上将显示风格做了改进。另外一个不同点在于,Swing虽然有顶层容器,但是不能把组件直接加到顶层容器中,Swing窗体中含有一个成为内容面板的容器(ContentPane),也可以说是中间容器。在顶层容器上放置内容面板,然后把组件加入到内容面板中,所以在Swing中,设置布局管理器是针对内容面板的,另外Swing新增加了一个BoxLayout布局管理器,显示与AWT略有不同。

    BorderLayout

    BorderLayout是一种简单的布局策略,在使用在这个布局管理器时,应将其看作是一个组件,所以,首先应通过构造器创建布局管理器对象,再通过引用其中的方法和变量来对组件进行布局。下面将以表格形式列举出BorderLayout布局管理器的构造器。

    布局管理器的构造器说明
    BorderLayout()构造一个组件之间没有间距的新边框布局
    BorderLayout(int h,int v)构造一个具有指定组件间距的边框布局

    这个布局管理器把容器分为东、南、西、北、中5个区域,每个组件将占据某个区域。而这5个区域分别被命名为NORTH、WEST、EAST、CENTER、SOUTH,它们都被定义为静态常量,静态常量可以直接引用。如下表所示:

    常量说明
    public static final String NORTH=”North”整个内容面板的北边(顶部)
    public static final String WEST=”West”整个内容面板的西边(左边)
    public static final String EAST=”East”整个内容面板的东边(右边)
    public static final String CENTER=”Center”整个内容面板的中间(中间)
    public static final String SOUTH=”South”整个内容面板的南边(底部)

    当向某个区域内添加控件时,就要将代表区域的常数作为第2个参数传递给add方法参数,而将需要添加到某个区域的控件作为add方法的第1个参数,如add(组件名称,方位)。可参考下面BorderLayout实例代码:

    import javax.swing.*;
    import java.awt.*;
    
    /**
     * BorderLayout
     * Created by veione on 5/9/16.
     */
    public class BorderLayoutCase {
        private static final int WIDTH = 300;
        private static final int HEIGHT = 200;
    
        public static void main(String[] args) {
            JFrame frame = new JFrame("BorderLayout");
            frame.setSize(WIDTH, HEIGHT);
            frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
            Tools.centerWindow(frame);
    
            JPanel contentPane = new JPanel();
            frame.setContentPane(contentPane);
    
            JButton btnLife = new JButton("生活");
            JButton btnWork = new JButton("工作");
            JButton btnSleep = new JButton("睡觉");
            JButton btnShopping = new JButton("购物");
            JButton btnFood = new JButton("饮食");
    
            //创建一个布局管理器,将中间容器设置为此布局管理器
            BorderLayout borderLayout = new BorderLayout();
            frame.setLayout(borderLayout);
    
            contentPane.add(btnLife, BorderLayout.NORTH);
            contentPane.add(btnWork, BorderLayout.SOUTH);
            contentPane.add(btnSleep, BorderLayout.EAST);
            contentPane.add(btnShopping, BorderLayout.WEST);
            contentPane.add(btnFood, BorderLayout.CENTER);
    
            frame.setVisible(true);
        }
    }

    以上代码运行之后,如下图所示:


    BorderLayout运行结果图

    FlowLayout

    这种布局管理器的策略也非常简单,它是按照控件加入的先后顺序从左到右排列,一行排满了,再换下一行,然后继续从左到右排列。每一行的组件都是居中排列的。另外,如果有些按钮看不到,可以使用pack()自动调整Frame的大小,使得所有控件都显示出来。FlowLayout布局管理器同样是通过先创建对象、再利用其内置方法和变量来布局的组件,下表所示是其构造其说明。


    布局管理器的构造器说明
    FlowLayout()构造一个FlowLayout对象,它是居中对齐的,默认的水平和垂直间隙是5个单位
    FlowLayout(int align)构造一个FlowLayout对象,默认的水平和垂直间隙是5个单位
    FlowLayout(int align,int h, int v)创建一个新的流布局管理器,它具有指定的对其方式以及指定的水平和垂直间隙

    FlowLayout代码示例:

    import javax.swing.*;
    import java.awt.*;
    
    /**
     * Created by veione on 5/9/16.
     */
    public class SpringLayoutCase {
        private static final int WIDTH=300;
        private static final int HEIGHT=200;
    
        public static void main(String[] args) {
            JFrame frame=new JFrame("SpringLayout");
            frame.setSize(WIDTH,HEIGHT);
            Tools.centerWindow(frame);
            frame.setDefaultCloseOperation(Tools.EXIT_ON_CLOSE);
    
            JPanel contentPane=new JPanel();
            frame.setContentPane(contentPane);
            JButton btnLife = new JButton("生活");
            JButton btnWork = new JButton("工作");
            JButton btnSleep = new JButton("睡觉");
            JButton btnShopping = new JButton("购物");
            JButton btnFood = new JButton("饮食");
    
            //设置内容面板布局管理器为FlowLayout
            contentPane.setLayout(new FlowLayout());
            contentPane.add(btnLife);
            contentPane.add(btnWork);
            contentPane.add(btnShopping);
            contentPane.add(btnSleep);
            contentPane.add(btnFood);
    
            frame.pack();
            frame.setVisible(true);
        }
    }

    以上代码运行之后如下图:
    FlowLayout流式布局

    GridLayout

    这种布局管理器有点像围棋盘,它将整个布局控件划分成若干行乘若干列的网格区域。组件就位于这些小的区域内,要想创建一个GridLayout布局管理器,就必须通过其构造器来创建GridLayout布局管理器对象。下面说明下其构造器。


    GridLayout布局管理器的构造器说明
    GridLayout()构造一个组件之间没有间距的新边框布局
    GridLayout(int h,int v)构造一个具有指定组件间距的边框布局,h、v是指行数和列数

    下面通过实例代码来熟悉一下GridLayout布局管理器的使用方法,其代码如下:

    import javax.swing.*;
    import java.awt.*;
    
    /**
     * GridLayout
     * Created by veione on 5/9/16.
     */
    public class GridLayoutCase {
        private static final int WIDTH=300;
        private static final int HEIGHT=200;
    
        public static void main(String[] args) {
            JFrame frame=new JFrame("GridLayout");
            frame.setSize(WIDTH,HEIGHT);
            frame.setDefaultCloseOperation(Tools.EXIT_ON_CLOSE);
            Tools.centerWindow(frame);
    
            //内容面板
            JPanel contentPane=new JPanel();
            frame.setContentPane(contentPane);
            JButton hk=new JButton("港币");
            JButton rmb=new JButton("人民币");
            JButton dollar=new JButton("美元");
            JButton euro=new JButton("欧元");
            JButton pound=new JButton("英镑");
    
            JButton mainBoard=new JButton("主板");
            JButton memory=new JButton("内存");
            JButton hardDisk=new JButton("硬盘");
            JButton monitor=new JButton("显示器");
    
            //创建网格布局管理器对象,指定3行3列
            GridLayout gridLayout=new GridLayout(3,3);
            contentPane.setLayout(gridLayout);
    
            //将控件添加到内容面板中
            contentPane.add(hk);
            contentPane.add(rmb);
            contentPane.add(dollar);
            contentPane.add(euro);
            contentPane.add(pound);
            contentPane.add(mainBoard);
            contentPane.add(memory);
            contentPane.add(hardDisk);
            contentPane.add(monitor);
    
            frame.pack();
            frame.setVisible(true);
        }
    }

    以上代码运行结果如下:
    GridLayout运行示例

    GridBagLayout

    GridBagLayout是一种很先进的、很人性化的布局管理器,通过网格的划分,可以看到每个组件都占据一个网格,也可以一个组件占据几个网格。与GridLayout布局管理器不同的是,GridBagLayout是按照开发人员自己的思路来排列控件位置,而GridLayout布局管理器根据系统的安排来布局。如果要采用网格组布局管理器,一般可采用下列步骤:
    1.创建一个GridBagLayout对象
    2.将容器设成此对象的布局管理器
    3.创建约束(GridBagConstraints)对象
    4.创建各个相应的组件
    5.添加各个组件与约束到网格组布局管理器中

        网格组由多个网格组成,而且各个行或在列的长度和宽度不同。但默认情况下,单元格从左上角开始有序列的编号,从第0行、第0列开始计数。
        当向网格组布局管理器中添加组件时,需要分别定义每个单元格的序列号,只要设定相应的值,那么组件就会添加到网格组布局管理器中。涉及到组件被添加到什么位置有4个参数,即gridX、gridY、gridwidth、gridheight。其中,gridX、gridY分别定义了添加组件时左上角的行与列的位置,而gridwidth、gridheight分别定义了组件所占用的列数和行数。
      网格组布局管理器中每个区域都要设置增量字段(weightx与weighty分别代表x方向和y方向的增量)。如果想让某个区域保持初始化大小,也就是说窗口缩放不会引起组件缩放,那就应该设置该区域的增量为0,相反如果让组件能随时完全填充单元格,那增量字段就应该设置为100。这个布局管理器对象中还涉及到了两个参数,即fill和anchor。
      这两个参数都是非常重要的约束,其中当组件不能填满单元格时,fill参数就可以发挥作用。该约束的值主要有以下几种。
    - GridBagConstraints.NONE:在每一个方向都不填充,即保持原状。
    - GridBagConstraints.HORIZONTAL:只在水平方向上填充。
    - GridBagConstraints.VERTICAL:只在垂直方向上填充。
    - GridBagConstraints.BOTH:在两个方向上都填充。

    而anchor参数则是当一个组件大于分配给它的单元格时发挥作用,该约束就是约定如何处理该组件,它的值如下所示:
    - GridBagConstraints.CENTER:居中缩小。
    - GridBagConstraints.NORTH:顶部缩小。
    - GridBagConstraints.NORTHEAST:左上角缩小。
    - GridBagConstraints.EAST:右侧缩小。


    GridBagLayout布局管理器的构造器只有一种,就是不带参数的构造器。下面通过代码认识下该布局管理器。

    import javax.swing.*;
    import java.awt.*;
    
    /**
     * GridBagLayout
     * Created by veione on 5/9/16.
     */
    public class GridBagLayoutCase extends JPanel{
        private static final int WIDTH=300;
        private static final int HEIGHT=200;
    
        JFrame loginFrame;
    
        public void add(Component c,GridBagConstraints constraints,int x,int y,int w,int h){
            constraints.gridx=x;
            constraints.gridy=y;
            constraints.gridwidth=w;
            constraints.gridheight=h;
            add(c,constraints);
        }
    
        public GridBagLayoutCase(){
            //设置顶层容器
            loginFrame=new JFrame("信息管理系统");
            loginFrame.setDefaultCloseOperation(Tools.EXIT_ON_CLOSE);
    
            //创建网格组布局方式对象
            GridBagLayout layout=new GridBagLayout();
            setLayout(layout);
            loginFrame.add(this,BorderLayout.WEST);
            loginFrame.setSize(WIDTH,HEIGHT);
            Tools.centerWindow(loginFrame);
    
            JButton btnOk=new JButton("确认");
            JButton btnCancel=new JButton("取消");
            JLabel lblTitle=new JLabel("用户登录");
            JLabel lblName=new JLabel("用户名");
            JLabel lblPwd=new JLabel("密码");
            JTextField txtName=new JTextField(15);
            JPasswordField txtPwd=new JPasswordField(15);
    
            //创建约束对象
            GridBagConstraints constraints=new GridBagConstraints();
            constraints.fill=GridBagConstraints.NONE;
            constraints.anchor=GridBagConstraints.EAST;
            constraints.weightx=3;
            constraints.weighty=4;
    
            add(lblTitle,constraints,0,0,3,1);
            add(lblName,constraints,0,1,1,1);
            add(lblPwd,constraints,0,2,1,1);
            add(txtName,constraints,2,1,1,1);
            add(txtPwd,constraints,2,2,1,1);
            add(btnOk,constraints,0,3,1,1);
            add(btnCancel,constraints,2,3,1,1);
    
            loginFrame.setResizable(false);
            loginFrame.setVisible(true);
    
        }
    
        public static void main(String[] args) {
            new GridBagLayoutCase();
        }
    }

    以上代码运行结果如下:
    GridBagLayout结果示例

    CardLayout

    CardLayout布局管理器非常简单,它将容器中的每一个组件当作一个卡片,一次仅有一个卡片可见,如最初显示容器时,CardLayout对象的第一个组件可见,其它组件都是不可见的。下面将以表格形式给出CardLayout布局管理器的构造器。


    CardLayout布局管理器的构造器说明
    CardLayout()构造一个间距大小为0的新卡片布局
    CardLayout(int h,int v)构造一个卡片布局管理器,其中h和v分别为卡片间水平和垂直方向上的空白空间

    在这个布局管理器中还有一些常用方法,说明如下:

    GridLayout布局管理器常用方法说明
    public void first(Container parent)移到指定容器的第一个卡片
    public void next(Container parent)移到指定容器的下一个卡片
    public void previous(Container parent)移到指定容器的前一个卡片
    public void last(Container parent)移到指定容器的最后一个卡片
    public void show(Container parent,String name)显示指定卡片

    下面通过代码实例来熟悉下它的使用:

    import javax.swing.*;
    import java.awt.*;
    import java.awt.event.ActionEvent;
    import java.awt.event.ActionListener;
    
    /**
     * CardLayout
     * Created by veione on 5/9/16.
     */
    public class CardLayoutCase extends JFrame{
        //主要的JPanel,该JPanel的布局管理器将被设置成CardLayout
        private JPanel pane=null;
        private JPanel btnPanel=null;
        private CardLayout cardLayout=null;
        private JButton btnPrevious=null;
        private JButton btnNext=null;
        private JButton btnDot1=null;
        private JButton btnDot2=null;
        private JButton btnDot3=null;
        private JPanel panel1,panel2,panel3;
    
        public CardLayoutCase(){
            super("CardLayout");
            cardLayout=new CardLayout(5,5);
            pane=new JPanel(cardLayout);
            btnPrevious=new JButton("< 上一步");
            btnNext=new JButton("下一步 >");
            btnDot1=new JButton("1");
            btnDot2=new JButton("2");
            btnDot3=new JButton("3");
            btnDot3.setMargin(new Insets(2,2,2,2));
            btnDot2.setMargin(new Insets(2,2,2,2));
            btnDot1.setMargin(new Insets(2,2,2,2));
    
            //构造放按钮的面板容器
            btnPanel=new JPanel();
            btnPanel.add(btnPrevious);
            btnPanel.add(btnDot1);
            btnPanel.add(btnDot2);
            btnPanel.add(btnDot3);
            btnPanel.add(btnNext);
    
            //显示的面板1-2-3
            panel1=new JPanel();
            panel2=new JPanel();
            panel3=new JPanel();
            panel1.setBackground(Color.red);
            panel2.setBackground(Color.cyan);
            panel3.setBackground(Color.green);
            panel1.add(new JLabel("面板1"));
            panel2.add(new JLabel("面板2"));
            panel3.add(new JLabel("面板3"));
    
            //将3个面板添加到上层容器中
            pane.add(panel1,"panel1");
            pane.add(panel2,"panel2");
            pane.add(panel3,"panel3");
    
            //给按钮添加事件
            btnPrevious.addActionListener(new ActionListener() {
                public void actionPerformed(ActionEvent e) {
                    cardLayout.previous(pane);
                }
            });
            btnNext.addActionListener(new ActionListener() {
                public void actionPerformed(ActionEvent e) {
                    cardLayout.next(pane);
                }
            });
            btnDot1.addActionListener(new ActionListener() {
                public void actionPerformed(ActionEvent e) {
                    cardLayout.show(pane,"panel1");
                }
            });
            btnDot2.addActionListener(new ActionListener() {
                public void actionPerformed(ActionEvent e) {
                    cardLayout.show(pane,"panel2");
                }
            });
            btnDot3.addActionListener(new ActionListener() {
                public void actionPerformed(ActionEvent e) {
                    cardLayout.show(pane,"panel3");
                }
            });
    
            this.getContentPane().add(pane);
            this.getContentPane().add(btnPanel,BorderLayout.SOUTH);
            setDefaultCloseOperation(Tools.EXIT_ON_CLOSE);
            setSize(300,200);
            Tools.centerWindow(this);
            setVisible(true);
        }
    
        public static void main(String[] args) {
            new CardLayoutCase();
        }
    }

    BoxLayout

    箱式布局比较灵活,也比较使用。Swing提供的BOX类就是箱式布局类,它的默认布局管理器就是BoxLayout,在箱式布局管理器中包括两种箱子:一种是水平箱,另外一种是垂直箱。
    创建一个水平箱的代码如下:
    Box horBox=Box.createHorizontalBox()
    创建一个垂直箱的代码如下:
    Box verBox=Box.createVerticalBox()
    创建好箱子后,就可以像添加其它组件一样添加下面的控件,代码如下:
    horBox.add(okBtn);
    verBox.add(cancelBtn);

    两种箱子的区别在于组件的排列顺序,水平箱是按照从左到右的顺序排列,而垂直箱按照从上到下的顺序排列。对于箱式布局管理器而言,最关键的就是每个组件的3个尺寸。

    • 首选尺寸,即组件显示时的宽度和高度。
    • 最大尺寸,即组件能被显示的最大宽度和高度
    • 最小尺寸,即组件被显示的最小高度和最小宽度

    下面是水平箱式布局管理器中组件排列的几个重点:

    • 计算最高组件的最大高度,尝试把所有的组件都增加到这个高度,如果有某些组件不能达到此高度,那么要在Y轴上对齐需要通过getAlignmentY方法实现,该方法返回一个介于0(按顶部对齐)和1(按底部对器)之间的浮点数。组件的默认值是0.5,也就是中线对齐。
    • 得到每个组件的首选宽度,然后把所有的首选宽度合计起来。
    • 如果首选宽度总和小于箱的宽度,那么所有的组件都会相应的延伸,直到适应这个箱子的宽度。组件从左到右排列,并且相邻两个组件之间没有多余的空格。

      箱式布局组件之间没有空隙,那么就要通过一个称为填充物的组件来提供空隙。箱式布局管理器提供了3种填充物:支柱、固定区、弹簧。下面将通过代码来说明给布局管理器:

    import javax.swing.*;
    import java.awt.*;
    
    /**
     * BoxLayout
     * Created by veione on 5/9/16.
     */
    public class BoxLayoutCase extends JFrame{
        private static final int WIDTH=300;
        private static final int HEIGHT=200;
    
        public BoxLayoutCase(){
            setTitle("BoxLayout");
            setSize(WIDTH,HEIGHT);
            Container con=getContentPane();
            JLabel label=new JLabel("姓名:");
            JTextField txtField=new JTextField(10);
            txtField.setMaximumSize(txtField.getPreferredSize());
    
            //创建一个水平箱子
            Box horBox=Box.createHorizontalBox();
            horBox.add(label);
    
            //在水平箱子上添加一个标签组件,并且创建一个不可见的20个单位的组件
            //在这之后再添加一个文本框组件
            horBox.add(Box.createHorizontalStrut(20));
            horBox.add(txtField);
    
            JLabel labelPwd=new JLabel("密码:");
            JPasswordField txtPwd=new JPasswordField(10);
            txtPwd.setMaximumSize(txtPwd.getPreferredSize());
    
            //创建一个水平箱子
            Box pwdHorBox=Box.createHorizontalBox();
            pwdHorBox.add(labelPwd);
            pwdHorBox.add(Box.createHorizontalStrut(20));
            pwdHorBox.add(txtPwd);
    
            JButton btnOk=new JButton("确定");
            JButton btnCancel=new JButton("取消");
    
            //创建一个水平箱子
            Box btnHorBox=Box.createHorizontalBox();
            btnHorBox.add(btnOk);
            btnHorBox.add(Box.createHorizontalStrut(20));
            btnHorBox.add(btnCancel);
    
            //创建一个垂直箱子将水平箱子放入到垂直箱子种
            Box vBox=Box.createVerticalBox();
            vBox.add(horBox);;
            vBox.add(pwdHorBox);
            vBox.add(btnHorBox);
    
            con.add(vBox,BorderLayout.CENTER);
    
            Tools.centerWindow(this);
            setVisible(true);
        }
    
        public static void main(String[] args) {
            new BoxLayoutCase();
        }
    }

    以上代码运行结果为:
    BoxLayout代码运行结果

    SpringLayout

    SpringLayout布局管理器是通过定义组件的边沿距离来实现布局的。边界之间的距离是使用Spring对象来表示的。每一个Spring对象具有4个属性值,包括minimum、maximum、preferred、value,其中value表示的是真实的值。
    在在这个管理器中,涉及到如下几个常量:

    • EAST:指定组件的边界矩形的右边。
    • NORTH:指定组件的边界矩形的顶边。
    • SOUTH:指定组件的边界矩形的底边。
    • WEST:指定组件的边界矩形的左边。
      在布局的时候,经常会用到下面的方法:
      void putConstraint(Stirng e1,int pad,String e2,Component c2);
      下面针对该布局管理器用代码来实际看看:
    import javax.swing.*;
    
    /**
     * SpringLayout
     * Created by veione on 5/9/16.
     */
    public class SpringLayoutDemo {
        private static final int WIDTH=300;
        private static final int HEIGHT=200;
    
        public static void main(String[] args) {
            JFrame frame=new JFrame("SpringLayout");
            frame.setVisible(true);
            frame.setSize(WIDTH,HEIGHT);
            Tools.centerWindow(frame);
            JPanel contentPane=new JPanel();
            frame.setContentPane(contentPane);
    
            JButton btnLoad=new JButton("加载");
            JButton btnTest=new JButton("测试");
            JLabel label=new JLabel("测试程序");
    
            contentPane.add(label);
            contentPane.add(btnLoad);
            contentPane.add(btnTest);
    
            //创建一个SpringLayout布局管理器,并且将之作为中间容器的布局方式
            SpringLayout springLayout=new SpringLayout();
            contentPane.setLayout(springLayout);
    
            //针对每个组件设置其与边界的距离
            springLayout.putConstraint(SpringLayout.NORTH,label,5,SpringLayout.NORTH,contentPane);
            springLayout.putConstraint(SpringLayout.WEST,label,85,SpringLayout.WEST,contentPane);
            springLayout.putConstraint(SpringLayout.EAST,label,5,SpringLayout.EAST,contentPane);
    
            springLayout.putConstraint(SpringLayout.NORTH,btnLoad,55,SpringLayout.NORTH,contentPane);
            springLayout.putConstraint(SpringLayout.WEST,btnLoad,5,SpringLayout.WEST,contentPane);
            springLayout.putConstraint(SpringLayout.EAST,btnLoad,25,SpringLayout.EAST,contentPane);
    
            springLayout.putConstraint(SpringLayout.NORTH,btnTest,105,SpringLayout.NORTH,contentPane);
            springLayout.putConstraint(SpringLayout.WEST,btnTest,5,SpringLayout.WEST,contentPane);
            springLayout.putConstraint(SpringLayout.EAST,btnTest,25,SpringLayout.EAST,contentPane);
    
            frame.setVisible(true);
        }
    }

    运行结果如下:
    SpringLayout

    GroupLayout

    从GroupLayout的单词意思来看,它是以Group(组)为单位来管理布局,也就是把多个组件(如:JLabel、JButton)按区域划分到不同的Group(组),再根据各个Group(组)相对于水平轴(Horizontal)和垂直轴(Vertical)的排列方式来管理。
    下面通过代码来熟悉下它的使用:

    
    import javax.swing.*;
    import java.awt.*;
    
    /**
     * GroupLayout
     * Created by veione on 5/9/16.
     */
    public class GroupLayoutCase extends JFrame{
    
        public GroupLayoutCase(){
            //创建一个中间容器,并且创建一个GroupLayout布局管理器对象
            Container c=getContentPane();
            GroupLayout layout=new GroupLayout(c);
            //创建两个普通按钮组件,文本框组件
            JButton btn1=new JButton("按钮1");
            JButton btn2=new JButton("按钮2");
            JTextField text=new JTextField("吻鳄不能");
    
            //创建一个hsg组,将两个按钮以一个一个的添加到组里面
            GroupLayout.SequentialGroup hsg=layout.createSequentialGroup();
            hsg.addComponent(btn1);
            hsg.addComponent(btn2);
    
            GroupLayout.ParallelGroup hpg=layout.createParallelGroup(GroupLayout.Alignment.CENTER);
    
            //创建一个hpg组,将文本框组件和上面的那个组添加到其中,并且将之剧中排列
            hpg.addComponent(text).addGroup(hsg);
            layout.setHorizontalGroup(hpg);
    
            GroupLayout.ParallelGroup vpg=layout.createParallelGroup();
    
            vpg.addComponent(btn1);
            vpg.addComponent(btn2);
    
            GroupLayout.SequentialGroup vsg=layout.createSequentialGroup();
    
            vsg.addComponent(text).addGroup(vpg);
            layout.setVerticalGroup(vsg);
            setLayout(layout);
            setDefaultCloseOperation(Tools.EXIT_ON_CLOSE);
            pack();
            setVisible(true);
        }
    
        public static void main(String[] args) {
            new GroupLayoutCase();
        }
    }

    运行结果如下:
    GroupLayout

    好了,Java布局管理器到此为止!

    展开全文
  • 主要介绍了Java编程使用箱式布局管理器,结合实例形式分析了基于swing组件的箱式布局管理器定义与使用技巧,需要的朋友可以参考下
  • 主要介绍了Java卡片布局管理器解释及实例,需要的朋友可以参考下。
  • Java Swing布局管理器

    万次阅读 多人点赞 2019-03-05 01:33:35
    引言 在使用 Swing 向容器...为了加快开发速度,Java 提供了一些布局管理器,它们可以将组件进行统一管理,这样开发人员就不需要考虑组件是否会重叠等问题。本文绍 Swing 提供的 6 种布局类型,所有布局都实现 La...

    引言

    在使用 Swing 向容器添加组件时,需要考虑组件的位置和大小。如果不使用布局管理器,则需要先在纸上画好各个组件的位置并计算组件间的距离,再向容器中添加。这样虽然能够灵活控制组件的位置,实现却非常麻烦。
    为了加快开发速度,Java 提供了一些布局管理器,它们可以将组件进行统一管理,这样开发人员就不需要考虑组件是否会重叠等问题。本文绍 Swing 提供的 8 种布局类型,所有布局都实现 LayoutManager 接口。

    一、绝对布局

    1.1 边框布局管理器(BorderLayout)

    BorderLayout(边框布局管理器)是 Window、JFrame 和 JDialog 的默认布局管理器。边框布局管理器将窗口分为 5 个区域:North、South、East、West 和 Center。其中,North 表示北,将占据面板的上方;Soufe 表示南,将占据面板的下方;East表示东,将占据面板的右侧;West 表示西,将占据面板的左侧;中间区域 Center 是在东、南、西、北都填满后剩下的区域,如图 所示:
    在这里插入图片描述
    提示:边框布局管理器并不要求所有区域都必须有组件,如果四周的区域(North、South、East 和 West 区域)没有组件,则由 Center 区域去补充。如果单个区域中添加的不只一个组件,那么后来添加的组件将覆盖原来的组件,所以,区域中只显示最后添加的一个组件。

    1.2 BorderLayout 布局管理器的构造方法

    BorderLayout()
    创建一个 Border 布局,组件之间没有间隙。
    BorderLayout(int hgap,int vgap)
    创建一个 Border 布局,其中 hgap 表示组件之间的横向间隔;vgap 表示组件之间的纵向间隔,单位是像素。
    

    1.3 示例

    使用 BorderLayout 将窗口分割为 5 个区域,并在每个区域添加一个标签按钮。实现代码如下:

    import javax.swing.*;
    import java.awt.*;
    
    public class BorderLayoutDemo {
        public static void main(String[] agrs) {
            JFrame frame=new JFrame("BorderLayoutDemo");    //创建Frame窗口
            frame.setSize(400,200);
    
            frame.setLayout(new BorderLayout());    //为Frame窗口设置布局为BorderLayout
            
            JButton button1=new JButton ("上");
            JButton button2=new JButton("左");
            JButton button3=new JButton("中");
            JButton button4=new JButton("右");
            JButton button5=new JButton("下");
            
            frame.add(button1,BorderLayout.NORTH);
            frame.add(button2,BorderLayout.WEST);
            frame.add(button3,BorderLayout.CENTER);
            frame.add(button4,BorderLayout.EAST);
            frame.add(button5,BorderLayout.SOUTH);
            
            frame.setBounds(300,200,600,300);
            frame.setVisible(true);
            frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        }
    }
    

    运行效果如下:
    在这里插入图片描述

    二、流式布局管理器(FlowLayout)

    2.1 FlowLayout

    FlowLayout(流式布局管理器)是 JPanel 和 JApplet 的默认布局管理器。FlowLayout 会将组件按照从从左到右、上到下的放置规律逐行进行定位。与其他布局管理器不同的是,FlowLayout 布局管理器不限制它所管理组件的大小,而是允许它们有自己的最佳大小。

    2.2 FlowLayout 布局管理器的构造方法

    FlowLayout():创建一个布局管理器,使用默认的居中对齐方式和默认 5 像素的水平和垂直间隔。
    FlowLayout(int align):创建一个布局管理器,使用默认 5 像素的水平和垂直间隔。其中,align 表示组件的对齐方式,对齐的值必须是 FlowLayout.LEFT、FlowLayout.RIGHT 和 FlowLayout.CENTER,指定组件在这一行的位置是居左对齐、居右对齐或居中对齐。
    FlowLayout(int align, int hgap,int vgap):创建一个布局管理器,其中 align 表示组件的对齐方式;hgap 表示组件之间的横向间隔;vgap 表示组件之间的纵向间隔,单位是像素。
    

    2.3 示例

    使用 FlowLayout 类对窗口进行布局,向容器内添加 9 个按钮,并设置横向和纵向的间隔都为 20 像素。具体实现代码如下:

    import javax.swing.*;
    import java.awt.*;
    
    public class FlowLayoutDemo {
        public static void main(String[] agrs)  {
            JFrame jFrame=new JFrame("FlowLayoutDemo");    //创建Frame窗口
    
            JPanel jPanel=new JPanel();    //创建面板
            JButton btn1=new JButton("1");    //创建按钮
            JButton btn2=new JButton("2");
            JButton btn3=new JButton("3");
            JButton btn4=new JButton("4");
            JButton btn5=new JButton("5");
            JButton btn6=new JButton("6");
            JButton btn7=new JButton("7");
            JButton btn8=new JButton("8");
            JButton btn9=new JButton("9");
    
            jPanel.add(btn1);    //面板中添加按钮
            jPanel.add(btn2);
            jPanel.add(btn3);
            jPanel.add(btn4);
            jPanel.add(btn5);
            jPanel.add(btn6);
            jPanel.add(btn7);
            jPanel.add(btn8);
            jPanel.add(btn9);
    
            //向JPanel添加FlowLayout布局管理器,将组件间的横向和纵向间隙都设置为20像素
            jPanel.setLayout(new FlowLayout(FlowLayout.LEADING,20,20));
            jPanel.setBackground(Color.gray);    //设置背景色
            jFrame.add(jPanel);    //添加面板到容器
            jFrame.setBounds(300,200,300,150);    //设置容器的大小
            jFrame.setVisible(true);
            jFrame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        }
    }
    

    上述程序向 JPanel 面板中添加了 9 个按钮,并使用 FlowLayout 布局管理器使 9 个按钮间的横向和纵向间隙都为 20 像素。此时这些按钮将在容器上按照从上到下、从左到右的顺序排列,如果一行剩余空间不足容纳组件将会换行显示,最终运行结果如图 所示:
    在这里插入图片描述
    在这里插入图片描述

    三、卡片布局管理器(CardLayout)

    3.1 CardLayout

    CardLayout(卡片布局管理器)能够帮助用户实现多个成员共享同一个显示空间,并且一次只显示一个容器组件的内容。
    CardLayout 布局管理器将容器分成许多层,每层的显示空间占据整个容器的大小,但是每层只允许放置一个组件。

    3.2 CardLayout 的构造方法

    CardLayout():构造一个新布局,默认间隔为 0CardLayout(int hgap, int vgap):创建布局管理器,并指定组件间的水平间隔(hgap)和垂直间隔(vgap)。
    

    3.3 示例

    使用 CardLayout 类对容器内的两个面板进行布局。其中第一个面板上包括三个按钮,第二个面板上包括三个文本框。最后调用 CardLayout 类的 show() 方法显示指定面板的内容,代码如下:

    import javax.swing.*;
    import java.awt.*;
    
    public class CardLayoutDemo {
        public static void main(String[] agrs) {
            JFrame frame=new JFrame("CardLayoutDemo");    //创建Frame窗口
    
            JPanel p1=new JPanel();    //面板1
            JPanel p2=new JPanel();    //面板2
            JPanel cards=new JPanel(new CardLayout());    //卡片式布局的面板
    
            p1.add(new JButton("登录按钮"));
            p1.add(new JButton("注册按钮"));
            p1.add(new JButton("找回密码按钮"));
    
            p2.add(new JTextField("用户名文本框",20));
            p2.add(new JTextField("密码文本框",20));
            p2.add(new JTextField("验证码文本框",20));
    
            cards.add(p1,"card1");    //向卡片式布局面板中添加面板1
            cards.add(p2,"card2");    //向卡片式布局面板中添加面板2
    
            CardLayout cl=(CardLayout)(cards.getLayout());
            cl.show(cards,"card1");    //调用show()方法显示面板2
    
            frame.add(cards);
            frame.setBounds(300,200,400,200);
            frame.setVisible(true);
            frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        }
    }
    

    上述代码创建了一个卡片式布局的面板 cards,该面板包含两个大小相同的子面板 p1 和 p2。需要注意的是,在将 p1 和 p2 添加到 cards 面板中时使用了含有两个参数的 add() 方法,该方法的第二个参数用来标识子面板。当需要显示某一个面板时,只需要调用卡片式布局管理器的 show() 方法,并在参数中指定子面板所对应的字符串即可,这里显示的是 p1 面板,运行效果如图 所示:

    在这里插入图片描述

    如果将“cl.show(cards,“card1”)”语句中的 card1 换成 card2,将显示 p2 面板的内容,此时运行结果如图 所示:
    在这里插入图片描述

    四、网格布局管理器(GridLayout)

    4.1 GridLayout

    GridLayout(网格布局管理器)为组件的放置位置提供了更大的灵活性。它将区域分割成行数(rows)和列数(columns)的网格状布局,组件按照由左至右、由上而下的次序排列填充到各个单元格中。
    提示:GridLayout 布局管理器总是忽略组件的最佳大小,而是根据提供的行和列进行平分。该布局管理的所有单元格的宽度和高度都是一样的。

    4.2 GridLayout 的构造方法

    GridLayout(int rows,int cols):创建一个指定行(rows)和列(cols)的网格布局。布局中所有组件的大小一样,组件之间没有间隔。
    GridLayout(int rows,int cols,int hgap,int vgap):创建一个指定行(rows)和列(cols)的网格布局,并且可以指定组件之间横向(hgap)和纵向(vgap)的间隔,单位是像素。
    

    4.3 示例

    使用 GridLayout 类的网格布局设计一个简单计算器。代码的实现如下:

    import javax.swing.*;
    import java.awt.*;
    
    public class GridLayoutDemo {
        public static void main(String[] args) {
            JFrame frame=new JFrame("GridLayou布局计算器");
            
            JPanel panel=new JPanel();    //创建面板
            //指定面板的布局为GridLayout,4行4列,间隙为5
            panel.setLayout(new GridLayout(4,4,5,5));
            panel.add(new JButton("7"));    //添加按钮
            panel.add(new JButton("8"));
            panel.add(new JButton("9"));
            panel.add(new JButton("/"));
            panel.add(new JButton("4"));
            panel.add(new JButton("5"));
            panel.add(new JButton("6"));
            panel.add(new JButton("*"));
            panel.add(new JButton("1"));
            panel.add(new JButton("2"));
            panel.add(new JButton("3"));
            panel.add(new JButton("-"));
            panel.add(new JButton("0"));
            panel.add(new JButton("."));
            panel.add(new JButton("="));
            panel.add(new JButton("+"));
            
            frame.add(panel);    //添加面板到容器
            frame.setBounds(300,200,200,150);
            frame.setVisible(true);
            frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        }
    }
    

    上述程序设置面板为 4 行 4 列、间隙都为 5 像素的网格布局,在该面板上包含 16 个按钮,其横向和纵向的间隙都为 5。该程序的运行结果如图所示:

    在这里插入图片描述

    五、网格包布局管理器(GridBagLayout)

    5.1 GridBagLayout

    GridBagLayout(网格包布局管理器)是在网格基础上提供复杂的布局,是最灵活、 最复杂的布局管理器。GridBagLayout 不需要组件的尺寸一致,允许组件扩展到多行多列。每个 GridBagLayout 对象都维护了一组动态的矩形网格单元,每个组件占一个或多个单元,所占有的网格单元称为组件的显示区域。
    GridBagLayout 所管理的每个组件都与一个 GridBagConstraints 约束类的对象相关。这个约束类对象指定了组件的显示区域在网格中的位置,以及在其显示区域中应该如何摆放组件。除了组件的约束对象,GridBagLayout 还要考虑每个组件的最小和首选尺寸,以确定组件的大小。

    5.2 GridBagLayout属性设置

    为了有效地利用网格包布局管理器,在向容器中添加组件时,必须定制某些组件的相关约束对象。GridBagConstraints 对象的定制是通过下列变量实现的。

    • 1.gridx 和 gridy

    用来指定组件左上角在网格中的行和列。容器中最左边列的 gridx 为 0,最上边行的 gridy 为 0。这两个变量的默认值是GridBagConstraints.RELATIVE,表示对应的组件将放在前一个组件的右边或下面。

    • 2.gridwidth 和 gridheight

    用来指定组件显示区域所占的列数和行数,以网格单元而不是像素为单位,默认值为 1。

    • 3.fill

    指定组件填充网格的方式,可以是如下值:GridBagConstraints.NONE(默认值)、GridBagConstraints.HORIZONTAL(组件横向充满显示区域,但是不改变组件高度)、GridBagConstraints.VERTICAL(组件纵向充满显示区域,但是不改变组件宽度)以及 GridBagConstraints.BOTH(组件横向、纵向充满其显示区域)。

    • 4.ipadx 和 ipady

    指定组件显示区域的内部填充,即在组件最小尺寸之外需要附加的像素数,默认值为 0。

    • 5.insets

    指定组件显示区域的外部填充,即组件与其显示区域边缘之间的空间, 默认组件没有外部填充。

    • 6.anchor

    指定组件在显示区域中的摆放位置。可选值有 GridBagConstraints.CENTER(默认值)、GridBagConstraints.NORTH、GridBagConstraints.NORTHEAST、GridBagConstraints.EAST、GridBagConstraints.SOUTH、GridBagConstraints.SOUTHEAST、GridBagConstraints.WEST、GridBagConstraints.SOUTHWEST 以及 GridBagConstraints.NORTHWEST。

    • 7.weightx 和 weighty

    用来指定在容器大小改变时,增加或减少的空间如何在组件间分配,默认值为 0,即所有的组件将聚拢在容器的中心,多余的空间将放在容器边缘与网格单元之间。weightx 和 weighty 的取值一般在 0.0 与 1.0 之间,数值大表明组件所在的行或者列将获得更多的空间。

    5.3 示例

    创建一个窗口,使用 GridBagLayout 进行布局,实现一个简易的手机拨号盘。这里要注意如何控制行内组件的显示方式以及使用 GridBagConstraints.REMAINDER 来控制一行的结束。代码的实现如下:

    import javax.swing.*;
    import java.awt.*;
    
    public class GridBagLayoutDemo {
    
        //向JFrame中添加JButton按钮
        public static void makeButton(String title,JFrame frame,GridBagLayout gridBagLayout,GridBagConstraints constraints) {
            JButton button=new JButton(title);    //创建Button对象
            gridBagLayout.setConstraints(button,constraints);
            frame.add(button);
        }
        public static void main(String[] agrs) {
            JFrame frame=new JFrame("拨号盘");
            GridBagLayout gbaglayout=new GridBagLayout();    //创建GridBagLayout布局管理器
            GridBagConstraints constraints=new GridBagConstraints();
            frame.setLayout(gbaglayout);    //使用GridBagLayout布局管理器
            constraints.fill = GridBagConstraints.BOTH;    //组件填充显示区域
            constraints.weightx=0.0;    //恢复默认值
            constraints.gridwidth = GridBagConstraints.REMAINDER;    //结束行
            JTextField tf=new JTextField("13612345678");
            gbaglayout.setConstraints(tf, constraints);
            frame.add(tf);
            constraints.weightx=0.5;    // 指定组件的分配区域
            constraints.weighty=0.2;
            constraints.gridwidth=1;
            makeButton("7",frame,gbaglayout,constraints);    //调用方法,添加按钮组件
            makeButton("8",frame,gbaglayout,constraints);
            constraints.gridwidth=GridBagConstraints.REMAINDER;    //结束行
            makeButton("9",frame,gbaglayout,constraints);
            constraints.gridwidth=1;    //重新设置gridwidth的值
    
            makeButton("4",frame,gbaglayout,constraints);
            makeButton("5",frame,gbaglayout,constraints);
            constraints.gridwidth=GridBagConstraints.REMAINDER;
            makeButton("6",frame,gbaglayout,constraints);
            constraints.gridwidth=1;
    
            makeButton("1",frame,gbaglayout,constraints);
            makeButton("2",frame,gbaglayout,constraints);
            constraints.gridwidth=GridBagConstraints.REMAINDER;
            makeButton("3",frame,gbaglayout,constraints);
            constraints.gridwidth=1;
    
            makeButton("返回",frame,gbaglayout,constraints);
            constraints.gridwidth=GridBagConstraints.REMAINDER;
            makeButton("拨号",frame,gbaglayout,constraints);
            constraints.gridwidth=1;
            frame.setBounds(400,400,400,400);    //设置容器大小
            frame.setVisible(true);
            frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        }
    }
    

    在上述程序中创建了一个 makeButton() 方法,用来将 JButton 组件添加到 JFrame 窗口中。在 main() 方法中分别创建了 GridBagLayout 对象和 GridBagConstraints 对象,然后设置 JFrame 窗口的布局为 GridBagLayout,并设置了 GridBagConstraints 的一些属性。接着将 JTextField 组件添加至窗口中,并通知布局管理器的 GridBagConstraints 信息。
    在接下来的代码中,调用 makeButton() 方法向 JFrame 窗口填充按钮,并使用 GridBagConstraints. REMAINDER 来控制结束行。当一行结束后,重新设置 GridBagConstraints 对象的 gridwidth 为 1。最后设置 JFrame 窗口为可见状态,程序运行后的拨号盘效果如图所示:
    在这里插入图片描述

    六、盒布局管理器(BoxLayout)

    6.1 BoxLayout

    BoxLayout(盒布局管理器)通常和 Box 容器联合使用。

    6.2 BoxLayout构造函数

    BoxLayout(Container c,int axis)
    

    其中,参数 Container 是一个容器对象,即该布局管理器在哪个容器中使用;第二个参数为 int 型,用来决定容器上的组件水平(X_AXIS)或垂直(Y_AXIS)放置,可以使用 BoxLayout 类访问这两个属性。

    6.3 Box相关方法

    createHorizontalBox():返回一个 Box 对象,它采用水平 BoxLayout,即 BoxLayout 沿着水平方向放置组件,让组件在容器内从左到右排列。
    createVerticalBox():返回一个 Box 对象,它采用垂直 BoxLayout,即 BoxLayout 沿着垂直方向放置组件,让组件在容器内从上到下进行排列。
    static Component createHorizontalGlue()	创建一个不可见的、可以被水平拉伸和收缩的组件
    static Component createVerticalGlue()	创建一个不可见的、可以被垂直拉伸和收缩的组件
    static Component createHorizontalStrut(int width)	创建一个不可见的、固定宽度的组件
    static Component createVerticalStrut(int height)	创建一个不可见的、固定高度的组件
    static Component createRigidArea(Dimension d)	创建一个不可见的、总是具有指定大小的组件
    

    6.4 示例

    使用 BoxLayout 类对容器内的 4 个按钮进行布局管理,使两个按钮为横向排列,另外两个按钮为纵向排列,代码如下:

    import javax.swing.*;
    import java.awt.*;
    
    public class BoxLayoutDemo {
        public static void main(String[] agrs) {
            JFrame frame=new JFrame("Java示例程序");
            
            Box b1=Box.createHorizontalBox();    //创建横向Box容器
            Box b2=Box.createVerticalBox();    //创建纵向Box容器
            frame.add(b1);    //将外层横向Box添加进窗体
            
            b1.add(Box.createVerticalStrut(200));    //添加高度为200的垂直框架
            b1.add(new JButton("西"));    //添加按钮1
            b1.add(Box.createHorizontalStrut(140));    //添加长度为140的水平框架
            b1.add(new JButton("东"));    //添加按钮2
            b1.add(Box.createHorizontalGlue());    //添加水平胶水
            b1.add(b2);    //添加嵌套的纵向Box容器
            
            //添加宽度为100,高度为20的固定区域
            b2.add(Box.createRigidArea(new Dimension(100,20)));
            b2.add(new JButton("北"));    //添加按钮3
            b2.add(Box.createVerticalGlue());    //添加垂直组件
            b2.add(new JButton("南"));    //添加按钮4
            b2.add(Box.createVerticalStrut(40));    //添加长度为40的垂直框架
            
            //设置窗口的关闭动作、标题、大小位置以及可见性等
            frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
            frame.setBounds(100,100,400,200);
            frame.setVisible(true);
        }
    }
    

    在程序中创建了 4 个 JButton 按钮和两个 Box 容器(横向 Box 容器和纵向 Box 容器),并将前两个 JButton 按钮添加到横向 Box 容器中,将后两个 JButton 容器添加到纵向 Box 容器中。程序的运行结果如图 所示:
    在这里插入图片描述

    七、绝对布局

    在Swing中,除了使用布局管理器之外还可以使用绝对布局。绝对布局,就是硬性指定组件在容 器中的位置和大小,可以使用绝对坐标的方式来指定组件的位置。

    7.1 使用步骤

    使用绝对布局的步骤如下:

    • 使用Container.setLayout(null)方法取消布局管理器。
    • 使用Component.setBounds()方法设置每个组件的大小与位置。

    7.2 示例:

    import javax.swing.*;
    import java.awt.*;
    
    public class AbsolutePosition extends JFrame {
    
        public AbsolutePosition() {
            setTitle("AbsolutePosition");
            setLayout(null);
            setBounds(0, 0, 200, 150);
    
            Container c = getContentPane();
            JButton b1 = new JButton("按钮1");
            JButton b2 = new JButton("按钮2");
    
            b1.setBounds(10, 30, 80, 30);
            b2.setBounds(60, 70, 100, 20);
            c.add(b1);
            c.add(b2);
            setVisible(true);
    
            setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
        }
    
        public static void main(String[] args) {
            AbsolutePosition absolutePosition = new AbsolutePosition();
        }
    }
    

    运行效果如下:
    在这里插入图片描述

    八、弹簧布局管理器(SpringLayout)

    8.1 SpringLayout

    由 SpringLayout 类实现的布局管理器称为弹簧布局管理器。利用该布局管理器管理组件,当改变窗体的大小时,能够在不改变组件间相对位置的前提下自动调整组件大小,使组件依旧布满整个窗体,从而保证了窗体的整体效果。

    8.2 putConstraint(String e1,Conponet c1,int pad,String e2,Componet c2)

    弹簧布局管理器以容器和组件的边缘为操作对象,通过为组件和容器边缘以及组件和组件边缘建立约束,实现对组件布局的管理。通过方法 putConstraint(String e1,Conponet c1,int pad,String e2,Componet c2)可以为各边之间建立约束,该方法的入口参数说明如下:

    • c1:需要参考的组件对象;
    • c2:需要参考的组件对象的具体需要参考的边;
    • e1:被参考的组件对象;
    • e2:被参考的组件对象的具体被参考的边;
    • pad:两条边之间的距离,即两个组件之间的间距。

    8.3 示例

    import javax.swing.*;
    import java.awt.*;
    import java.awt.event.WindowAdapter;
    import java.awt.event.WindowEvent;
    
    class SpringLayout_3 extends JFrame {
        
        private static final long serialVersionUID = -6045918631932051025L;
        
        public SpringLayout_3() {
            // TODO Auto-generated constructor stub
            Container container = getContentPane();
            SpringLayout springLayout = new SpringLayout();
            container.setLayout(springLayout);
            JLabel topicLabel = new JLabel("主题 :");
            JLabel contentLabel = new JLabel("内容 :");
            final JTextField textField = new JTextField(30);
            JTextArea textArea = new JTextArea(3, 30);
            JScrollPane scrollPane = new JScrollPane();
            scrollPane.setViewportView(textArea);
            textArea.setLineWrap(true);
            final JButton confirmButton = new JButton("取消");
            JButton cancelButton = new JButton("确认");
            Spring st = Spring.constant(10);
            Spring st2 = Spring.constant(30);
            container.add(topicLabel);
            springLayout.putConstraint(SpringLayout.NORTH, topicLabel, st,SpringLayout.NORTH, container);
            springLayout.putConstraint(SpringLayout.WEST, topicLabel, st,SpringLayout.WEST, container);
            container.add(textField);
            springLayout.putConstraint(SpringLayout.WEST, textField, st2, SpringLayout.EAST, topicLabel);
            springLayout.putConstraint(SpringLayout.NORTH, textField, 0,SpringLayout.NORTH, topicLabel);
            springLayout.putConstraint(SpringLayout.EAST, textField, Spring.minus(st),SpringLayout.EAST, container);
            container.add(contentLabel);
            springLayout.putConstraint(SpringLayout.WEST, contentLabel, 0, SpringLayout.WEST, topicLabel);
            springLayout.putConstraint(SpringLayout.NORTH, contentLabel, st, SpringLayout.SOUTH, topicLabel);
            container.add(scrollPane);
            springLayout.putConstraint(SpringLayout.NORTH, scrollPane, 0, SpringLayout.NORTH, contentLabel);
            springLayout.putConstraint(SpringLayout.WEST, scrollPane, 0, SpringLayout.WEST, textField);
            springLayout.putConstraint(SpringLayout.EAST, scrollPane, Spring.minus(st), SpringLayout.EAST, container);
            container.add(confirmButton);
            springLayout.putConstraint(SpringLayout.SOUTH, scrollPane, Spring.minus(st), SpringLayout.NORTH, confirmButton);
            springLayout.putConstraint(SpringLayout.EAST, confirmButton, Spring.minus(st), SpringLayout.EAST, container);
            springLayout.putConstraint(SpringLayout.SOUTH, confirmButton, Spring.minus(st), SpringLayout.SOUTH, container);
            container.add(cancelButton);
            springLayout.putConstraint(SpringLayout.EAST, cancelButton, Spring.minus(st), SpringLayout.WEST, confirmButton);
            springLayout.putConstraint(SpringLayout.NORTH, cancelButton, 0, SpringLayout.NORTH, confirmButton);
            // make the text field focused every time the window is activated
            addWindowFocusListener(new WindowAdapter() {
                @Override
                public void windowGainedFocus(WindowEvent e) {
                    // TODO Auto-generated method stub
                    textField.requestFocus();
                }
            });
        }
        
        public static void main(String[] args) {
    
            // TODO Auto-generated method stub
    
            SpringLayout_3 frame = new SpringLayout_3();
    
            frame.setTitle("使用弹簧布局管理器");
    
            frame.setVisible(true);
    
            frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
    
            frame.setBounds(100, 100, 600, 300);
    
        }
    }
    

    运行效果如图所示;:

    在这里插入图片描述

    展开全文
  • Java三大常用布局管理器

    万次阅读 2015-08-21 19:33:10
    三大常用布局管理器:BorderLayout,FlowLayout,GridLayout,以及计算器的案例

    首先我们要了解布局管理器的作用

    Java布局管理器作用:

    跨平台时,当一个窗体中有文本控件,又有标签,还有按钮,这时你怎么控制它们在窗体中的排列顺序和位置呢,JAVA定义了布局管理器来处理这个问题的

    三大常用布局管理器:
    1.BorderLayout
    将版面划分成东、西、南、北、中五个区域,将添加的组件按指定位置放置。
        BorderLayout.EAST
        BorderLayout.WEST
        BorderLayout.SOUTH
        BorderLayout.NORTH
        BorderLayout.CENTER
    构造函数:
    BorderLayout()
    注意事项:
    1、不是五个部分都必须添加
    2、中部组件会自动调节大小(在其他部位没有的时候)
    3、JFrame,JDialog 默认布局管理器就是BorderLayout
    案例:
    <span style="font-family:KaiTi_GB2312;font-size:18px;">/*
     * BorderLayout演示
     * 1.继承JFrame
     * 2.定义你需要的组件
     * 3.创建组件(构造函数)
     * 4.添加组件
     * 5.对窗体设置
     * 6.显示窗体
     */
    package com.test1;
    import java.awt.*;
    import javax.swing.*;
    
    
    //继承JFrame类(窗体)和VB窗体相似
    public class Demo8_2 extends JFrame{
    
    	//定义组件
    	JButton jb1,jb2,jb3,jb4,jb5;
    	public static void main(String[] args) {
    		// TODO Auto-generated method stub
    		Demo8_2 demo8_2=new Demo8_2();
    	}
    	
    	public Demo8_2()
    	{
    		//创建组件
    		jb1=new JButton("中部");
    		jb2=new JButton("北部");
    		jb3=new JButton("东部");
    		jb4=new JButton("南部");
    		jb5=new JButton("西部");
    		
    		//添加各个组件,定位
    		this.add(jb1,BorderLayout.CENTER);
    		this.add(jb2,BorderLayout.NORTH);
    		this.add(jb3,BorderLayout.EAST);
    		this.add(jb4,BorderLayout.SOUTH);
    		this.add(jb5,BorderLayout.WEST);
    		
    		//设置窗体属性
    		this.setTitle("边界布局案例");
    		this.setSize(300,200);//大小
    
    		this.setLocation(200,300);//初始位置
    
    				this.setResizable(false);//禁止用户改变窗体大小
    
    		this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);//关闭窗体时关闭java虚拟机,以免占用内存
    		
    		//显示窗体
    		this.setVisible(true);
    	}
    }
    </span>
    效果:

    2.FlowLayout(流式布局)
    组件按从左到右而后从上到下的顺序依次排列,一行不能放完则折到下一行。


    构造函数:
    FlowLayout()
    建立一个默认为居中对齐,组件彼此有5单位的水平与垂直间距的FlowLayout
    FlowLayout(int align)
    建立一个可设置排列方式且组件彼此有5单位的水平与垂直间距的FlowLayout
    FlowLayout(int align,int hgap,int vgap)
    建立一个可设置排列方式与组件间距的FlowLayout


    注意事项:
    1、不限制它所管理的组件大小,允许它们有最佳大小
    2、当容器被缩放时,组件的位置可能变化,但组件的大小不变(在窗体属性那里加如下代码即可)
    <span style="font-family:KaiTi_GB2312;font-size:18px;">//禁止用户改变窗体大小
    this.setResizable(false);</span>
    3、默认组件是居中对齐,可以通过FlowLayout(int align)函数来指定对齐方式(如下图)
    案例:代码和上面一样除添加各个组件,定位那里,如下
    <span style="font-family:KaiTi_GB2312;font-size:18px;">//添加组件
    		this.add(jb1);
    		this.add(jb2);
    		this.add(jb3);
    		this.add(jb4);
    		this.add(jb5);
    		this.add(jb6);
    		
    		//设置布局管理器
    		this.setLayout(new FlowLayout(FlowLayout.LEFT));//这里定位也有多个方案,如下图		</span>

    效果:(我选的是左对齐)先填满第一排,然后再左对齐


    3.GridLayout(网格布局)
    矩形网格形式对容器的组件进行布置
     
    构造函数:
    GridLayout()
    建立一个默认为一行一列的GridLayout
    GridLayout(int rows,int cols)
    建立一个指定行(rows)和列(cols)的GridLayout
    GridLayout(int rows,int cols,int hgap,int vgap)
    建立一个指定行(rows)和列(cols),且组件间水平间距为hgap、垂直间距为vgap的GridLayout

    案例:
    <span style="font-family:KaiTi_GB2312;font-size:18px;">/*
     * 功能:网格布局演示
     * 
     */
    package com.test1;
    import java.awt.*;
    
    import javax.swing.*;
    public class Demo8_4 extends JFrame{
    	
    	//定义一个按钮数组(9个)
    	int size=9;
    	JButton jbs[]=new JButton[size];
    	
    	public static void main(String[] args) {
    		// TODO Auto-generated method stub
    		Demo8_4 demo8_4=new Demo8_4();
    	}
    	public Demo8_4()
    	{
    		//创建组件(按钮)
    		for(int i=0;i<size;i++)
    		{
    			jbs[i]=new JButton(String.valueOf(i));
    		}
    		
    		//设置网格布局(3行3列)(int rows,int cols) 后面两个10是水平垂直距离
    		this.setLayout(new GridLayout(3,3,10,10));
    		
    		//添加组件
    		for (int i=0;i<size;i++)
    		{
    			this.add(jbs[i]);
    		}
    		
    		//设置窗体
    		this.setTitle("网格布局案例");
    		this.setSize(300,200);
    		this.setLocation(200,300);
    		this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);//关闭窗体时关闭java虚拟机
    		
    		this.setVisible(true);
    	}
    }</span>
    效果:


    那我们就来做个计算器吧
    <span style="font-family:KaiTi_GB2312;font-size:18px;">package com.test1;
    import java.awt.*;
    import javax.swing.*;
    
    public class Demo8_5 extends JFrame{
    			
    	  //定义字符串数组,为按钮的显示文本赋值
    	  //注意字符元素的顺序与循环添加按钮保持一致
    	  String str[]={"7","8","9","/","4","5","6","*","1","2","3","-","0",".","=","+"};    
              JButton btn[]=new JButton[str.length];	//声明按钮组件
              
              //定义面板,并设置为网格布局,4行4列,组件水平、垂直间距均为3
              JPanel p=new JPanel(new GridLayout(4,4,3,3));  //面板组件Jpanel
              JTextArea t=new JTextArea();        //定义文本框
              
              
              public static void main(String[] args){
            	  
            	  Demo8_5 demo8_5 =new Demo8_5();
              }
    
              
         public Demo8_5(){
       	  	
        	//创建组件
            for(int i=0;i<str.length;i++){
    
                   btn[i]=new JButton(str[i]);
    
                   p.add(btn[i]);
    
             }
            
                setLayout(new BorderLayout());     //定义窗体布局为边界布局
               
                getContentPane().add(t,BorderLayout.NORTH);      //将文本框放置在窗体NORTH位置
                getContentPane().add(p,BorderLayout.CENTER);     //将面板放置在窗体CENTER位置
                
                //设置窗体属性
                this.setTitle("计算器布局案例");
                this.setSize(250,200);
                this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
                this.setLocationRelativeTo(null);                     //让窗体居中显示
                this.setVisible(true);
            }
    } 
    
    </span>
    效果:


    展开全文
  • Java布局管理器之插件(一)---JPanel

    千次阅读 2019-10-31 14:15:43
    在图形用户界面编程中, 如果只是普通的组件布局, 我们用前面讲的三种布局管理器就可以解决, 但在比较复杂的布局要求时,就需要使用布局管理器的组合使用。 面板组件 (JPanel) JPanel :面板组件,非顶层容器,...
  • java布局管理器总结

    千次阅读 多人点赞 2017-04-03 18:11:47
    BorderLayout FlowLayout GridLayout GridBagLayout ...java.lang.Object –java.awt.BorderLayout 将版面划分成东、西、南、北、中五个区域,将添加的组件按指定位置放置。 BorderLayout.EAST Border
  • 主要介绍了JAVA swing布局管理器实例解析,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
  • 韩顺平java图形界面编程之常用组件、布局管理器
  • java 常用布局管理器

    2013-03-28 16:54:48
    java 常用布局管理器
  • 主要为大家详细介绍了java Swing布局管理之BoxLayout布局的相关资料,感兴趣的小伙伴们可以参考一下
  • java布局管理器实例

    2010-08-07 10:30:58
    swing 组件的各种布局管理器,每一个都有实例,不明白的时候可以查查
  • ​ GridLayout 布局管理器将容器分割成纵横线分隔的网格 , 每个网格所占的区域大小相同。当向使用 GridLayout 布局管理器的容器中添加组件时, 默认从左向右、 从上向下依次添加到每个网格中 。 与 FlowLayout不同...
  • GridBagLayout是java里面最重要的布局管理器之一,可以做出很复杂的布局,可以说GridBagLayout是必须要学好的的,需要的朋友可以了解下
  • Java GUI编程的几种常用布局管理器

    千次阅读 2017-08-24 11:59:48
    Java GUI编程的几种常用布局管理器 本人是一个大二的学生。因为最近有做JavaGUI界面的需求,因此重新开始熟悉JavaGUI的各种控件和布局。然后以次博文为笔记,总结、完善以及发表最近学习的一些技术要点。希望各位...
  • javaGui--JFrame、布局管理器

    千次阅读 多人点赞 2018-10-05 07:49:35
    这个系列,我们介绍下java中的图形化组件——java GUI 开发。   java中开发gui程序需要使用的依赖包 java.awt.* 布局、字体等 ...java.awt.event.* 事件 (鼠标事件、键盘...本篇,我们介绍下javaGui中的布局 ...
  • Java BoxLayout(盒子布局)布局管理器

    千次阅读 2021-01-31 17:50:01
    为了简化开发,Swing 引入了 一个新的布局管理器 : BoxLayout 。 BoxLayout 可以在垂直和 水平两个方向上摆放 GUI 组件, BoxLayout 提供了如下一个简单的构造: 方法名称 方法功能 BoxLayout(Container ...
  • 可以帮助Java学习者深入了解边界布局管理器
  • java中的swing组件、主要三大布局管理器的应用

    万次阅读 多人点赞 2017-10-22 14:05:44
    2、种类:java共提供了五种布局管理器:流式布局管理器(FlowLayout)、边界布局管理器(BorderLayout)、网格布局管理器(GridLayout)、卡片布局管理器(CardLayout)、网格包布局管理器(GridBagLayout)。其中前三种是最...
  • BorderLayout布局 管理器布局示意图如图所示 。 当改变使用 BorderLayout 的容器大小时, NORTH 、 SOUTH 和 CENTER区域水平调整,而 EAST 、 WEST 和 CENTER 区域垂直调整。使用BorderLayout 有如下两个注意点:...
  • 解决Java初学者在使用布局管理器后不能调节各区域大小的问题
  • java多种布局管理器混合使用

    千次阅读 2017-06-30 16:36:30
    import javax.swing.*; import java.awt.*;... * 多种布局管理器的使用  *  */ public class test_04 extends JFrame { //定义组件 JPanel jp1,jp2; JButton jb1,jb2,jb3,jb4,jb5,jb6; publi

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 130,728
精华内容 52,291
关键字:

java布局管理器的作用

java 订阅