Java核心(Swing 程序设计1-Swing 、常用窗体)

梦里梦外; 2022-05-22 12:47 326阅读 0赞

### 一、Swing 概述 ###

GUI（图形用户界面）为程序提供图形界面，它最初的设计目的是为程序员构建一个通用的GUI，使其能够在所有的平台上运行，但 Java 1.0 中基础类 AWT（抽象窗口工具箱）并没有达到这个要求，于是 Swing 出现了，它是 AWT 组件的增强组件，但是它并不能完全替代 AWT 组件，这两种组件需要同时出现在一个图形用户界面中。

1.1 Swing 特点

原来的 AWT 组件来自 java.awt 包，当含有 AWT 组件的 Java 应用程序在不同的平台上运行时，每个平台的GUI组件的显示会有所不同，但是在不同平台上运行使用 Swing 开发的应用程序时，就可以统一 GUI 组件的显示风格，因为 Swing 组件允许编程人员在跨平台时指定统一的外观和风格。

Swing 组件通常被称为“轻量级组件”，因为它完全由 Java 语言编写，而 Java 是不依赖于操作系统的语言，它可以在任何平台上运行；相反，依赖于本地平台的组件被称为“重量级组件”，如 AWT 组件就是依赖于本地平台的窗口系统来决定组件的功能、外观和风格。

Swing 主要具有以下特点：

（ 1 ）轻量级组件。

（ 2 ）可插入外观组件。

1.2 Swing 包

为了有效地使用 Swing 组件，必须了解 Swing 包的层次结构和继承关系，其中比较重要的类是 Component 类、Container 类和 JComponent 类。

Java.lang.Object 类 --> Java.awt.Component 类 --> Java.awt.Container 类 --> Java.swing.JComponent 类

在 Swing 组件中大多数 GUI 组件都是 Component 类的直接子类或间接子类，JComponent 类是 Swing 组件各种特性的存放位置，这些组件的特性包括设定组件边界、GUI 组件自动滚动等。

在 Swing 组件中最重要的父类是 Container 类，而 Container 类有两个最重要的子类，分别为 java.awt.Window 与 java.awt.Frame ，除了以往的 AWT 类组件会继承这两个类之外，现在的 Swing 组件也扩展了这两个类。顶层父类是 Component 类与 Container 类，所以 Java 关于窗口组件的编写，都与组件以及容器的概念相关联。

1.3 常用的 Swing 组件概述

<table> 常用 Swing 组件 
 <tbody> 
 <tr> 
 <td>组件名称</td> 
 <td>定义</td> 
 </tr> 
 <tr> 
 <td>JButton</td> 
 <td>代表 Swing 按钮，按钮可以带一些图片或文字</td> 
 </tr> 
 <tr> 
 <td>JCheckBox</td> 
 <td>代表 Swing 中的复选框组件</td> 
 </tr> 
 <tr> 
 <td>JComBox</td> 
 <td>代表下拉列表框，可以在下拉显示区域显示多个选项</td> 
 </tr> 
 <tr> 
 <td>JFrame</td> 
 <td>代表 Swing 的框架类</td> 
 </tr> 
 <tr> 
 <td>JDialog</td> 
 <td>代表 Swing 版本的对话框</td> 
 </tr> 
 <tr> 
 <td>JLabel</td> 
 <td>代表 Swing 中的标签组件</td> 
 </tr> 
 <tr> 
 <td>JRadioButton</td> 
 <td>代表 Swing 的单选按钮</td> 
 </tr> 
 <tr> 
 <td>JList</td> 
 <td>代表能够在用户界面中显示一系列条目的组件</td> 
 </tr> 
 <tr> 
 <td>JTextField</td> 
 <td>代表文本框</td> 
 </tr> 
 <tr> 
 <td>JPasswordField</td> 
 <td>代表密码框</td> 
 </tr> 
 <tr> 
 <td>JTextArea</td> 
 <td>代表 Swing 中的文本区域</td> 
 </tr> 
 <tr> 
 <td>JOptionPane</td> 
 <td>代表 Swing 中的一些对话框</td> 
 </tr> 
 </tbody> 
</table>

### 二、常用窗体 ###

窗体作为 Swing 应用程序中组件的承载体，处于非常重要的位置。Swing 中常用的窗体包括 JFrame 和 JDialog 。

2.1 JFrame 窗体

JFrame 窗体是一个容器，它是 Swing 程序中各个组件的载体，可以将 JFrame 看作是承载这些 Swing 组件的容器。在开发应用程序时可以用过继承 java.swing.JFrame 类创建一个窗体，在这个窗体中添加组件，同时为组件设置事件。由于该窗体继承了 JFrame 类，所以它拥有“最大化”、“最小化”和“关闭”等按钮。

JFrame 在程序中的语法格式 ：

JFrame jf = new JFrame(title);
    Container container = jf.getContentPane();

参数含义：

jf ：JFrame 类的对象。

container ：Container 类的对象，可以使用 JFrame 对象调用 getContentPane() 方法获取。

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

container.add(new JButton("按钮"));        //JButton 按钮组件

在容器中添加组件后，也可以使用 Container 类的 remove() 方法将这些组件从容器中删除。

container.remove(new JButton("按钮"));

eg 2.1 ： 在项目中创建 Example1 类，该类继承 JFrame 类乘为窗体类，在该类中创建标签组件，并添加到窗体界面中。

package com.SwingDemo;
    
    import java.awt.*;        //导入 AWT 包
    import javax.swing.*;         //导入 Swing 包
    
    public class Example1 extends JFrame {         //定义一个类继承 JFrame 类
        public void CreateJFrame(String title) {         //定义一个 CreateJFrame() 方法
            JFrame jf = new JFrame(title);        //实例化一个 JFrame 对象
            Container container = jf.getContentPane();        //获取一个容器
            JLabel jl = new JLabel("这是一个 JFrame 窗体");        //创建一个 JLabel 标签
            jl.setHorizontalAlignment(SwingConstants.CENTER);        //使标签上的文字居中
            container.add(jl);        //将标签添加到容器中
            container.setBackground(Color.white);        //设置容器的背景颜色
            jf.setVisible(true);        //使窗体可视
            jf.setSize(200, 150);        //设置窗体大小
            jf.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);        //设置窗体关闭方式
        }
    
        public static void main(String[] args) {
            new Example1().CreateJFrame("创建一个 JFrame 窗体");        //在主方法中调用 CreateJFrame() 方法
        }
    }

运行结果为 ：

![70][]

在 eg 2.1 中，Example1 类继承了 JFrame 类，在 CreateJFrame() 方法中实例化 JFrame 对象。JFrame 类的常用构造方法包括以下两种形式：

( 1 ) ： public JFrame() 。

( 2 ) ： public JFrame(String title)。

JFrame 类中的两种构造方法分别为无参的构造方法和有参的构造方法，第一种形式的构造方法可以创建一个厨师不可见。没有标题的新窗体；第二种形式的构造方法再实例化该 JFrame 对象时可以创建一个不可见但具有标题的窗体。可以使用 JFrame 对象调用 show() 方法使窗体可见，但是该方法早已被新版 JDK 所弃用，通常视同 setVisible(true) 方法使窗体可见。

同时可以使用 setSize(int x , int y) 方法设置窗体大小，其中 x 与 y 变量分别代表窗体的宽和高。

创建窗体后，需要给予窗体一个关闭方式，可以调用 setDefaultCloseOperation() 方法关闭窗体。Java 为窗体关闭提供了多种方式，常用的有一下 4 中：

( 1 ) ：DO\_NOTHING\_ON\_CLOSE 。 代表什么都不做就将窗体关闭。

( 2 ) ：DISPOSE\_ON\_CLOSE 。 代表任何注册监听程序对象后会自动隐藏并释放窗体。

( 3 ) ：HIDE\_ON\_CLOSE 。 代表隐藏窗口的默认默认窗口关闭。

( 4 ) ：EXIT\_ON\_CLOSE 。 代表退出应用程序默认窗口关闭

这几种操作实质上是将一个 int 类型的常量封装在 java.swing.WindowConstants 接口中。

2.2 JDialog 窗体

JDialog 窗体是 Swing 组件中的对话框，它继承了 AWT 组件中 java.awt.Dialog 类。

JDialog 窗体的功能是从一个窗体中弹出另一个窗体，就像是在使用 IE 浏览器时弹出的确定对话框一样。JDialog 窗体实质上就是另一种类型的窗体，它与 JFrame 窗体类似，在使用时也需要调用 getContentPane() 方法将窗体转换为容器，然后再容器中设置窗体特性。

在应用程序中创建 JDialog 窗体需要实例化 JDialog 类，通常使用以下几个 JDialog 类的构造方法。

( 1 ) ：publi JDialog() ：创建一个没有标题和父窗体的对话框 。

( 2 ) ：public JDialog(Frame f) ：创建一个指定父窗体的对话框，但该窗体没有标题 。

( 3 ) ：public JDialog(Frame f , boolean model) ：创建一个指定类型的对话框，并指定父窗体，但该窗体没有指定标题 。

( 4 ) ： public JDialog(Frame f ,String title) ：创建一个指定标题和父窗体的对话框 。

( 5 ) ： public JDialog(Frame f , String title , boolean model) ：创建一个指定标题、窗体和模式的对话框。

eg 2.2 ：在项目中创建 MyJDialog 类，该类继承 JDialog 窗体，并在窗口中添加按钮，当用户单机该按钮后，将弹出一个对话框窗体。

package com.SwingDemo;
    
    import java.awt.*;        //导入 AWT 包
    import java.awt.event.ActionEvent;
    import java.awt.event.ActionListener;
    import javax.swing.*;        //导入 swing 包
    
    class MyJDialog extends JDialog{        //创建新类继承 JDialog 类
        public MyJDialog (MyFrame frame) {
            super(frame,"第一个 JDialog 窗体",true);        //实例化一个 JDialog 类对象，指定对话框的父窗体、窗体标题和类型
            Container container = getContentPane();        //创建一个容器
            container.add(new JLabel("这是一个对话框"));        //在容器中添加标签
            setBounds(120, 120, 100, 100);        //设置对话框窗体大小
        }
    }
    
    public class MyFrame extends JFrame {        //创建新类
    	
        public static void main(String[] args) {
            new MyFrame();        //实例化 MyJDialog 类对象
        }
    	
        public MyFrame() {
            Container container = getContentPane();        //创建一个容器
            container.setLayout(null);
            JLabel jl = new JLabel("这是一个 JFrame 窗体");        //在窗体中设置标签
            jl.setHorizontalAlignment(SwingConstants.CENTER);//将标签的文字居中
            container.add(jl);
            JButton jButton = new JButton("弹出对话框");        //定义一个按钮
            jButton.setBounds(10, 10, 100, 21);
            jButton.addActionListener(new ActionListener() {        //为按钮添加鼠标点击事件
                @Override
                public void actionPerformed(ActionEvent e) {
                    new MyJDialog(MyFrame.this).setVisible(true);        //使 MyJDialog 可见
                }
            });
            container.add(jButton);        //将按钮添加到容器中
            container.setBackground(Color.white);
            setSize(200, 200);
            setDefaultCloseOperation(WindowConstants.DISPOSE_ON_CLOSE);
            setVisible(true);
        }
    }

运行结果为：

![70 1][]

在例子中，为了使对话框在父窗体弹出，定义了一个 JFrame 窗体，首先在该窗体中定义一个按钮，然后为此按钮添加一个鼠标单击监听事件，这里使用 new MyJDialog().setVisible(true) 语句使对话框可见，这样就实现了用户点击该按钮后弹出对话框的功能。

在 MyJDialog 类中，由于它继承了 JDialog 类，所以可以在构造方法中使用 super 关键字调用 JDialog 构造方法。在这里使用了 public JDialog(Frame f , String title , boolean model) 这种形式的构造方法，相应地设置了自定义的 JFrame 窗体以及对话框的标题和窗体类型。JDialog 窗体与 JFrame 窗体形式基本相同，设置在设置窗体的特性时调用的方法名称都基本相同，如设置窗体大小。窗体关闭状态等。

[70]: /images/20220522/5fc1f576dd9f40e7be241e7e05a41db0.png
[70 1]: /images/20220522/ad3283c0772647f3a712e7f969f8cf77.png