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

    2012-09-18 11:11:40
    java布局管理器测试代码,绝对能运行,环境为jdk1.6下
  • 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布局管理器

    2013-08-14 18:50:16
    JAVA布局管理器分为FlowLayout, BroderLayout, CardLayout, GridLayout等,每个Frame对象可以分配一种布局管理模式。 使用BroderLayout的时候,界面被划分成上下左右中心五个部分,对应英文里的(North, South, West,...

    JAVA布局管理器分为FlowLayout, BorderLayout, CardLayout, GridLayout等,每个Frame对象可以分配一种布局管理模式。

    使用BorderLayout的时候,界面被划分成上下左右中心五个部分,对应英文里的(North, South, West, East, Center),每一个部分还可以嵌套一个Panel控件,

    Panel控件也可以应用布局管理器,所以在JAVA设计中,复杂的界面往往是有多种布局管理模式嵌套而成。

    下面贴一段代码,综合演示了JAVA布局管理器的使用。

    package layout;
    import java.awt.*;
    import java.awt.event.*;
    /**
     * 聊天室界面模拟,演示布局管理器的综合使用
     */
    public class GridLayoutUse extends  Frame implements WindowListener{
    	public GridLayoutUse(){
    		super("在线聊天室");
    		this.addWindowListener(this);
    		initUI();
    	}
    
    
    	
    	/**
    	 * 初始化界面
    	 */
    	private void initUI(){
    		Panel pNorth = initNorth();
    		this.add(pNorth, BorderLayout.NORTH);
    		
    		Panel pEast  = initEast();
    		this.add(pEast, BorderLayout.EAST);
    		
    		Panel pCenter = initCenter();
    		this.add(pCenter, BorderLayout.CENTER);
    		
    		this.setSize(450,500);
    		this.setVisible(true);
    	}
    	
    	/**
    	 * 初始化界面上部
    	 */
    	private Panel initNorth(){
    		Panel p = new Panel();
    		Label lbTitle = new Label("聊天室");
    		p.add(lbTitle);
    		p.setBackground(Color.PINK);
    		return p;
    	}
    	
    	
    	/**
    	 * 初始化界面右侧
    	 */
    	private Panel initEast(){
    		Panel p = new Panel();
    		BorderLayout bl = new BorderLayout();
    		p.setLayout(bl);
    		Label lbTitle = new Label("当前在线");
    		List listUser = new List();
    		listUser.add("所有人");
    		listUser.add("Miao");
    		listUser.add("Wang");
    		
    		p.add(lbTitle, BorderLayout.NORTH);
    		p.add(listUser,BorderLayout.CENTER);
    		
    		p.setBackground(Color.CYAN);
    		return p;
    	}
    
    	/**
    	 * 初始化主界面中心
    	 * @return 主界面中心面板
    	 */
    	private Panel initCenter(){
    		Panel p = new Panel();
    		BorderLayout bl = new BorderLayout();
    		p.setLayout(bl);
    		TextArea ta = new TextArea();
    		ta.append("You enter the chatroom.\n");
    		ta.append("You say \"Hi\" to everyone.");
    		ta.setEditable(false);
    		ta.setBackground(Color.ORANGE);
    		p.add(ta,BorderLayout.CENTER);
    		
    		//initialize south
    		Panel pSouth = new Panel();
    		BorderLayout bl2 = new BorderLayout();
    		pSouth.setLayout(bl2);
    		Choice ch = new Choice();
    		ch.add("All");
    		ch.add("Wang");
    		pSouth.add(ch, BorderLayout.WEST);
    		TextField tf = new TextField(20);
    		pSouth.add(tf, BorderLayout.CENTER);
    		Button btn = new Button("Send");
    		pSouth.add(btn, BorderLayout.EAST);
    		
    		p.add(pSouth, BorderLayout.SOUTH);
    		return p;
    	}
    	
    	public static void main(String[] agrs){
    		GridLayoutUse crf = new GridLayoutUse();
    	}
    
    
    
    	@Override
    	public void windowActivated(WindowEvent arg0) {
    		// TODO Auto-generated method stub
    		System.out.println("activated");
    	}
    
    
    
    	@Override
    	public void windowClosed(WindowEvent arg0) {
    		// TODO Auto-generated method stub
    		System.out.println("Closed");
    	}
    
    
    
    	@Override
    	public void windowClosing(WindowEvent arg0) {
    		// TODO Auto-generated method stub
    		System.out.println("Closing");
    		System.exit(0);
    		
    	}
    
    
    
    	@Override
    	public void windowDeactivated(WindowEvent arg0) {
    		// TODO Auto-generated method stub
    		System.out.println("deactivated");
    	}
    
    
    
    	@Override
    	public void windowDeiconified(WindowEvent arg0) {
    		// TODO Auto-generated method stub
    		System.out.println("deiconified");
    		
    	}
    
    
    
    	@Override
    	public void windowIconified(WindowEvent arg0) {
    		// TODO Auto-generated method stub
    		System.out.println("iconified");
    		
    	}
    
    
    
    	@Override
    	public void windowOpened(WindowEvent arg0) {
    		// TODO Auto-generated method stub
    		System.out.println("open");
    	}
    
    
    }

    运行后代码界面效果如下:

     


     

     

    此处只写了界面,没有完善功能。

    展开全文
  • JAVA 布局管理器

    千次阅读 2011-04-13 15:33:00
    默认布局管理器 当一个容器被创建后,它们有相应的默认布局管理器。Window、Frame和Dialog的默认布局管理器是BorderLayout,Panel和 Applet的默认布局管理器是FlowLayout。 可以通过setLayout()...

    New Document 组件在容器中的位置和尺寸是由布局管理器来决定的。所有的容器都会引用一个布局管理器实例,通过它来自动进行组件的布局管理。
    默认布局管理器
    当一个容器被创建后,它们有相应的默认布局管理器。Window、Frame和Dialog的默认布局管理器是BorderLayout,Panel和
    Applet的默认布局管理器是FlowLayout。 可以通过setLayout()方法来重新设置容器的布局管理器。例如把一个Frame的布局管理器设为FlowLayout。

    Frame f=new Frame("hello"); f.setLayout(new FlowLayout());

    取消布局管理器
    如果不希望通过布局管理器来管理布局,可以调用容器的setLayout(null)方法, 这样布局管理器就被取消了。
    接下来必须调用容器中每个组件的setLocation()、setSize()、或setBounds()方法,为这些组件在容器中一一定位。
    和布局管理器管理方式不同的是,这种手工布局将导致图形界面的布局不再是和平台无关的。相反,图形界面的布局将依赖于操作系统环境。

    布局管理器种类
    java.awt包提供了5种布局管理器:FlowLayout 流式布局管理器、Borderlayout 边界布局管理器、GridLayout 网格布局管理器、Cardlayout 卡片 布局管理器和GridBagLayout网格包布局管理器。另外javax.swing包还提供了一种BoxLayout 布局管理器。

    FlowLayout 流式布局管理器
    FlowLayout 是最简单的布局管理器,按照组件的添加次序将它们从左到右地放置在容器中。当到达容器边界时,组件将放置在下一行中。
    FlowLayout 运行以左对齐、 居中对齐(默认方式)或右对齐的方式排列组件。

    FlowLayout的特性如下: 不限制它所管理的组件的大小,而是允许它们有自己的最佳大小。 当容器被缩放时,组件的位置可能会变化,但组件的大小不改变。 FlowLayout的构造方法如下:

    • FlowLayout();
    • FlowLayout(int align);
    • FlowLayout(int align,int hgap,int vgap);


    参数align用来决定组件在每行中相对于容器的边界的对齐方式,可选值有:FlowLayout.LEFT(左对齐)、
    FlowLayout.RIGHT(右对齐)和FlowLayout.CENTER(居中对齐)。参数hgap和参数vgap 分别设定组件之间的水平和垂直间隙。

    BorderLayout边界布局管理器
    BorderLayout为在容器中放置组件提供了一个稍微复杂的布局方案。BorderLayout把容器分为5个区域:东、南、西、北和中。
    北占据容器的上方,东占据容器的右侧,依次类推。中区域是在东、南、西和北都填满后剩下的区域。
    BorderLayout的特性如下:

    • 在位于东和西区域的组件保持最佳宽度,高度被垂直拉伸至和所在区域一样高; 位于南和北区域的组件保持最佳高度,宽度被水平拉伸至和所在区域一样宽; 位于中区域的组件的宽度和高度都被拉伸至和所在区域一样的大小。
    • 当窗口垂直拉伸时,东、西和中区域也拉伸;而当窗口水平拉伸时,南、北和中区域也拉伸;
    • 对于容器的东、南、西和北区域,如果某个区域没有组件,则这个区域面积为零;对于中区域,不管有没有 组件,BorderLayout都会为它分配空间,如果该区域没有组件,在中区域显示容器的背景颜色。
    • 当容器被缩放时,组件所在的相对位置不变,但组件大小改变。
    • 如果在某个区域添加的组件不止一个,则只有最后添加的一个是可见的。


    BorderLayout的构造方法如下:

    • BorderLayout()
    • BorderLayout(int hgap,int vgap)


    参数hgap和参数vgap分别设定组件之间的水平和垂直间隙。
    对于采用BorderLayout的容器,当它用add()方法添加一个组件时,可以同时为组件指定在容器中的区域。

    void add(Component comp,Object constraints)
    这里的 constraints是 String类型,可选值为BorderLayout提供的5个常量。

    • Borderlayout.NORTH:北区域,值为"North"。
    • Borderlayout.SOUTH:南区域,值为"South"。
    • Borderlayout.EAST:东区域,值为"East"。
    • Borderlayout.WEST:西区域,值为"West"。
    • Borderlayout.CENTER:中区域,值为"Center"。


    Frame的默认布局管理器就是BorderLayout。以下代码把Button方在Frame的北区域。

    Frame f=new Frame("Test");
    f.add(new Button("b1",BorderLayout>NORTH));
    //或者;f.add(new Button("b1","North"));

    如果不指定add()方法的constraints参数,在默认情况下把组件放在中区域。以下代码向Frame的
    中区域加入两个Button,但是只有最后加入的Button是可见的。

    Frame f=new Frame("Test");
    f.add(new Button("b1"));
    f.add(new Button("b2"));
    f.setSize(100,100);
    f.setVisible(true);

    在Frame中只有b2按钮是可见的,它占据了Frame的中区域,由于其他区域没有组件,因此其他区域的面积都为零
    ,b2按钮自动向垂直和水平方向拉伸,占据了Frame的整个空间。

    Gridlayout网格布局管理器
    GridLayout将容器分割成许多行和列,组件被填充到每个网格中。添加到容器中的组件首先放置在左上角的网格中,
    然后从左到右放置其他组件,直至占满该行的所以网格,接着继续在下一行中从左到右放置组件。

    GridLayout的特性如下:

    • 组件的相对位置不随区域的缩放而改变,但组件的大小会随之改变。组件始终占据网格的整个区域。 GridLayout总是忽略组件的最佳大小,所以组件的宽度相同,高度也相同。
    • 将组件用add()方法添加到容器中的先后顺序决定它们占据哪个网格。
    • GridLayout从左到右、从上到下将组件填充到容器的网格中。


    GridLayout的构造方法如下:

    • GridLayout()
    • GridLayout(int rows,int cols)
    • GridLayout(int rows,int cols,int hgap,int vgap)


    参数rows代表行数,参数cols代表列数。参数hgap和vgap规定水平和垂直方向的间隙。水平间隙是指网格之间的水平距离,
    垂直间隙是指网格之间的垂直距离。

    CardLayout卡片布局管理器
    CardLayout将界面看做一系列的卡片,在任何时候只有其中一个卡片是可见的,
    这张卡片占据容器的整个区域。CardLayout的构造方法如下:

    • Cardlayout()
    • Cardlayout(int hgap,int vgap)


    参数hgap表示卡片和容器的左右边界之间的间隙,参数vgap表示卡片和容器的上下边界的间隙。
    对于采用Cardlayout的容器,当用add()方法添加一个组件时,需要同时为组件指定所在卡片的名字。

    void add(Component comp,Object constraints)

    以上constraints参数是一个字符串,表示卡片的名字。在默认的情况下,容器显示第一个用add()方法加入到
    容器中的组件,也可以通过CardLayout的show(Container parent,String name)方法指定显示哪张卡片,参数
    parent指定容器,参数name指定卡片的名字。

    GridBagLayout网格包布局管理器
    GridBagLayout在网格的基础上提供更为复杂的布局,和GridLayout不同,GridBagLayout允许容器中各个
    组件的大小各不相同,还允许单个组件所在的显示区域占据多个网格。
    使用GridBagLayout布局管理器的步骤如下:
    (1)创建GridBagLayout布局管理器,并使容器采用该布局管理器。
    GridBagLayout layout =new GridBagLayout();
    container.setlayout(layout);
    (2)创建一个GridBagConstraints对象。
    GridBagConstraints constraints=new GridBagConstraints();
    (3)为第一个添加到容器中的组件设置GridBagConstraints的各种属性。
    constraints.gridx=1; //设置网络的左上角的x坐标
    constraints.gridy=1; //设置网络的左上角的y坐标
    constraints.gridwidth=1; //设置网络的宽度
    constraints.gridheight=1; //设置网络的高度
    (4)通知布局管理器放置第一个组件时的GridBagConstraints信息。
    layout.setConstraints(component1,constraints);
    (5)向容器中添加第一个组件。
    container.add(component1);
    (6)重复步骤(3)~步骤(5),将每个组件都添加到容器中。

    GridBagConstraints包含了如何把一个组件添加到容器中的布局信息。只需要创建一个GridBagConstraints对象,
    在每次向容器中加入组件时,先设置GridBagConstraints对象的属性,这个GridBagConstraints对象可以被多次 重用。
    GridBagConstraints具有以下属性。
    (1)gridx和gridy:这些属性指定了组件的显示区域的左上角的列和行。如果把gridx或gridy设为GridBagConstraints
    .RELATIVE(默认值),表示当前组件紧跟在上一个组件的后面。
    (2)gridwidth和gridheight:这些属性指定了组件的显示区域占据的列数和行数,默认值为1.如果把Gridwidth或
    gridheigth设为GridBagConstraints.REMAINDER,表示当前组件在其行或列上为最后一个组件。如果把gridwidth或gridheight
    设为GridBagConstraints.RELATIVE,表示当前组件在其行或列上为倒数第二个组件。
    (3)fill:该属性在某组件的显示区域大于它所要求的大小时被使用。fill决定了是否及如何改变组件的大小,有效值包括:

    • GridBagConstraints.NONE-默认,不改变组件的大小。
    • GridBagConstraints.HORIZONTAL-使组件足够大,以填充其显示区域的水平方向,但不改变其高度。
    • GridBagConstraints.VERTICAL-使组件足够大,以填充其显示区域的垂直方向,但不改变其宽度。
    • GridBagConstraints.BOTH-使组件足够大,以填充其整个显示区域。


    (4)ipadx和ipady:这些属性指定了内部填充的大小,即在该组件的最小尺寸基础上还需要增加多少。
    组件的宽度必须至少为其最小宽度加ipadx×2个像素(因为填充作用于组件的两边)。同样,组件的高度必须至少为其最小高度加ipady×2个像素。
    (5)insets:该属性指定了组件的外部填充大小,即组件与其显示区域边界之间的最小空间大小。
    (6)anchor:该属性在某组件大小小于其显示区域时使用。anchor决定了组件放置在该区域中的位置。有效值包括;

    • GridBagConstraints.CENTER(默认值)
    • GridBagConstraints.NORTH
    • GridBagConstraints.NORTHEAST
    • GridBagConstraints.EAST
    • GridBagConstraints.SOUTHEAST
    • GridBagConstraints.SOUTH
    • GridBagConstraints.SOUTHWEST
    • GridBagConstraints.WEST
    • GridBagConstraints.NORTHWEST。


    (7)weightx和weighty:weightx属性称为水平重量,weightty属性称为垂直重量,
    它们用来决定如何布置容器中多于的水平方向和垂直方向的空白区域。除非为一行
    (weightx)和一列(weighty)中的至少一个组件指定了重量,否则,所有组件都会集中
    在容器的中央,这是因为当重量为0(默认值)时,GridBagLayout把所有空白区域放在
    组件的显示区域和容器边界之间。

    展开全文
  • 主要介绍了JAVA布局管理器与面板组合代码实例,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
  • 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布局管理器

    2020-12-22 20:52:50
    Java的GUI界面定义是由awt类和swing类来完成的。它在布局管理上面采用了容器和布局管理分离的方案。也是说,容器只管将其他小件放...  现在我们来看Java布局管理器的具体实现。我们前面说过,Java中的容器类(Contai
  • 很多初学者在用Java布局器自动布局画界面时,经常遇见不知道如何定义区域大小或按钮之间的距离等问题。我写过一篇《实现JAVA手动布局中各个组件能随窗口变化的方法》的文章,有读者反映算坐标不好算,问能不能用布局...
  • java布局管理器实例

    2010-08-07 10:30:58
    swing 组件的各种布局管理器,每一个都有实例,不明白的时候可以查查
  • Java布局管理器setLayout()

    万次阅读 2013-07-18 20:11:29
    Java布局管理器setLayout() 1。FlowLayout public FlowLayout(int align,int hgap,int vgap) 创建一个新的流布局管理器,具有指定的对齐方式以及指定的水平和垂直间隙。 对齐参数的值必须是以下之一:FlowLayout....
  • 离开Java布局管理器

    千次阅读 2006-08-28 16:46:00
    离开Java布局管理器 转载自:www.csdn.net Java语言中提供的布局管理器种类有:边界式布局、卡片式布局、流式布局和网格式布局等,各有不同的特点
  • java布局管理器总结

    千次阅读 多人点赞 2017-04-03 18:11:47
    BorderLayout FlowLayout GridLayout GridBagLayout ...java.lang.Object –java.awt.BorderLayout 将版面划分成东、西、南、北、中五个区域,将添加的组件按指定位置放置。 BorderLayout.EAST Border
  • Java布局管理器之GridBagLayout布局

    千次阅读 2013-05-18 01:27:57
    今天做了画图板界面的布局,感觉传统的布局都难以满足需求(难以实现画图面板的左上角停靠),所以无奈只能使用这个比较恶心的布局管理器了,由于涉及到的参数很多,因此相当复杂,而且其内的单元网格是动态的,所以...
  • Java中,容器ScrollPane的默认布局管理器是BorderLayout 但是可以改变ScrollPane的布局管理器吗? 我的一个程序如下: ``` import java.awt.Component; import java.awt.Container; import java.awt.Window; ...
  • JAVA布局管理 用户程序界面的设计不仅要求其功能完备,各控件之间的布局设计合理,更要求界面风格使人赏心悦目。为了帮助程序员设立良好的界面,减轻他们的工作强度,Java提供了布局管理器,用来设计和控制各种组件...
  • Java布局管理器之插件(一)---JPanel

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

空空如也

空空如也

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

java布局管理器

java 订阅