精华内容
下载资源
问答
  • 小白用网格布局实现简单的计算器 ——Android
    千次阅读
    2019-03-16 23:36:33

     目的:采用网格布局,实现计算器的简单功能

     开发工具:Android Studio3.3.2 

     开发环境

      

    实现过程

    • 第一步,创建一个Android项目,在这我把项目命名为MyApplication。
    • 第二步,打开MyApplication/app/src/main/res/layout/activity_main.xml,使用text模式编写代码。
      1. 使用网格布局(GridLayout)把区域划分为6行4列。

      2.  第一行设置为显示数据的文本标签<TextView/>,第二行为清除数据的按钮,第三到六行均划分为4列,共16个按钮,分别代表0到9以及加、减、乘、除、等号,此外给每一个按钮添加id ,后续用来绑定按钮事件。

      3. xml文件代码如下,写完之后,可以先run一下,看一下布局效果。

    <?xml version="1.0" encoding="utf-8"?>
    <GridLayout xmlns:android="http://schemas.android.com/apk/res/android"
        android:layout_width="match_parent"
        android:layout_height="match_parent"
        android:rowCount="6"
        android:columnCount="4"
        > <!--设置网格为6行4列-->
    
        <TextView
            android:id="@+id/a_edit"
            android:layout_width="wrap_content"
            android:layout_height="wrap_content"
            android:layout_columnSpan = "4"
            android:layout_marginLeft="4px"   
            android:gravity="left"
            android:text="0"
            android:textSize="50dip"
            /> <!--组件占据4列,且左对齐,设置左边距为4px-->
    
        <Button
            android:id="@+id/btn_clear"
            android:layout_width="354dp"
            android:layout_height="wrap_content"
            android:layout_columnSpan="4"
            android:text="清除"
            android:textSize="26sp" /><!--组件占据4列-->
    
        <Button android:text ="1" android:id="@+id/btn_one" android:textSize="26sp"/>
        <Button android:text ="2" android:id="@+id/btn_two" android:textSize="26sp"/>
        <Button android:text ="3" android:id="@+id/btn_three" android:textSize="26sp"/>
        <Button android:text ="+" android:id="@+id/btn_add" android:textSize="26sp"/>
    
        <Button android:text ="4" android:id="@+id/btn_four" android:textSize="26sp"/>
        <Button android:text ="5" android:id="@+id/btn_five" android:textSize="26sp"/>
        <Button android:text ="6" android:id="@+id/btn_six" android:textSize="26sp"/>
        <Button android:text ="-" android:id="@+id/btn_sub" android:textSize="26sp"/>
    
        <Button android:text ="7" android:id="@+id/btn_seven" android:textSize="26sp"/>
        <Button android:text ="8" android:id="@+id/btn_eight" android:textSize="26sp"/>
        <Button android:text ="9" android:id="@+id/btn_nine" android:textSize="26sp"/>
        <Button android:text ="*" android:id="@+id/btn_multiply" android:textSize="26sp"/>
    
        <Button android:text ="." android:id="@+id/btn_point" android:textSize="26sp"/>
        <Button android:text ="0" android:id="@+id/btn_zero" android:textSize="26sp"/>
        <Button android:text ="=" android:id="@+id/btn_equal" android:textSize="26sp"/>
        <Button android:text ="/" android:id="@+id/btn_divide" android:textSize="26sp"/>
    
    </GridLayout>
    • 第三步,这部分主要是处理计算器的点击事件,也是计算器的核心部分

       

      1. 打开MainActiviity.java,在MainActivity中开始编写Java
      2. 处理数字类按钮的点击事件:首先是要定义布局中所有的按钮和输入框,然后以手机中的计算器为例,可知用户点击数字按钮时,显示框会显示用户输入的数字,而且需要做计算就需要保存用户输入的数字。也就是是说,数字按钮的事件就是获取到用户点击按钮所对应的数字,并存储显示,小数点的按钮同理。
      3. 明确数字按钮的功能之后,就分析一下加减乘除。运算符就比较有意思一点,因为用户可能会做连续运算。情况一是:输入一个数字之后按下运算符按钮,此时就直接存储一下用户所点击的符号即可,案例1+2=3。情况二:用户已经计算过一次,即已经输入"=",也就是已经有一个运算结果了,此时再输入符号就表示想要在原来结果的基础上做运算,这个时候我们就要将上一次的运算结果(str_result)作为该次运算的第一个数字,案例4+6=10-2=8。情况三:和情况二类似,用户想计算两个或两个以上的数字,此时就要设置一个标记来判断用户是否已经输过符号,如果已经输过,就先计算结果并显示,然后再记录这次输入的运算符(1+3)*3=12【注:这里没有做运算符优先级处理,默认按顺序计算结果。 
    • 具体实现代码如下

     

    package com.example.myapplication;
    import android.os.Bundle;
    import android.app.Activity;
    import android.view.View;
    import android.widget.Button;
    import android.widget.TextView;
    import android.widget.Toast;
    
    public class MainActivity extends Activity implements View.OnClickListener {
        //声明对象
        private Button bt_zero;
        private Button bt_one;
        private Button bt_two;
        private Button bt_three;
        private Button bt_four;
        private Button bt_five;
        private Button bt_six;
        private Button bt_seven;
        private Button bt_eight;
        private Button bt_nine;
        private Button bt_multiply;
        private Button bt_divide;
        private Button bt_sub;
        private Button bt_add;
        private Button bt_point;
        private Button bt_equal;
        private Button bt_clear;
        private TextView et_edit;
    
        private StringBuffer str_display = new StringBuffer();  //用来存放用户输入
        private boolean flag = true;   //是否输入小数点
        private String str_oper = "+";//存放输入的符号
        private String str_result = "0"; //存放计算结果
        private double num1 = 0;   //存放符号前的数字
        private double num2 = 0;    //存放符号后的数字;
        private boolean e_flag = false;   //是否已经按等号
        private boolean s_flag = false;   //是否已经按符号
    
        @Override
        protected void onCreate(Bundle savedInstanceState) {
            super.onCreate(savedInstanceState);
            setContentView(R.layout.activity_main);
            //与用户界面程序建立组件关联【实例化对象】
            bt_zero = (Button) findViewById(R.id.btn_zero);
            bt_one = (Button) findViewById(R.id.btn_one);
            bt_two = (Button) findViewById(R.id.btn_two);
            bt_three = (Button) findViewById(R.id.btn_three);
            bt_four = (Button) findViewById(R.id.btn_four);
            bt_five = (Button) findViewById(R.id.btn_five);
            bt_six = (Button) findViewById(R.id.btn_six);
            bt_seven = (Button) findViewById(R.id.btn_seven);
            bt_eight = (Button) findViewById(R.id.btn_eight);
            bt_nine = (Button) findViewById(R.id.btn_nine);
            bt_multiply = (Button) findViewById(R.id.btn_multiply);
            bt_divide = (Button) findViewById(R.id.btn_divide);
            bt_sub = (Button) findViewById(R.id.btn_sub);
            bt_add = (Button) findViewById(R.id.btn_add);
            bt_point = (Button) findViewById(R.id.btn_point);
            bt_equal = (Button) findViewById(R.id.btn_equal);
            bt_clear = (Button) findViewById(R.id.btn_clear);
            et_edit = (TextView) findViewById(R.id.a_edit);
            et_edit.setText("0.0");
            
            //注册按钮监听器
            bt_zero.setOnClickListener(this);
            bt_one.setOnClickListener(this);
            bt_two.setOnClickListener(this);
            bt_three.setOnClickListener(this);
            bt_four.setOnClickListener(this);
            bt_five.setOnClickListener(this);
            bt_six.setOnClickListener(this);
            bt_seven.setOnClickListener(this);
            bt_eight.setOnClickListener(this);
            bt_nine.setOnClickListener(this);
            bt_point.setOnClickListener(this);
            bt_add.setOnClickListener(this);
            bt_sub.setOnClickListener(this);
            bt_divide.setOnClickListener(this);
            bt_multiply.setOnClickListener(this);
            bt_clear.setOnClickListener(this);
            bt_equal.setOnClickListener(this);
        }
        public void onClick(View v) {
            switch (v.getId()) {
                //按钮0-9
                case R.id.btn_zero:
                case R.id.btn_one:
                case R.id.btn_two:
                case R.id.btn_three:
                case R.id.btn_four:
                case R.id.btn_five:
                case R.id.btn_six:
                case R.id.btn_seven:
                case R.id.btn_eight:
                case R.id.btn_nine:
                    if(e_flag){
                        str_result = "0";
                        e_flag = false;
                    }//判断是否已经计算过,即是否输入“=”,如果是,此时已经按下数字键,上一次计算结果则无效,进行初始化,下面同理
                    str_display.append(((Button) v).getText().toString());    //获取到按钮的显示文字,转化为String类型,插入到str_display变量中
                    et_edit.setText(str_display.toString());    //将获取到的按钮文字显示在EditText里
                    break;
                case R.id.btn_point:
                    if(e_flag){
                        str_result = "0";
                        e_flag = false;
                    }
                    if (flag) {
                        str_display.append(".");
                        et_edit.setText(str_display.toString());
                        flag = false;    
                    }
                    break;
                case R.id.btn_add:
                case R.id.btn_sub:
                case R.id.btn_divide:
                case R.id.btn_multiply: //用户点击了运算按钮
                    if(s_flag){    //用户第二次点击运算按钮,则将上一次运算得到的结果赋值给num1
                        getResult(); 
                        s_flag = false;   //初始化
                    }
                    str_oper = ((Button) v).getText().toString();  //将获取到的按钮文字显示在EditText里
                    if (e_flag) {  //用户点击了“=”号之后直接输入运算符,表示想连续运算,则先将上一次运算得到的结果赋值给num1
                        num1 = Double.parseDouble(str_result);   
                        str_result = "0";
                        str_display = new StringBuffer("");
                    }else{
                        if (str_display.toString() != "") {
                            num1 = Double.parseDouble(str_display.toString()); //将用户的第一个输入赋值给num1
                            str_display = new StringBuffer("");
                        }else{
                            num1 = 0;
                        }
                    }
                    et_edit.setText(String.valueOf(num1)); //将num1显示在EditText里
                    flag = true;
                    s_flag = true;
                    break;
    
                    case R.id.btn_clear:  //用户点击了清除按钮,对所有变量进行初始化
                    str_oper = "+";
                    str_result = "0";
                    num1 = 0;
                    num2 = 0;
                    flag = true;
                    e_flag = false;
                    s_flag = false;
                    str_display = new StringBuffer("");
                    et_edit.setText("0.0");
                    break;
    
                    case R.id.btn_equal:  //用户点击了“=”
                    getResult();   //调用函数,计算结果
                    break;
            }
        }
        private void getResult(){
            if (str_oper.equals("+")) {  //当用户输入的符号为“+”时
                num2 = Double.parseDouble(str_display.toString());
                str_result = String.valueOf(num1 + num2);   //计算两数相加
                et_edit.setText(str_result);   //将计算结果显示在EditText里
                str_display = new StringBuffer("");
            }
            if (str_oper.equals("-")) {  //当用户输入的符号为“+”时
                num2 = Double.parseDouble(str_display.toString());
                str_result = String.valueOf(num1 - num2); //计算两数相减
                et_edit.setText(str_result);
                str_display = new StringBuffer("");
            }
            if (str_oper.equals("*")) {  //当用户输入的符号为“+”时
                num2 = Double.parseDouble(str_display.toString());
                str_result = String.valueOf(num1 * num2);//计算两数相乘
                et_edit.setText(str_result);
                str_display = new StringBuffer("");
            }
            if (str_oper.equals("/")) {  //当用户输入的符号为“+”时
                num2 = Double.parseDouble(str_display.toString());
                if (num2 != 0) {
                    str_result = String.valueOf(num1 / num2);//计算两数相除
                    et_edit.setText(str_result);
                } else {
                    Toast.makeText(MainActivity.this, "除数不能为零!", 0).show();
                }
                str_display = new StringBuffer("");
            }
            num1 = 0;
            num2 =0;
            e_flag = true;
            s_flag = false;
            str_oper = "";
        }
    }
    
    

    ——运行解果如下图所示【左边是android studio自带虚拟机效果,右边是真机效果】: 

     

    以上就是简单计算器的实现过程,本小组成员功力尚浅,若有不足之处,请多多指教鸭~

    更多相关内容
  • 二、网格布局说明 (一)、源码A 1、源码A说明 2、源码A运行效果 (二)、源码B(源码A基础上添加方法way3、way4) 1、源码B说明 2、源码B的运行效果 (三)、源码C(源码B的基础上添加方法way4) 1、源码...

    目录

    一、关键代码

    (一)、网格组约束条件

    (二)、约束的“条件”

    1、坐标

    2、尺寸

    3、填充(fill)属性

    二、网格组布局说明

    (一)、源码A

    1、源码A说明

    2、源码A运行效果

    (二)、源码B(源码A基础上添加方法way3、way4)

    1、源码B说明

    2、源码B的运行效果

    (三)、源码C(源码B的基础上添加方法way4)

    1、源码C说明

    2、源码C的运行效果

    (四)、源码C关于fill属性的运行效果

    1-1、全填充(BOTH):

    1-2、按钮3(名为:0.0)全填充(BOTH)的运行效果:

    2-1、垂直填充(VERTICAL):

    2-2、按钮3(名为:“0.0”)垂直填充(VERTICAL)的运行效果:

    3-1、水平填充(HORIZONTAL):

    3-2、按钮3(名为:“0.0”)水平填充(HORIZONTAL)的运行效果:

    三、定位日期


    一、关键代码

    (一)、网格组约束条件

            由下代码创建一个网格包约束条件g_0,最后再由g_0分别指定不同的条件,如位置、尺寸,等。

    // Grid(网格),Bag(包),Constraints(限制)
    GridBagConstraints g_0=new GridBagConstraints();// 创建一个网格包约束条件g_0

    (二)、约束的“条件”

            以下为本文用到的网格包约束条件中的“条件”。

    1、坐标

            网格(grid)的x,y坐标(gridx、gridy

            坐标数值由0开始,并未由1开始。坐标的第0行,即为第一行。

    g_0.gridx=0;// x坐标1行位置,计算机以0为第一个
    g_0.gridy=0;// y坐标1列位置

    2、尺寸

            网格(grid)的宽度(width)、高度(height

            (尺寸数值非零开头,和坐标不同)

    g_0.gridwidth=1;// 宽度
    g_0.gridheight=2;// 高度

    3、填充(fill)属性

            (1)、默认方式为“居中(center)”

            (2)、上下,左右全:BOTH 。小写:both

            (3)、垂直:VERTICAL 。小写:vertical

            (4)、水平:HORIZONTAL 。小写:horizontal

    g_3.fill=GridBagConstraints.BOTH;// 按钮填充方式,全全填充
    g_3.fill=GridBagConstraints.VERTICAL;// 填充方式,垂直填充
    g_3.fill=GridBagConstraints.HORIZONTAL;// 填充方式,水平填充

    二、网格组布局说明

            网格组布局,可以更精确的布置窗体内各构建的位置。在一个窗体中使用网格组布局,布置“按钮”“标签”等构件时,可以先引入网格组布局包A,然后再根据自己的需求对A设置好相关的约束条件便可。“约束”内容,比如:坐标、尺寸、填充方式、方位、具体位置等。本文记录的约束内容为:坐标、尺寸和填充方式,其它约束条件下篇博文记录。

    (一)、源码A

    1、源码A说明

            展示网格组布局中约束条件的效果,先建立一个“窗体”,代码部分看源码A的方法way1,窗体的属性详细内容看way1部分代码。

            在“窗体”中添加3个“按钮”,具体为源码A中的方法way2部分代码,数据坐标分别为(0-0),(1-1),(2-2),(x-y坐标)。由于坐标数值由0开始,则前面的way2的三个坐标分别为(第一行-第一列),(第二行-第二列),(第三行-第三列)。

            源码A如下

    /**所想:
        网格组布局
    */
    
    /*
    	引入的包,以下的import等等
    */
    import java.awt.GridBagConstraints;// Constraints(限制) 
    import java.awt.GridBagLayout;//网格包
    import java.awt.Container;// 容器
    import java.awt.Color;// 颜色
    
    import javax.swing.JFrame; // 窗体
    import javax.swing.JButton;// 按钮
    import javax.swing.JPanel;// java面板
    
    class Demo{
    	JFrame f=new JFrame();// 设置主窗体
    	Container c;// 主容器
    
    	/*	
    		方法way1
    		创建一个新方法way1,设置窗体的规格
    		Content(容器),Pane(镶嵌),Grid(网格),Bag(包),Layout(布局)
    	*/
    	void way1(){
    		// Content(容器),Pane(镶嵌),layout(布局)
    		c=f.getContentPane();//容器c镶嵌于窗体中
    		c.setLayout(new GridBagLayout());// 容器c建立网格包布局
    		f.setSize(1000,800);// 设置窗体宽、高
    
    		// location(位置),Relative(相对于),括号里为某“组件”参数,为null时窗体在桌面居中显示
    		f.setLocationRelativeTo(null);// 窗体在桌面居中显示,null(空值)
    
    		// Default(默认),operation(操作),点击×程序便停止运行
    		f.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
    	}
    	
    	/*
    		方法way2
    		创建一个新方法way2,将3个按钮限制于x,y坐标为1-1,2-2,3-3的布局中
    		主要使用:gridx及gridy,网格坐标的意思	
    	*/
    	void way2(){
    		// Grid(网格),Bag(包),Constraints(限制)
    		GridBagConstraints g_0=new GridBagConstraints();// 创建一个网格包约束条件g_0
    		g_0.gridx=0;// x坐标1行位置,计算机以0为第一个
    		g_0.gridy=0;// y坐标1列位置
    		c.add(new JButton("按钮1"),g_0);// 在容器里创建一个“按钮1”,约束条件“g_0”
    
    		GridBagConstraints g_1=new GridBagConstraints();// 约束“g_1”
    		g_1.gridx=1;// x坐标2行位置
    		g_1.gridy=1;// y坐标2列位置
    		c.add(new JButton("按钮2"),g_1);// 容器里加“按钮2”,约束为“g_1”
    		
    		GridBagConstraints g_2=new GridBagConstraints();//约束“g_2”
    		g_2.gridx=2;// x坐标3行位置
    		g_2.gridy=2;// y坐标3列位置
    		c.add(new JButton("按钮3"),g_2);// 容器里加“按钮3”,约束为“g_2”
    	}
    
    	public static void main(String[] args){
    		Demo d=new Demo();// 创建一个新类型d
    		d.way1();// 对d使用方法way1,创建一个窗体,包括布局参数等
    		d.way2();// 对d使用方法way2,容器里的按钮等
    
    		d.f.setVisible(true);// 类型d、窗体可见,为真
    	}
    }

    2、源码A运行效果

    (二)、源码B(源码A基础上添加方法way3、way4)

    1、源码B说明

            为更直观显示效果,创建一个矩阵,源码B中的方法way3。由多个“按钮”组成的,类似与表格的9行、9列的矩阵,效果由后面源码B运行效果图片看出。

            使用方法way4,显示坐标2-2、3-3、4-4、5-6。坐标(x-y)。具体效果由后面源码B的运行的含有“列”“行”的“按钮”显示。

    /**所想:
        网格组布局
    */
    
    /*
    	引入的包,以下的import等等
    */
    import java.awt.GridBagConstraints;// Constraints(限制) 
    import java.awt.GridBagLayout;//网格包
    import java.awt.Container;// 容器
    import java.awt.Color;// 颜色
    
    import javax.swing.JFrame; // 窗体
    import javax.swing.JButton;// 按钮
    import javax.swing.JPanel;// java面板
    
    class Demo{
    	JFrame f=new JFrame();// 设置主窗体
    	Container c;// 主容器
    
    	/*	
    		方法way1
    		创建一个新方法way1,设置窗体的规格
    		Content(容器),Pane(镶嵌),Grid(网格),Bag(包),Layout(布局)
    	*/
    	void way1(){
    		// Content(容器),Pane(镶嵌),layout(布局)
    		c=f.getContentPane();//容器c镶嵌于窗体中
    		c.setLayout(new GridBagLayout());// 容器c建立网格包布局
    		f.setSize(1000,800);// 设置窗体宽、高
    
    		// location(位置),Relative(相对于),括号里为某“组件”参数,为null时窗体在桌面居中显示
    		f.setLocationRelativeTo(null);// 窗体在桌面居中显示,null(空值)
    
    		// Default(默认),operation(操作),点击×程序便停止运行
    		f.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
    	}
    	
    	/*
    		方法way2
    		创建一个新方法way2,将3个按钮限制于x,y坐标为1-1,2-2,3-3的布局中
    		主要使用:gridx及gridy,网格坐标的意思	
    	*/
    	void way2(){
    		// Grid(网格),Bag(包),Constraints(限制)
    		GridBagConstraints g_0=new GridBagConstraints();// 创建一个网格包约束条件g_0
    		g_0.gridx=0;// x坐标1行位置,计算机以0为第一个
    		g_0.gridy=0;// y坐标1列位置
    		c.add(new JButton("按钮1"),g_0);// 在容器里创建一个“按钮1”,约束条件“g_0”
    
    		GridBagConstraints g_1=new GridBagConstraints();// 约束“g_1”
    		g_1.gridx=1;// x坐标2行位置
    		g_1.gridy=1;// y坐标2列位置
    		c.add(new JButton("按钮2"),g_1);// 容器里加“按钮2”,约束为“g_1”
    		
    		GridBagConstraints g_2=new GridBagConstraints();//约束“g_2”
    		g_2.gridx=2;// x坐标3行位置
    		g_2.gridy=2;// y坐标3列位置
    		c.add(new JButton("按钮3"),g_2);// 容器里加“按钮3”,约束为“g_2”
    	}
    
    	/*
    		方法way4
    		创建三个按钮,按钮名称及x、y轴的位置
    		按钮1	2-2
    		按钮2	3-3
    		按钮3	4-4
    		按钮4	5-6
    	*/
    	void way4(){
    		GridBagConstraints g_1=new GridBagConstraints();// 创建一个网格包约束条件g_1
    		g_1.gridx=1;// x坐标第2行,0开始
    		g_1.gridy=1;// y坐标第2列
    		c.add(new JButton("按钮1,坐标2-2"),g_1);// 容器c里添加“按钮1”,约束为“g_1”
    
    		GridBagConstraints g_2=new GridBagConstraints();// 创建一个网格包约束条件g_2
    		g_2.gridx=2;// x坐标第3行,0开始
    		g_2.gridy=2;// y坐标第3列
    		c.add(new JButton("按钮2,坐标3-3"),g_2);// 容器c里添加“按钮2”,约束为“g_2”
    
    		GridBagConstraints g_3=new GridBagConstraints();// 创建一个网格包约束条件g_3
    		g_3.gridx=3;// x坐标第4行,0开始数
    		g_3.gridy=3;// y坐标第4列
    		c.add(new JButton("按钮3,坐标4-4"),g_3);// 容器c里添加“按钮3”,约束为“g_4”
    
    		GridBagConstraints g_4=new GridBagConstraints();// 创建一个网格包约束条件g_4
    		g_4.gridx=4;// x坐标5行,0开始数
    		g_4.gridy=5;// y坐标6列
    		c.add(new JButton("按钮4,坐标5-6"),g_4);// 容器c里添加“按钮4”,约束为“g_4”
    	}
    
    	/*
    		方法way3
    		创建一个方法way3,创建一个按钮矩阵,类似表格,用以
    	对照后面放进去的其他“限制”按钮,设置一个行数与列数相同
    	的矩阵,以供参考。设置行数列数不对等显示按钮会有些按钮显示
    	错位。
    	*/
    	void way3(){
    		for(int i_0=0;i_0<9;i_0++){
    			// Grid(网格),Bag(包),Constraints(限制)
    			GridBagConstraints g_0=new GridBagConstraints();// 创建一个网格包约束条件g_0
    			g_0.gridx=i_0;
    			g_0.gridy=0;// y轴第一列
    			c.add(new JButton(i_0+1+"行"),g_0);// 添加i+1个按钮,横向排序
    		}
    		for(int i_1=1;i_1<9;i_1++){
    			GridBagConstraints g_1=new GridBagConstraints();// 说明参考上
    			g_1.gridx=0;
    			g_1.gridy=i_1;// x轴第一列
    			c.add(new JButton(i_1+1+"列"),g_1);
    		}
    	}
    
    
    	public static void main(String[] args){
    		Demo d=new Demo();// 创建一个新类型d
    		d.way1();// 对d使用方法way1,创建一个窗体,包括布局参数等
    		//d.way2();// 对d使用方法way2,容器里的按钮等
    		d.way3();// 方法way3,按钮矩阵,参照用
    		d.way4();// 方法way4,坐标分别为2-2,3-3,4-4的“按钮”
    
    		d.f.setVisible(true);// 类型d、窗体可见,为真
    	}
    }

    2、源码B的运行效果

    (三)、源码C(源码B的基础上添加方法way4)

    1、源码C说明

            源码C方法way4为三个“按钮”相对于方法way2多添加了构件的“尺寸”约束条件。具体可观察下方的源码C的运行效果。按钮1和按钮2的坐标、尺寸的约束数据作为按钮的名称。各使用矩形框(a、b、c、d、e、f)框选了按钮所对应的坐标及尺寸。

           为更直观看到效果,单独对按钮3(名称:“0.0”)另外添加了一个红色的“标签”背景,以方便看出按钮3(名称:“0.0”)在后面fill属性约束条件下的表现效果。 对于按钮3名称选择为“0.0”,为更直观的显示,按钮的名称太长容易影响尺寸、坐标的判断。由源码C方法way4中的数据按钮3(名为:“0.0”)的坐标为4-4,尺寸为2-3。源码C中的按钮3(“0.0”)默认状态为上下左右居中。对于按钮3的fill属性(水平填充、垂直填充、上下左右填充)的相关代码已写于源码C方法way4中,暂处于注释状态,用于后面说明使用。

    /**所想:
        网格组布局
    */
    
    /*
    	引入的包,以下的import等等
    */
    import java.awt.GridBagConstraints;// Constraints(限制) 
    import java.awt.GridBagLayout;//网格包
    import java.awt.Container;// 容器
    import java.awt.Color;// 颜色
    
    import javax.swing.JFrame; // 窗体
    import javax.swing.JButton;// 按钮
    import javax.swing.JPanel;// java面板
    
    class Demo{
    	JFrame f=new JFrame();// 设置主窗体
    	Container c;// 主容器
    
    	/*	
    		方法way1
    		创建一个新方法way1,设置窗体的规格
    		Content(容器),Pane(镶嵌),Grid(网格),Bag(包),Layout(布局)
    	*/
    	void way1(){
    		// Content(容器),Pane(镶嵌),layout(布局)
    		c=f.getContentPane();//容器c镶嵌于窗体中
    		c.setLayout(new GridBagLayout());// 容器c建立网格包布局
    		f.setSize(1000,800);// 设置窗体宽、高
    
    		// location(位置),Relative(相对于),括号里为某“组件”参数,为null时窗体在桌面居中显示
    		f.setLocationRelativeTo(null);// 窗体在桌面居中显示,null(空值)
    
    		// Default(默认),operation(操作),点击×程序便停止运行
    		f.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
    	}
    	
    	/*
    		方法way2
    		创建一个新方法way2,将3个按钮限制于x,y坐标为1-1,2-2,3-3的布局中
    		主要使用:gridx及gridy,网格坐标的意思	
    	*/
    	void way2(){
    		// Grid(网格),Bag(包),Constraints(限制)
    		GridBagConstraints g_0=new GridBagConstraints();// 创建一个网格包约束条件g_0
    		g_0.gridx=0;// x坐标1行位置,计算机以0为第一个
    		g_0.gridy=0;// y坐标1列位置
    		c.add(new JButton("按钮1"),g_0);// 在容器里创建一个“按钮1”,约束条件“g_0”
    
    		GridBagConstraints g_1=new GridBagConstraints();// 约束“g_1”
    		g_1.gridx=1;// x坐标2行位置
    		g_1.gridy=1;// y坐标2列位置
    		c.add(new JButton("按钮2"),g_1);// 容器里加“按钮2”,约束为“g_1”
    		
    		GridBagConstraints g_2=new GridBagConstraints();//约束“g_2”
    		g_2.gridx=2;// x坐标3行位置
    		g_2.gridy=2;// y坐标3列位置
    		c.add(new JButton("按钮3"),g_2);// 容器里加“按钮3”,约束为“g_2”
    	}
    
    	/*
    		方法way4
    		创建三个按钮,按钮名称及x、y轴的位置
    		按钮1	2-2
    		按钮2	3-3
    		按钮3	4-4
    		按钮4	5-6
    	*/
    	void way4(){
    		GridBagConstraints g_1=new GridBagConstraints();// 创建一个网格包约束条件g_1
    		g_1.gridx=1;// x坐标第2行,0开始
    		g_1.gridy=1;// y坐标第2列
    		c.add(new JButton("按钮1,坐标2-2"),g_1);// 容器c里添加“按钮1”,约束为“g_1”
    
    		GridBagConstraints g_2=new GridBagConstraints();// 创建一个网格包约束条件g_2
    		g_2.gridx=2;// x坐标第3行,0开始
    		g_2.gridy=2;// y坐标第3列
    		c.add(new JButton("按钮2,坐标3-3"),g_2);// 容器c里添加“按钮2”,约束为“g_2”
    
    		GridBagConstraints g_3=new GridBagConstraints();// 创建一个网格包约束条件g_3
    		g_3.gridx=3;// x坐标第4行,0开始数
    		g_3.gridy=3;// y坐标第4列
    		c.add(new JButton("按钮3,坐标4-4"),g_3);// 容器c里添加“按钮3”,约束为“g_4”
    
    		GridBagConstraints g_4=new GridBagConstraints();// 创建一个网格包约束条件g_4
    		g_4.gridx=4;// x坐标5行,0开始数
    		g_4.gridy=5;// y坐标6列
    		c.add(new JButton("按钮4,坐标5-6"),g_4);// 容器c里添加“按钮4”,约束为“g_4”
    	}
    
    	/*
    		方法way3
    		创建一个方法way3,创建一个按钮矩阵,类似表格,用以
    	对照后面放进去的其他“限制”按钮,设置一个行数与列数相同
    	的矩阵,以供参考。设置行数列数不对等显示按钮会有些按钮显示
    	错位。
    	*/
    	void way3(){
    		for(int i_0=0;i_0<9;i_0++){
    			// Grid(网格),Bag(包),Constraints(限制)
    			GridBagConstraints g_0=new GridBagConstraints();// 创建一个网格包约束条件g_0
    			g_0.gridx=i_0;
    			g_0.gridy=0;// y轴第一列
    			c.add(new JButton(i_0+1+"行"),g_0);// 添加i+1个按钮,横向排序
    		}
    		for(int i_1=1;i_1<9;i_1++){
    			GridBagConstraints g_1=new GridBagConstraints();// 说明参考上
    			g_1.gridx=0;
    			g_1.gridy=i_1;// x轴第一列
    			c.add(new JButton(i_1+1+"列"),g_1);
    		}
    	}
    
    	/*
    		方法way05
    		按钮 添加约束条件,指定坐标、尺寸
    		填充(fill)属性,全填充(BOTH),垂直(vertical)填充,水平(horizontal)填充
    		g_3添加一面板,以对照观察用
    	*/
    	void way5(){
    		GridBagConstraints g_1=new GridBagConstraints();// 创建一个网格包约束条件g_1
    		g_1.gridx=1;// x坐标
    		g_1.gridy=1;// y坐标
    		g_1.gridwidth=1;// 宽度
    		g_1.gridheight=2;// 高度
    		//g_1.fill=GridBagConstraints.BOTH;// 按钮填充方式,全全填充
    		c.add(new JButton("按钮1,坐标1-1,宽1高2"),g_1);// 添加按钮,约束对象g_1
    
    		GridBagConstraints g_2=new GridBagConstraints();// 创建一个网格包约束条件g_2
    		g_2.gridx=3;// x坐标
    		g_2.gridy=1;// y坐标
    		g_2.gridwidth=3;// 宽度
    		g_2.gridheight=1;// 高度
    		//g_2.fill=GridBagConstraints.BOTH;// 按钮填充方式,全全填充
    		c.add(new JButton("按钮2,坐标3-1,宽3高1"),g_2);// 容器c里添加按钮,约束为g_2
    
    		GridBagConstraints g_3=new GridBagConstraints();// 创建一个网格包约束条件g_3
    		g_3.gridx=4;// x坐标
    		g_3.gridy=4;// y坐标
    		g_3.gridwidth=2;// 宽度
    		g_3.gridheight=3;// 高度
    		//g_3.fill=GridBagConstraints.BOTH;// 按钮填充方式,全全填充
    		//g_3.fill=GridBagConstraints.VERTICAL;// 填充方式,垂直填充
    		//g_3.fill=GridBagConstraints.HORIZONTAL;// 填充方式,水平填充
    		c.add(new JButton("0.0"),g_3);// 容器c里添加按钮3,约束为g_3
    
    		g_3.fill=GridBagConstraints.BOTH;// 给g_3约束条件,全填充
    		JPanel p_1=new JPanel();// 新建面板(Panel),需要在前面添加import javax.swing.JPanel;
    		p_1.setBackground(Color.red);// 面板p_1的背景(颜色),需要在前面添加import java.awt.Color;
    		c.add(p_1,g_3);// 容器c里添加面板p_1,约束条件为g_3
    	}
    
    	public static void main(String[] args){
    		Demo d=new Demo();// 创建一个新类型d
    		d.way1();// 对d使用方法way1,创建一个窗体,包括布局参数等
    		//d.way2();// 对d使用方法way2,容器里的按钮等
    		d.way3();// 方法way3,按钮矩阵,参照用
    		//d.way4();// 方法way4,坐标分别为2-2,3-3,4-4的“按钮”
    
    		d.way5();// 对d使用方法way5,在方法way4的基础上添加了尺寸宽和高
    
    		d.f.setVisible(true);// 类型d、窗体可见,为真
    	}
    }

    2、源码C的运行效果

    (四)、源码C关于fill属性的运行效果

    1-1、全填充(BOTH):

            将源码C的方法way4中显示按钮3(名称:“0.0”)的上下左右填充(全填充)效果。

            关键词:BOTH

            将源码C中方法way4中的的如下代码

    //g_3.fill=GridBagConstraints.BOTH;// 按钮填充方式,全全填充

            取消注释为如下

    g_3.fill=GridBagConstraints.BOTH;// 按钮填充方式,全全填充

    1-2、按钮3(名为:0.0)全填充(BOTH)的运行效果:

    2-1、垂直填充(VERTICAL):

            与上1-1同理,将源码C的方法way4中显示按钮3(名称:“0.0”)的垂直填充效果。

            关键词:VERTICAL

            将源码C中方法way4中的的如下代码

    //g_3.fill=GridBagConstraints.VERTICAL;// 填充方式,垂直填充

            取消注释为如下

    g_3.fill=GridBagConstraints.VERTICAL;// 填充方式,垂直填充

    2-2、按钮3(名为:“0.0”)垂直填充(VERTICAL)的运行效果:

    3-1、水平填充(HORIZONTAL):

            与上1-1同理,将源码C的方法way4中显示按钮3(名称:“0.0”)的水平填充效果。

            关键词:HORIZONTAL

            将源码C中方法way4中的的如下代码

    //g_3.fill=GridBagConstraints.HORIZONTAL;// 填充方式,水平填充

            取消注释为如下

    g_3.fill=GridBagConstraints.HORIZONTAL;// 填充方式,水平填充

    3-2、按钮3(名为:“0.0”)水平填充(HORIZONTAL)的运行效果:

    三、定位日期

    2022.3.8;23:16;因时间问题未编写完,第二天继续

    2022.3.9;21:29

    展开全文
  • 一、水平/垂直/网格布局简介 水平布局:在水平方向上排列控件 垂直布局:在垂直方向上排列控件 网格布局:多行多列 二、水平/垂直/网格布局实现 1)水平布局【QHBoxLayout *layout = new QHBoxLayout;】 ...

    一、水平/垂直/网格布局简介

    1. 水平布局:在水平方向上排列控件
    2. 垂直布局:在垂直方向上排列控件
    3. 网格布局:多行多列

    二、水平/垂直/网格布局实现

    1)水平布局【QHBoxLayout *layout = new QHBoxLayout;

        QWidget *window = new QWidget;
        QPushButton *button1=new QPushButton("OK");
        QPushButton *button2=new QPushButton("cancel");
        window->setWindowTitle("Enter Your Name");
        QHBoxLayout *layout = new QHBoxLayout;
        layout->addWidget(button1);
        layout->addWidget(button2);
        window->setLayout(layout);
        window->show();

    2)垂直布局【QVBoxLayout *layout = new QVBoxLayout;

        QWidget *window = new QWidget;
        QPushButton *button1=new QPushButton("OK");
        QPushButton *button2=new QPushButton("cancel");
        window->setWindowTitle("Enter Your Name");
        QVBoxLayout *layout = new QVBoxLayout;
        layout->addWidget(button1);
        layout->addWidget(button2);
        window->setLayout(layout);
        window->show();

     

    1)设置外边距:

    ①setMargin(int)
    ②setContentsMargins(int left, int top, int right, int bottom);
    ③setContentsMargins(const QMargins &margins)
    以上setMargin设置的外边距是相同的;setContentsMargins可以将左、上、右、下的外边距设置为不同的值。

    2)设置间距:setSpacing(int)

    3)添加了一个伸缩空间:addStretch() 

    4)拉伸按钮宽度:setStretchFactor(btn, 2);

    5)添加控件:addWidget(QWidget *, int stretch = 0, Qt::Alignment alignment = 0)【默认的,我们添加控件至水平布局中且垂直方向居中对齐。】

    网格布局基本原理:是把窗口划分为若干个网状的单元格,每个子部件被放置于一个或多个单元格之中,各单元格的大小可由一行或列中单元格的数量来确定,若子部件的大小(由sizeHint()确定)小于单元格,则可以设置该子部件位于单元格的什么位置,还可设置该子部件是否可以拉伸以填满该单元格等等。

     

     网格布局登录界面效果图:

     

    源码如下:

    
        this->setWindowTitle("登录界面");
    
        //设置窗体图标
        QPixmap pix;
        pix.load(":/IQY/win_icon.png");
        qreal w=pix.width();
        qreal h=pix.height();
        //给定的矩形内保持宽高的比值不变
        pix=pix.scaled(w*0.5,h*0.5,Qt::KeepAspectRatio);
        this->setWindowIcon(pix);
    
    
        //创建控件
        imgLab = new QLabel(this);
        nameEdit = new QLineEdit(this);
        pwdEdit = new QLineEdit(this);
        rememberCheckBox = new QCheckBox(this);
        autoLoginCheckBox = new QCheckBox(this);
        loginBtn = new QPushButton(this);
        registerBtn = new QPushButton(this);
        forgotBtn = new QPushButton(this);
        loginBtn->setFixedHeight(30);
        nameEdit->setFixedWidth(200);
    
        // 设置logo
        QPixmap pixmap2(":/IQY/win_icon.png");
        imgLab->setFixedSize(90, 90);
        imgLab->setPixmap(pixmap2);
        imgLab->setScaledContents(true);
    
        // 文本
        nameEdit->setPlaceholderText(QStringLiteral("爱奇艺账号/手机号"));
        pwdEdit->setPlaceholderText(QStringLiteral("密码"));
        pwdEdit->setEchoMode(QLineEdit::Password);
        rememberCheckBox->setText(QStringLiteral("记住密码"));
        autoLoginCheckBox->setText(QStringLiteral("自动登录"));
        loginBtn->setText(QStringLiteral("登录"));
        registerBtn->setText(QStringLiteral("注册账号"));
        forgotBtn->setText(QStringLiteral("找回密码"));
    
        QGridLayout *pLayout = new QGridLayout();
        // logo 第0行,第0列开始,占3行1列
        pLayout->addWidget(imgLab, 0, 0, 3, 1);
        // 用户名输入框 第0行,第1列开始,占1行2列
        pLayout->addWidget(nameEdit, 0, 1, 1, 2);
        pLayout->addWidget(registerBtn, 0, 4);
        // 密码输入框 第1行,第1列开始,占1行2列
        pLayout->addWidget(pwdEdit, 1, 1, 1, 2);
        pLayout->addWidget(forgotBtn, 1, 4);
        // 记住密码 第2行,第1列开始,占1行1列 水平居左 垂直居中
        pLayout->addWidget(rememberCheckBox, 2, 1, 1, 1, Qt::AlignLeft | Qt::AlignVCenter);
        // 自动登录 第2行,第2列开始,占1行1列 水平居右 垂直居中
        pLayout->addWidget(autoLoginCheckBox, 2, 2, 1, 1, Qt::AlignRight | Qt::AlignVCenter);
        // 登录按钮 第3行,第1列开始,占1行2列
        pLayout->addWidget(loginBtn, 3, 1, 1, 2);
        // 设置水平间距
        pLayout->setHorizontalSpacing(20);
        // 设置垂直间距
        pLayout->setVerticalSpacing(20);
        // 设置外间距
        pLayout->setContentsMargins(80, 80, 80, 80);
        setLayout(pLayout);
    
        //槽函数
        connect(loginBtn,SIGNAL(clicked(bool)),this,SLOT(GotoLogin()));
        connect(registerBtn,SIGNAL(clicked(bool)),this,SLOT(GotoRegist()));

    参考文献:

    Qt 之格栅布局(QGridLayout)_君莫笑的博客-CSDN博客_qt网格布局

     

    展开全文
  • GridLayout(网格布局) ​ GridLayout 布局管理器将容器分割成纵横线分隔的网格 , 每个网格所占的区域大小相同。当向使用 GridLayout 布局管理器的容器添加组件时, 默认从左向右、 从上向下依次添加到每个网格...

    GridLayout(网格布局)

    ​ GridLayout 布局管理器将容器分割成纵横线分隔的网格 , 每个网格所占的区域大小相同。当向使用 GridLayout 布局管理器的容器中添加组件时, 默认从左向右、 从上向下依次添加到每个网格中 。 与 FlowLayout不同的是,放置在 GridLayout 布局管理器中的各组件的大小由组件所处的区域决定(每 个组件将自动占满整个区域) 。

    构造方法方法功能
    GridLayout(int rows,in t cols)采用指定的行数、列数,以及默认的横向间距、纵向间距将容器 分割成多个网格
    GridLayout(int rows,int cols,int hgap,int vgap)采用指定 的行数、列 数 ,以及指定的横向间距 、 纵向间距将容器分割成多个网格。

    案例:

    ​ 使用Frame+Panel,配合FlowLayout和GridLayout完成一个计算器效果。

    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-hloEdvRs-1612002352981)(./images/计算器.jpg)]

    代码:

    import java.awt.*;
    
    public class GridLayoutDemo{
    
        public static void main(String[] args) {
    
            //1.创建Frame对象,并且标题设置为计算器
            Frame frame = new Frame("计算器");
    
            //2.创建一个Panel对象,并且往Panel中放置一个TextField组件
            Panel p1 = new Panel();
            p1.add(new TextField(30));
    
            //3.把上述的Panel放入到Frame的北侧区域
            frame.add(p1,BorderLayout.NORTH);
    
            //4.创建一个Panel对象,并且设置其布局管理器为GridLayout
            Panel p2 = new Panel();
            p2.setLayout(new GridLayout(3,5,4,4));
    
            //5.往上述Panel中,放置15个按钮,内容依次是:0,1,2,3,4,5,6,7,8,9,+,-,*,/,.
            for (int i = 0; i < 10; i++) {
                p2.add(new Button(i+""));
            }
            p2.add(new Button("+"));
            p2.add(new Button("-"));
            p2.add(new Button("*"));
            p2.add(new Button("/"));
            p2.add(new Button("."));
    
            //6.把上述Panel添加到Frame的中间区域中国
            frame.add(p2);
            //7.设置Frame为最佳大小
            frame.pack();
    
            //8.设置Frame可见
            frame.setVisible(true);
    
        }
    }
    

    在这里插入图片描述

    GridBagLayout

    GridBagLayout 布局管理器的功能最强大 , 但也最复杂,与 GridLayout 布局管理器不同的是, 在GridBagLayout 布局管理器中,一个组件可以跨越一个或多个网格 , 并可以设置各网格的大小互不相同,从而增加了布局的灵活性 。 当窗口的大小发生变化时 , GridBagLayout 布局管理器也可以准确地控制窗口各部分的拉伸 。

    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-3bKcIFuS-1612002352996)(./images/GridBagLayout.png)]

    由于在GridBagLayout 布局中,每个组件可以占用多个网格,此时,我们往容器中添加组件的时候,就需要具体的控制每个组件占用多少个网格,java提供的GridBagConstaints类,与特定的组件绑定,可以完成具体大小和跨越性的设置。

    GridBagConstraints API:

    成员变量含义
    gridx设置受该对象控制的GUI组件左上角所在网格的横向索引
    gridy设置受该对象控制的GUI组件左上角所在网格的纵向索引
    gridwidth设置受该对象控制的 GUI 组件横向跨越多少个网格,如果属性值为 GridBagContraints.REMAIND,则表明当前组件是横向最后一个组件,如果属性值为GridBagConstraints.RELATIVE,表明当前组件是横向倒数第二个组件。
    gridheight设置受该对象控制的 GUI 组件纵向跨越多少个网格,如果属性值为 GridBagContraints.REMAIND,则表明当前组件是纵向最后一个组件,如果属性值为GridBagConstraints.RELATIVE,表明当前组件是纵向倒数第二个组件。
    fill当"显示区域"大于"组件"的时候,如何调整组件 :
    GridBagConstraints.NONE : GUI 组件不扩大
    GridBagConstraints.HORIZONTAL: GUI 组件水平扩大 以 占据空白区域
    GridBagConstraints.VERTICAL: GUI 组件垂直扩大以占据空白区域
    GridBagConstraints.BOTH: GUI 组件水平 、 垂直同时扩大以占据空白区域.
    ipadx设置受该对象控制的 GUI 组件横向内部填充的大小,即 在该组件最小尺寸的基础上还需要增大多少.
    ipady设置受该对象控制的 GUI 组件纵向内部填充的大小,即 在该组件最小尺寸的基础上还需要增大多少.
    insets设置受该对象控制 的 GUI 组件的 外部填充的大小 , 即该组件边界和显示区 域边界之间的 距离 .
    weightx设置受该对象控制 的 GUI 组件占据多余空间的水平比例, 假设某个容器 的水平线上包括三个 GUI 组件, 它们的水平增加比例分别是 1 、 2 、 3 , 但容器宽度增加 60 像素 时,则第一个组件宽度增加 10 像素 , 第二个组件宽度增加 20 像素,第三个组件宽度增加 30 像 素。 如 果其增 加比例为 0 , 则 表示不会增加 。
    weighty设置受该对象控制 的 GUI 组件占据多余空间的垂直比例
    anchor设置受该对象控制 的 GUI 组件在其显示区域中的定位方式:
    GridBagConstraints .CENTER (中 间 )
    GridBagConstraints.NORTH (上中 )
    GridBagConstraints.NORTHWEST (左上角)
    GridBagConstraints.NORTHEAST (右上角)
    GridBagConstraints.SOUTH (下中)
    GridBagConstraints.SOUTHEAST (右下角)
    GridBagConstraints.SOUTHWEST (左下角)
    GridBagConstraints.EAST (右中)
    GridBagConstraints.WEST (左中)

    GridBagLayout使用步骤:

    1.创建GridBagLaout布局管理器对象,并给容器设置该布局管理器对象;
    
    2.创建GridBagConstraints对象,并设置该对象的控制属性:
    
    	gridx: 用于指定组件在网格中所处的横向索引;
    
    	gridy: 用于执行组件在网格中所处的纵向索引;
    
    	gridwidth: 用于指定组件横向跨越多少个网格;
    
    	gridheight: 用于指定组件纵向跨越多少个网格;
    
    3.调用GridBagLayout对象的setConstraints(Component c,GridBagConstraints gbc )方法,把即将要添加到容器中的组件c和GridBagConstraints对象关联起来;
    
    4. 把组件添加到容器中;
    

    案例:

    ​ 使用Frame容器,设置GridBagLayout布局管理器,实现下图中的效果:

    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-nDuuom6G-1612002352999)(./images/GridBagLayout.jpg)]

    演示代码:

    import java.awt.*;
    
    public class GridBagLayoutDemo {
    
        public static void main(String[] args) {
            //1.创建Frame对象
            Frame frame = new Frame("这里是GridBagLayout测试");
    
            //2.创建GridBagLayout对象
            GridBagLayout gbl = new GridBagLayout();
    
            //3.把Frame对象的布局管理器设置为GridBagLayout
            frame.setLayout(gbl);
    
            //4.创建GridBagConstraints对象
            GridBagConstraints gbc = new GridBagConstraints();
    
            //5.创建容量为10的Button数组
            Button[] bs = new Button[10];
    
            //6.遍历数组,初始化每一个Button
            for (int i = 0; i < bs.length; i++) {
                bs[i] = new Button("按钮"+(i+1));
            }
    
            //7.设置所有的GridBagConstraints对象的fill属性为GridBagConstraints.BOTH,当有空白区域时,组件自动扩大占满空白区域
            gbc.fill=GridBagConstraints.BOTH;
    
            //8.设置GridBagConstraints对象的weightx设置为1,表示横向扩展比例为1
            gbc.weightx=1;
    
            //9.往frame中添加数组中的前3个Button
            addComponent(frame,bs[0],gbl,gbc);
            addComponent(frame,bs[1],gbl,gbc);
            addComponent(frame,bs[2],gbl,gbc);
    
            //10.把GridBagConstraints的gridwidth设置为GridBagConstraints.REMAINDER,则表明当前组件是横向最后一个组件
            gbc.gridwidth=GridBagConstraints.REMAINDER;
    
            //11.把button数组中第四个按钮添加到frame中
            addComponent(frame,bs[3],gbl,gbc);
    
    
            //12.把GridBagConstraints的weighty设置为1,表示纵向扩展比例为1
            gbc.weighty=1;
    
            //13.把button数组中第5个按钮添加到frame中
            addComponent(frame,bs[4],gbl,gbc);
    
            //14.把GridBagConstaints的gridheight和gridwidth设置为2,表示纵向和横向会占用两个网格
            gbc.gridheight=2;
            gbc.gridwidth=2;
    
            //15.把button数组中第6个按钮添加到frame中
            addComponent(frame,bs[5],gbl,gbc);
    
            //16.把GridBagConstaints的gridheight和gridwidth设置为1,表示纵向会占用1个网格
            gbc.gridwidth=1;
            gbc.gridheight=1;
            //17.把button数组中第7个按钮添加到frame中
            addComponent(frame,bs[6],gbl,gbc);
    
            //18.把GridBagConstraints的gridwidth设置为GridBagConstraints.REMAINDER,则表明当前组件是横向最后一个组件
            gbc.gridwidth=GridBagConstraints.REMAINDER;
    
            //19.把button数组中第8个按钮添加到frame中
            addComponent(frame,bs[7],gbl,gbc);
    
            //20.把GridBagConstaints的gridwidth设置为1,表示纵向会占用1个网格
            gbc.gridwidth=1;
    
            //21.把button数组中第9、10个按钮添加到frame中
            addComponent(frame,bs[8],gbl,gbc);
            addComponent(frame,bs[9],gbl,gbc);
    
            //22.设置frame为最佳大小
            frame.pack();
    
            //23.设置frame可见
            frame.setVisible(true);
        }
    
        public static void addComponent(Container container,Component c,GridBagLayout gridBagLayout,GridBagConstraints gridBagConstraints){
            gridBagLayout.setConstraints(c,gridBagConstraints);
            container.add(c);
        }
    }
    

    在这里插入图片描述

    展开全文
  • Qt布局管理器之网格布局(QGridLayout)

    千次阅读 2019-08-16 11:41:42
    Qt网格布局和水平、垂直布局类似,QGridLayout将控件布局在网格。QGridLayout和QHBoxLayout类似,可以插入Widget、插入子Layout、设置拉伸系数等,不同的是QGridLayout多了一个行、列的概念。在插入widget、插入子...
  • 网格布局特点:l 使容器的各组件呈M行×N列的网格状分布。l 网格每列宽度相同,等于容器的宽度除以网格的列数。l 网格每行高度相同,等于容器的高度除以网格的行数。l 各组件的排列方式为:从上到下,从左到右。l ...
  • 1.1 相对布局窗口内子组件的位置总是相对兄弟组件、父容器来决定的,因此叫相对布局 1.2 id型 @+id和@id的区别 @+id/x1(添加新ID) @id/x1(引用此ID) 相对于指定元素(根据ID指定) 1.3 layout_toRightOf,layout_...
  • 网格布局的使用方法 启用网格布局display: grid 划分列grid-template-columns 绝对值 px 百分比值 % 比例值 fr auto值 minmax()函数值 repeat()函数值 划分行grid-template-rows 自动填充auto-fill 给...
  • 如果您以前对CSS网格没有任何了解,请查看我们的初学者系列文章了解CSS网格布局模块 。 让我们开始! 1.基本注册表格 在此布局,我们将表单分为两列,以便我们在左侧显示标签,在右侧显示输入字段。 使用...
  • Pyqt学习笔记(2) ----- 创建三个按钮,进行水平布局并添加事件 # -*- coding:utf-8 -*- # Time : 2021/03/31 下午 14:06 # Author : ncs # e-mail:1437307741@qq.com # project: PyQt5 # File : 布局.py # @...
  • //登录 按钮 //网格布局 整体居中 gp.setAlignment(Pos.CENTER);//Pos->Position 位置 gp.setHgap(15);//H:水平 水平间距 px gp.setVgap(15);//V:垂直 垂直间距 px //点击事件: login 登录 b....
  • 此功能参考http://www.datouwang.com/jiaoben/761.html的资源,感谢!此参数的说明参考自https://www.cnblogs.com/JealousGirl/p/useGridster.html,感谢!页面效果 拖动后效果 具体实现:EasyUI Draggable 测试...
  • Qt基本布局(水平/垂直/网格

    千次阅读 2020-11-09 23:28:27
    基本布局(水平/垂直/网格) (QHBoxLayout类/ QVBoxLayout类/ QGridLayout类) 涉及函数/方法: addWidget( )方法:加入控件; addLayout( )方法:加入子布局。 实例功能:用户信息修改 1【导航页】 2【基本信息...
  • 1.界面设计 采用书本代码设计页面。 2.功能设计 按照按钮点击事件的套路...每按一个按钮,只要满足要求,不是错误的输入,就调用append()方法,将按钮的值当字符存入这个字符串,当用户按到等号时,调用另一个...
  • Android布局概述

    2021-06-02 17:21:57
    您可以通过两种方式声明布局:在 XML 声明 UI 元素。Android 提供了对应于 View 类及其子类的简明 XML 词汇,如用于小部件和布局的词汇; 运行时实例化布局元素。您的应用可以通过编程创建 View 对象和 ViewGroup ...
  • import javax.swing.JFrame; import javax.swing.JButton; import java.awt.BorderLayout; import java.awt.FlowLayout;...//按钮组件的声明 My(){ setTitle("我的窗体"); //设置窗体的大小 setSize(3
  • 一旦小部件被插入布局中,就不可能单独移动和调整它们的大小,因为布局本身控制则其中每个小部件的几何图形,并考虑了间接符提供的提示。可以在布局中添加间隔符来影响表不见的几何图形。 布局可以嵌套以形成层次...
  • Android Studio 工具栏添加常用按钮

    千次阅读 2021-06-02 14:37:10
    在工具栏添加一些常用的按钮,如设置、DDMS,有利于提高我们的开发效率,举例说明:设置后的菜单栏和工具栏,如图常用的 DDMS 在新版本的工具栏找不到,当然我们也可以通过 Tools --> Android --> Android ...
  • 我是用线性布局,中间插入网格布局。并将方向设置为垂直, &amp;lt;TextView android:layout_width=&quot;match_parent&quot; android:layout_height=&quot;50dp&quot; android:...
  • JAVA容器类与布局

    2021-03-14 19:01:14
    GridLayout——网格布局:1) 网格顾名思义就是纵横分割大小一样的格网,每个格子都是矩形的,且大小相等,每个格子只能存放一个组件;2) 构造器:最大的特点就是必须指定格网是几行几列的i. 指定行列:GridLayout...
  • 网格布局wx.GridSizer即由行列组成的二维表格的布局方式。在GridSizer,可以定义表格的行列数目,以及单元格之间的横竖间距,它通过AddMany()方法,按照从左到右从上到下方的顺序,一次性插入多个组件,它的语法为...
  • 在 wxPython ,可以使用绝对定位或使用 sizer 来布局小组件。绝对定位程序员以像素为单位指定每个小组件的位置和大小。绝对定位有几个缺点。如果我们调整窗口的大小,小组件的大小和位置不会改变。应用程序在不同...
  • Android之相对布局

    2021-06-03 01:41:17
    Android的布局分为六种,分别是相对布局、线性布局、表格布局、网格布局、帧布局、绝对布局,良好的布局设计对UI界面至关重要,下面先来看看先相对布局。相对布局(RelativeLayout):在Eclipse开发Android程序时,...
  • 最近想用RadioButton进行表格状的布局,但是研究之后发现android自带的...这篇博文里android自定义RadioGroup实现可以添加多种布局,博主自己重写了一个RadioGroup类,使其可以对子布局中的RadioButton进行查找,达...
  • 点击上方蓝字关注我们,更多惊喜等着你讲解视频1:页面布局、“插入”选项卡讲解视频2:表格部分考点梳理一、“设计”选项卡在Word2016,将传统的“页面布局”选项卡分为了“设计”和“布局”两个选项卡。...
  • 当您使用绝对定位时,我们必须了解以下限制:如果我们调整窗口大小,则小部件的大小和位置不会改变各种平台上的应用可能会有所不同在我们的应用程序更改字体可能会损坏布局如果我们决定改变我们的布局,我们必须...
  • layui的基本使用(布局,栅格,按钮)

    千次阅读 2021-08-22 14:16:57
    在浏览器输入https://www.layui.com/会出现以下界面 点击立即下载进行下载 下载后并进行解压 2.layui目录结构 二.layui基本使用 1.引入核心文件 <head> <meta charset="UTF-8"> <title&...
  • Qt使用绝对定位的布局方式无法自适应窗口的变化,因此Qt提供了对界面组件进行布局管理的类,用于对界面组件进行管理,能够自动排列窗口的界面组件,窗口大小变化后自动更新界面组件的大小。 QLayout是Qt...
  • Qt——布局

    2022-01-11 11:28:59
    Qt布局介绍:水平布局、垂直布局、栅格布局、表单布局、堆栈布局

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 5,852
精华内容 2,340
关键字:

网格布局中插入按钮