Swing是GUI（图形用户界面）开发工具包，包括容器、组件和布局等。

早期的AWT（抽象窗口工具包）组件开发的图形用户界面，要依赖本地系统，当把AWT组件开发的应用程序移植到其他平台的系统上运行时，不能保证其外观风格，因此AWT是依赖于本地系统平台的。而使用Swing开发的Java应用程序，其界面是不受本地系统平台限制的，也就是说Swing开发的Java应用程序移植到其他系统平台上时，其界面外观是不会改变的。但要注意的是，虽然Swing提供的组件可以方便开发Java应用程序，但是Swing并不能取代AWT，在开发Swing程序时通常要借助与AWT的一些对象来共同完成应用程序的设计。

一、常用窗体
　　Swing窗体是Swing的一个组件，同时也是创建图形化用户界面的容器，可以将其它组件放置在窗体容器中。

1. JFrame框架窗体
　　JFrame窗体是一个容器，在Swing开发中我们经常要用到，它是Swing程序中各个组件的载体。语法格式如下：

JFrame jf = new JFrame(title);

当然，在开发中更常用的方式是通过继承java.swing.JFrame类创建一个窗体，可通过this关键字调用其方法。

而在JFrame对象创建完成后，需要调用getContentPane()方法将窗体转换为容器，然后在容器中添加组件或设置布局管理器，通常这个容器用来包含和显示组件。如果需要将组件添加至容器，可以使用来自Container类的add()方法进行设置。至于JPanel容器会在后面提到。

下面举一个JFrame窗体的例子。

import javax.swing.JFrame;
import javax.swing.WindowConstants;

public class JFrameDemo {

    public void CreateJFrame() {
        JFrame jf = new JFrame("这是一个JFrame窗体");        // 实例化一个JFrame对象
        jf.setVisible(true);        // 设置窗体可视
        jf.setSize(500, 350);        // 设置窗体大小
        jf.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);        // 设置窗体关闭方式
    }

    public static void main(String[] args) {
        new JFrameDemo().CreateJFrame();        // 调用CreateJFrame()方法
    }

}

结果：
这就是一个500*350的窗体，用的是setSize()方法；标题为“这是一个JFrame窗体”，在实例化对象时就可以定义；窗体关闭方式见窗体右上角为“EXIT_ON_CLOSE”；窗体可视setVisible()方法中的参数为“false”或不写setVisible()方法时，此窗体不可见。

常用的窗体关闭方式有四种，分别为“DO_NOTHING_ON_CLOSE”、“DISPOSE_ON_CLOSE”、“HIDE_ON_CLOSE”、“EXIT_ON_CLOSE”。第一种表示什么也不做就将窗体关闭；第二种表示任何注册监听程序对象后会自动隐藏并释放窗体；第三种表示隐藏窗口的默认窗口关闭；第四种表示退出应用程序默认窗口关闭。
　　下面再举一个用继承JFrame的方式编写的代码，并加入Container容器及JLabel标签

import java.awt.Color;
import java.awt.Container;

import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.SwingConstants;
import javax.swing.WindowConstants;

public class JFrameDemo2 extends JFrame{

    public void init() {
        this.setVisible(true);        // 可视化
        this.setSize(500, 350);        // 大小
        this.setTitle("博客园");        // 标题
        this.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);        // 关闭方式

        JLabel jl = new JLabel("http://www.cnblogs.com/adamjwh/");        // 创建一个JLabel标签
        jl.setHorizontalAlignment(SwingConstants.CENTER);        // 使标签文字居中

        Container container = this.getContentPane();        // 获取一个容器
        container.add(jl);        // 将标签添加至容器
        container.setBackground(Color.YELLOW);        // 设置容器背景颜色
    }

    public static void main(String[] args) {
        new JFrameDemo2().init();
    }

}

结果：

这里继承了JFrame类，所以方法中实现时用this关键字即可（或直接实现，不加this）。12_{15行为创建JFrame框体；17、18行为JLabel标签，用与添加一个标签；20}22行为Container容器，用getContentPane()方法为JFrame窗体获取容器，并用add()方法将JLabel标签添加到容器上。

2. JDialog窗体
　　JDialog窗体是Swing组件中的对话框，继承了AWT组件中的java.awt.Dialog类。功能是从一个窗体中弹出另一个窗体。

下面来看一个实例：

import java.awt.Container;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;

import javax.swing.JButton;
import javax.swing.JDialog;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.WindowConstants;

public class JDialogDemo extends JDialog {        // 继承JDialog类

    public JDialogDemo() {
        super(new MyJFrame(), "这是一个JDialog窗体", true); // 实例化一个JDialog类对象，指定其父窗体、窗口标题和类型
        Container container = this.getContentPane();
        container.add(new JLabel("http://www.cnblogs.com/adamjwh/"));
        this.setSize(500, 350);
    }


    public static void main(String[] args) {
        new JDialogDemo();
    }

}

// 下面这部分内容包含监听器，可自行查阅资料
class MyJFrame extends JFrame {
    public MyJFrame() {
        this.setVisible(true);
        this.setSize(700, 500);
        this.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);

        Container container = this.getContentPane();
        container.setLayout(null);

        JButton jb = new JButton("点击弹出对话框");        // 创建按钮
        jb.setBounds(30, 30, 200, 50);        // 按钮位置及大小
        jb.addActionListener(new ActionListener() {        // 监听器，用于监听点击事件
            @Override
            public void actionPerformed(ActionEvent e) {
                new JDialogDemo().setVisible(true);
            }
        });
        container.add(jb);
    }
}

结果：
当我们点击按钮时，触发点击事件，这时执行第42行的语句，创建一个JDialog的实例化对象，弹出一个窗口。这里出现了许多我们之前学过的知识，比如super关键字，在之前提到过，这里相当于使用了JDialog(Frame f, String title, boolean model)形式的构造方法；监听器的实现就是一个匿名内部类。
二、标签组件
　　在Swing中显示文本或提示信息的方法是使用标签，它支持文本字符串和图标。上面我们提到的JLabel就是这里的内容。

1. 标签
　　标签由JLabel类定义，可以显示一行只读文本、一个图像或带图像的文本。

JLabel类提供了许多构造方法，可查看API选择需要的使用，如显示只有文本的标签、只有图标的标签或包含文本与图标的标签等。因为上面已经出现过了，这里就不再举例了。常用语法格式如下，创建的是一个不带图标和文本的JLabel对象：

JLabel jl = new JLabel();

2. 图标
　　Swing中的图标可以放置在按钮、标签等组件上，用于描述组件的用途。图标可以用Java支持的图片文件类型进行创建，也可以使用java.awt.Graphics类提供的功能方法来创建。

在Swing中通过Icon接口来创建图标，可以在创建时给定图标的大小、颜色等特性。注意，Icon是接口，在使用Icon接口的时候，必须实现Icon接口的三个方法：

public int getIconHeight()
public int getIconWidth()
public void paintIcon(Component arg0, Graphics arg1, int arg2, int arg3)

下面看一个用Icon接口创建图标的实例：

import java.awt.Component;
import java.awt.Container;
import java.awt.Graphics;

import javax.swing.Icon;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.SwingConstants;
import javax.swing.WindowConstants;

public class IconDemo extends JFrame implements Icon {

    private int width;        // 声明图标的宽
    private int height;        // 声明图标的长

    public IconDemo() {}        // 定义无参构造方法

    public IconDemo(int width, int height) {        // 定义有参构造方法
        this.width = width;
        this.height = height;
    }

    @Override
    public int getIconHeight() {        // 实现getIconHeight()方法
        return this.height;
    }

    @Override
    public int getIconWidth() {            // 实现getIconWidth()方法
        return this.width;
    }

    @Override
    public void paintIcon(Component arg0, Graphics arg1, int arg2, int arg3) {        // 实现paintIcon()方法
        arg1.fillOval(arg2, arg3, width, height);        // 绘制一个圆形
    }

    public void init() {    // 定义一个方法用于实现界面
        IconDemo iconDemo = new IconDemo(15, 15);        // 定义图标的长和宽
        JLabel jb = new JLabel("icon测试", iconDemo, SwingConstants.CENTER);    // 设置标签上的文字在标签正中间

        Container container = getContentPane();
        container.add(jb);

        this.setVisible(true);
        this.setSize(500, 350);
        this.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
    }

    public static void main(String[] args) {
        new IconDemo().init();
    }

}

Java SWing就是java提供的一个类库专门用于开发窗体程序的，相对于C#的winform，java swing的开发要比C#更加麻烦，他不像C#拥有可视化的界面编辑工具
而是需要像QT一样纯代码式GUI编程。java的好处就是通用性强，跨平台，这个java窗体程序做好之后，哪都可以用。然而C#的winform只能运行在有.net框架上
的平台，然而.net支持最好的，也就只有windows了。C#的开发效率更高

以下讲解Java swing的开发

（一）第一个java swing程序

    public static void main(String[] args)
    {
        //java Swing学习
        //生成窗口
        JFrame windows1=new JFrame("窗口1");
        JFrame windows2=new JFrame("窗口2");
        Container container1=windows1.getContentPane();//获得这个窗口的内容面板
        container1.setBackground(Color.blue);//设置背景颜色
        windows1.setBounds(60,100,188,108);//设置位置大小
        windows2.setBounds(260,100,188,108);
        windows1.setVisible(true);//可视性设置
        windows1.setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);//设置按x后的操作.[这个只是关闭那个窗口]
        windows2.setVisible(true);
        windows2.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);//设置按x后的操作.[这个是关闭整个程序,将会关闭所有窗口]
    }

需要注意的是，在设置位置和大小时，即setBounds，一共有4个参数，前面两个是坐标信息，即x，y坐标。对于屏幕坐标系，这个坐标原点在屏幕左上角，以下为y正轴，右为x正轴
还有就是DISPOSE_ON_CLOSE EXIT_ON_CLOSE的区别。
运行的效果如下

（二）带有菜单栏，菜单条，和子菜单的窗体程序

首先要知道几个常见类和函数
JMenuBar：代表菜单条，他需要被设置给JFrame窗体中
JMenu：代表菜单，他需要被放在菜单条中
JMenuItem：代表菜单项，续杯放在菜单中。
Icon：代表图标，使用new ImgeIcon（“文件路径”）;//使用绝对路径，这里由于是linux所以没有盘符
常用函数
JFrame：
setJMenuBar(JMenuBar menuBar)；//将菜单条设置给窗口
JMenu:
add(JMenuItem)；//在菜单中添加菜单项
add(JMenu)；//在菜单中添加子菜单
addSoearator()；//添加分割线
JMeunItem:
其的双参构造方法：第一个是菜单项名字，第二个是菜单项图标

    /**
     * 创建一个带菜单条，菜单项，子菜单的窗口
     */
    public class MainForm extends JFrame {
        JMenuBar menuBar;//菜单条
        JMenu menu1,menu2,submenu;//菜单
        JMenuItem item1,item2;//菜单项
    
        /**
         * 创建这个窗口的构造函数
         * @param title 窗口名字
         * @param posX X坐标
         * @param posY Y坐标
         * @param width 宽
         * @param height 高
         */
        public MainForm(String title,int posX,int posY,int width,int height)
        {
            init(title);
            
            //setIconImage();//设置窗体图标
            setLocation(posX,posY);//该函数继承至JFrame用于设置位置
            setSize(width,height);//该函数继承至JFrame用于设置大小
            setVisible(true);//同上，设置可视性
            setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);//同上，设置关闭时的操作
        }
    
        private void init(String title)
        {
            setTitle(title);//继承至JFrame,设置窗口标题
            menuBar =new JMenuBar();//实例化菜单条
            menu1=new JMenu("菜单1");//实例化菜单
            menu2=new JMenu("菜单2");//同上
            submenu=new JMenu("子菜单1");//同上
            item1=new JMenuItem("菜单项1",new ImageIcon("/home/zuikaku/图片/1.png"));//实例化菜单项并设置图标
            item2=new JMenuItem("菜单项2",new ImageIcon("/home/zuikaku/图片/1.png"));//实例化菜单项并设置图标
            item1.setAccelerator(KeyStroke.getKeyStroke('A'));//设置快捷键
            item2.setAccelerator(KeyStroke.getKeyStroke(KeyEvent.VK_S,KeyEvent.CTRL_MASK));//设置组合快捷键
            menu1.add(item1);//将菜单项添加入菜单中
            menu1.addSeparator();
            menu1.add(item2);//同上
            menu1.add(submenu);//将菜单加入菜单中，即作为其子菜单
            submenu.add(new JMenuItem("子菜单项1",new ImageIcon("/home/zuikaku/图片/1.png")));//子菜单中添加菜单项
            submenu.add(new JMenuItem("子菜单项2",new ImageIcon("/home/zuikaku/图片/1.png")));//子菜单中添加菜单项
            menuBar.add(menu1);//菜单条中添加菜单
            menuBar.add(menu2);//同上
            setJMenuBar(menuBar);//将该菜单条设置给这个窗口
        }
    
    }

实例化这个MainForm的效果就是

（三）Java Swing中的常用组件

组件的作用就是与人交互，他们就是用来显示提供给用户的信息或捕捉。这些组件都继承至JComponent
常用的有
JTextField:单行文本输入
JTextArea:多行文本输入
JButton:按钮
JLabel:标签，用于显示提示信息
JCheckBox:复选框
JRadioButton:单选框-需要归组后才能实现单选
JComboBox:下拉列表
JPasswordField:密码框
需要注意的是，这些组件new出来后，是不会显示的，要将其添加add到这个窗体中，才会显示

    /**
     * 展示java swing中的常见组件
     */
    public class UserInputForm extends JFrame{
        JLabel usernameLabel;
        JLabel passwordLabel;
        JLabel personalInfoLabel;
        JTextField usernameInput;
        JPasswordField passwordInput;
        JTextArea personalInputArea;
        JCheckBox checkBox1;
        JCheckBox checkBox2;
        JRadioButton men;
        JRadioButton women;
        JComboBox<String> countryComboBox;
        ButtonGroup buttonGroup;//用于单选框的归组
        JButton submitBtn;
        public UserInputForm(String title,int posX,int posY,int width,int height)
        {
            init();
            setTitle(title);
            setLocation(posX,posY);
            setSize(width,height);
            setVisible(true);
    
            setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);
        }
        private void init()
        {
            setLayout(new FlowLayout());//设置布局
            usernameLabel=new JLabel("用户名");
            passwordLabel=new JLabel("密码");
            personalInfoLabel=new JLabel("个人信息");
            usernameInput=new JTextField();
            passwordInput=new JPasswordField();
            personalInputArea=new JTextArea();
            checkBox1=new JCheckBox("哈哈");
            checkBox2=new JCheckBox("嘻嘻");
            men=new JRadioButton("男");
            women=new JRadioButton("女");
            buttonGroup=new ButtonGroup();
            buttonGroup.add(men);
            buttonGroup.add(women);
            countryComboBox=new JComboBox<String>();
            countryComboBox.addItem("下拉选项1");
            countryComboBox.addItem("下拉选项2");
            submitBtn=new JButton("提交");
            //将这些组件加入到这个窗口中-才可以显示
            add(usernameLabel);
            add(passwordLabel);
            add(personalInfoLabel);
            add(usernameInput);
            add(passwordInput);
            add(personalInputArea);
            add(checkBox1);
            add(checkBox2);
            add(men);
            add(women);
            add(countryComboBox);
            add(submitBtn);
        }
    }

效果如下

（四）常见容器(面板)【中间层容器】

刚刚是将所有的组件添加到继承至JFrame的类中，JFrame叫做底层容器，然而在实际开发和为了更好的使用【例如实现同一个窗口切换选项卡有不同的面板】
这些组件并不是直接添加在底层容器。而是添加到中间层容器。当然，这个中间层容器也必须添加到底层容器JFrame中才会启作用。否则显示不出来
即必须有一个类继承至JFrame，且这个类将面板或是布局，add进去。然后实例化这个继承至JFrame的类，才看的到。
1:JPanel面板：常用JPanel作为一个面板，最普通的面板，向该面板中添加组件。默认布局是FlowLayout
2:JTabbedPane可切换选项卡面板：特点，向该面板中添加组件时，会可以为这个组件添加选项卡。即通过选项卡可以切换不同的组件(也可以是子面板JPanel),相当于，第一个选项卡点击
显示第一个界面，第二个选项卡点击，不开新窗口，就在该窗口上显示第二个界面。使用add(String text,Component c);//这个函数来指定选项卡名字和组件之间的对应关系
选项卡的位置在构造JTabbedPane对象时可以指定，其构造函数参数为int类型，实际是一个静态常量，枚举表示的是选项卡的位置JTabbedPane.Bottom/Top/LEFT/RIGHT
3:JSrollPane滚动面板：其只可以添加一个组件，通常和JTextArea配合使用，作为文本输入栏的滚动条
JScrollPane scroll=new JScrollPanel(new JTextArea());

4:JSplitPane拆分面板：即面板分为两部分，可以按左右分割，左右各一个，也可以按上下分割，上下各一个
构造方法
JSplitPane splitPanel=new JSplitpanel(int a,Component b,Conponent c)；
其中a是个静态常量，代表是水平分割还是垂直，分别是JSplitpane.HORIZONTAL_SPLIT和JSplitpane.VERTICAL_SPLIT

5:JLayeredPane分层面板：用于处理组件重叠问题
需要注意的是，这个层并不是可以自己定义，和Unity的OrderInLayer和SortLayer不同。JavaSwing中总共就定义了5层，从低到高，分别是
DEFAULT_LAYER,PALETTE_LAYER,MODAL_LAYER,POPUP_LAYER,DRAG_LAYER
同一位置，高层的会覆盖显示底层的。对于同层的，后来的会覆盖新来的
//使用add(Component, layer)可以添加组件并设置值
setLayer(Component c,int layer))；//可以重新设置layer
getLayer(Component c)；//可以获得一个组件的Layer

（五）设置布局

即组件在面板上的布局
容器/面板通过调用setLayout(布局对象)来设置布局
1:FlowLayout布局：表示默认居中对齐，使用该布局方式的容器，用add函数向里面加组件，就会根据先后顺序从左向右排列，一行排完后就提行
使用该布局方式，组件自身的setSize将不会有用，要改变大小只能通过setPreferredSize(DimensionpreferredSize)
button.setPreferredSize(new Dimension(20,20)))

该布局方式的对齐方式可以更改，FlowLayout对象调用setAlignment(int align);//使用该函数修改对齐方式，传入的参数是一个静态常量，FlowLayout.LEFT,FlowLayout.CENTER
FlowLayout.RIGHT
2:BorderLayout布局：表示将这个容器划分为5个部分，东西南北中【上下左右中】
中间的区域最大，所加入的组件都应该指明其属于哪一个区域。东南西北中用静态常量表示的：分别是EAST.WEST,SOUTH,NORTH。
//使用方法
容器对象.add(组件对象,BorderLayout.East)

需要注意的是，使用这种布局方式，组件不能超过5个，同一个区域加入过多次组件以最后一次为准。如果一个区域实在需要多个组件
那么就用嵌套的方式，即加个面板进去，再这个面板里面再加组件
3:CardLayout布局：表示其可以添加多个组件，但只能显示一个。这些组件层叠的放在一起，只有最前面可以显示。
顺序并不是栈，而是队列，即第一个添加进去的组件，显示在最前面，后面的一次往后排。且显示出来的组件将会占据该容器的所有空间
使用该种布局的容器在添加组件时
add(String s,Component c)
s只是一个代号，方便以后显示这个组件时找到
cardlayout对象.show(容器对象,代号s)

其实也有快捷方式，如果知道顺序，但未知代号，或者是没有设置代号，可以通过
caradLayout对象.frist(容器对象)的方式,还有last(),next(),previous()的方式
4:GridLayout布局：即格子布局，将容器划分为若干行和若干列，在小格子添加组件
需要注意的是：这些小格子的大小不能改，所有格子强制大小相同，且排列顺序是从左到右，一行排完后再提行
5:null布局：表示空布局
使用时 容器对象.setLayout(null)即可
这种模式下，不限制组件的个数，每个组件都可以设置其自己的大小和位置location。当然组件可以通过setBounds()函数来设置位置和宽高。
通常在容器add©//c代表一个组件。然后c调用自己setBounds来设置
6:Box布局：盒子布局
盒子布局一共有两种，1是水平盒子Box.creatHorizontalBox()。2是垂直盒子Box.creatVerticalBox().
其中水平盒子中添加的组件都是水平排列，垂直盒子中添加的组件都是垂直排列的
想在水平或垂直的组件间添加间距
可以在盒子中Box对象.add(Box.creatHorizontalStrut(10))；//创建间距为10的水平间隔，Box.creatVerticalStrut(10)则代表垂直方向上的间隔
以下是一个演示案例

    /**
     * 格子布局演示
     */
    public class GridPanel extends JPanel {
        public GridPanel()
        {
            GridLayout gridLayout=new GridLayout(12,12);//生成格子布局对象。构造时设置格子
            setLayout(gridLayout);//为该panel设置布局
            JLabel [][]labels=new JLabel[12][12];//格子中的组件
            for(int i=0;i<=11;i++)
            {
                for(int j=0;j<=11;j++)
                {
                    labels[i][j]=new JLabel();
                    if((i+j)%2==0)
                        labels[i][j].setText("A");
                    else
                        labels[i][j].setText("B");
                    add(labels[i][j]);//将该组件加入到面板中
                }
            }
        }
    }
    
    /**
     * 自定义的空布局面板
     */
    public class NullPanel extends JPanel {
        JButton button;
        JTextField textField;
        public NullPanel(){
            setLayout(null);//设置布局类型
            button=new JButton("确定");//实例化组件
            textField=new JTextField();//实例化组件
            //将组件加入该面板
            add(button);
            add(textField);
            //设置他们大小和位置
            textField.setBounds(100,30,90,30);
            button.setBounds(190,30,66,30);
        }
    }
    /**
     * 用于演示的主面板-其自身也使用了BorderLayout布局
     */
    public class MixedForm extends JFrame {
        private GridPanel gridPanel;//自定义的格子面板对象
        private NullPanel nullPanel;//自定义的空布局面板对象
        private JTabbedPane tabbedPane;//选项卡面板
        public MixedForm()
        {
            gridPanel=new GridPanel();//实例化格子面板对象
            nullPanel=new NullPanel();//实例化空布局面板对象
            tabbedPane=new JTabbedPane();//实例化选项卡面板
            //将两个自定义的面板加入到选项卡面板下，通过选项卡可进行切换
            tabbedPane.add("格子布局面板",gridPanel);
            tabbedPane.add("空布局面板",nullPanel);
            //设置这个MixedForm的布局模式为BorderLayout
            setLayout(new BorderLayout());
            //将这个选项卡面板添加入该MixedForm的中区域
            add(tabbedPane,BorderLayout.CENTER);
            //随便填充几个，将东南西北填充完
            add(new JButton("东"),BorderLayout.EAST);
            add(new JButton("南"),BorderLayout.SOUTH);
            add(new JButton("西"),BorderLayout.WEST);
            add(new JButton("北"),BorderLayout.NORTH);
            //设置MixedForm的相关属性
            setBounds(10,10,570,390);
            setVisible(true);
            setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);
            //validate();//验证组件，可以有
        }
    }
    //启动类
    public class Main  {
        public static void main(String[] args)
        {
            MixedForm form=new MixedForm();
        }
    }

注意在设置很多布局之后调用一次
void validate()验证此容器及其所有子组件。函数，更新验证。【可以有】
效果如下图

盒子布局的展示
代码如下

    public class UserInputPanel extends JFrame {
        private Box userInputBox;//用户输入部分的盒子，主要包含了用户名和密码,垂直排列
        private Box usernameBox;//用户名盒子，包含两个部分，一个label一个TextFiled,水平排列
        private Box passwordBox;//密码盒子，包含两个部分，一个label一个passwordField,水平排列
        private Box buttonBox;//按钮盒子，包含登录和忘记密码两个按钮,水平排列
        private JLabel userNameLabel;//
        private JLabel passwordLabel;//两个label组件提示用户
        private JTextField userNameInput;//用户名输入框
        private JPasswordField passwordInput;//密码输入框
        private JButton loginBtn;//登录按钮
        private JButton forgetPasswordBtn;//忘记密码按钮
        public UserInputPanel()
        {
    
            //实例化所有的对象
            userNameLabel=new JLabel("用户名");
            passwordLabel=new JLabel("密码");
            userNameInput=new JTextField();
            passwordInput=new JPasswordField();
            loginBtn=new JButton("登录");
            forgetPasswordBtn=new JButton("忘记密码");
            userInputBox=Box.createVerticalBox();//内部组件，垂直排列
            buttonBox=Box.createHorizontalBox();//内部组件，水平排列
            usernameBox=Box.createHorizontalBox();//内部组件，水平排列
            passwordBox=Box.createHorizontalBox();//内部组件，水平排列
            //将用户名相关内容加入用户名盒子
            usernameBox.add(userNameLabel);
            usernameBox.add(Box.createHorizontalStrut(10));//输入框与label的横向间隔
            usernameBox.add(userNameInput);
            //将密码相关内容加入密码盒子
            passwordBox.add(passwordLabel);
            passwordBox.add(Box.createHorizontalStrut(10));//输入框和label的横向间距
            passwordBox.add(passwordInput);
            //将用户名盒子和密码盒子加入用户输入userInputBox盒子
            userInputBox.add(usernameBox);
            userInputBox.add(Box.createVerticalStrut(10));//两行之间的间距
            userInputBox.add(passwordBox);
            //将两个按钮加入到按钮盒子
            buttonBox.add(Box.createHorizontalStrut(20));//第一个按钮和左边界的距离
            buttonBox.add(loginBtn);
            buttonBox.add(Box.createHorizontalStrut(10));//两个按钮之间的间距
            buttonBox.add(forgetPasswordBtn);
            //这个面板为空布局
            //设置这两个大盒子userInputBox和buttonBox的位置
            setLayout(null);
            setBounds(50,50,500,400);//该窗口本身的位置和大小
            //加入这两个大Box
            add(userInputBox);
            add(buttonBox);
            //设置这两个大Box的位置和大小
            userInputBox.setBounds(20,20,400,100);
            buttonBox.setBounds(20,200,400,100);
            setVisible(true);
            setDefaultCloseOperation(DISPOSE_ON_CLOSE);
            validate();
        }
    }

执行的效果如下

就此，界面的相关内容介绍的差不多了。下面介绍最重要的"事件"
可以关注我的博客，观看后续学习记录
下一节：java swing 窗体程序开发(二)事件(Action,Item,Document)
https://blog.csdn.net/tanyu159/article/details/89082367

【！！！】欢迎关注我的个人线上课堂https://www.zuikakuedu.cn，内含JavaWeb与Unity游戏开发实战教程，完全免费!，Csdn博客涉及的课程资料也在该网站上

桌面面板和内部窗体

在一个GUI应用程序中需要使用多个窗口，针对这些窗口可以有两种管理策略，一种是每个窗口都是一个独立的窗体，优点是可以通过系统主窗体上的按钮及快捷键浏览所有窗口；另一种是提供一个主窗体，然后将其他窗口放在主窗体中，优点是窗口比较整齐。

在利用第二种策略管理窗口时，必须使用 JDesktopPane 类和 JInternalFrame 类（桌面面板类和内部窗体类）。 JDesktopPane 类是一个容器类，用来创建一个虚拟桌面； JInternalFrame 类是一个轻量级对象，用来创建支持拖动，关闭，图标化，调整大小，标题显示和菜单栏的内部窗体。

JDesktopPane 类中的常用方法

JInternalFrame 类

JInternalFrame 类创建构造方法时，可设置的入口参数最多为5个。

JInternalFrame(String title, boolean resizable, boolean closable, boolean maximizable, boolean iconifiable)

参数说明：
title：为内部窗体的标题。
resizable：设置是否允许自由调整大小，设为 true 表示允许，设为 false （默认值）表示不允许。
closable：设置是否提供“关闭”按钮，设为 true 表示提供，设为 false （默认值）表示提供。
maximizable：设置是否提供“最大化”按钮，设为 true 表示提供，设为 false （默认值）表示提供。
iconifiable：设置是否提供“最小化”按钮，设为 true 表示提供，设为 false （默认值）表示提供。

JInternalFrame 类中的常用方法

创建一个桌面面板与内部窗体，代码如下：

package study.czm;

import java.awt.Container;

import javax.swing.JDesktopPane;
import javax.swing.JFrame;
import javax.swing.JInternalFrame;

public class Study {

	public static void main(String[] args) {

		JFrame jf = new JFrame();
		jf.setTitle("表格组件");
		jf.setSize(600, 500);
		jf.setLocationRelativeTo(null);
		jf.setDefaultCloseOperation(jf.EXIT_ON_CLOSE);
		Container c = jf.getContentPane();

		JDesktopPane desktopPan = new JDesktopPane();// 创建桌面面板对象
		desktopPan.setDragMode(JDesktopPane.OUTLINE_DRAG_MODE);// 设置内部窗体的拖拽方式
		c.add(desktopPan);
		// 创建内部窗体
		JInternalFrame inFrame1 = new JInternalFrame("第一个内部窗体", true, true, true, true);
		JInternalFrame inFrame2 = new JInternalFrame("第二个内部窗体", true, true, true, true);
		JInternalFrame inFrame3 = new JInternalFrame("第三个内部窗体", true, true, true, true);
		desktopPan.add(inFrame1);
		inFrame1.setBounds(50, 50, 200, 200);
		inFrame1.setVisible(true);
		desktopPan.add(inFrame2);
		inFrame2.setBounds(90, 90, 200, 200);
		inFrame2.setVisible(true);
		desktopPan.add(inFrame3);
		inFrame3.setBounds(130, 130, 200, 200);
		inFrame3.setVisible(true);

		jf.setVisible(true);

	}
}

运行效果：