Java

图形用户界面的设计与实现

2022-02-28  本文已影响0人  马佳乐

AWT概述

AWT：Abstract Window ToolKit的缩写，抽象窗口组件工具包，是Java语言中最早用于编写GUI应用程序的工具包，提供了一套与本地图形界面进行交互的接口。
AWT中的图形方法与操作系统提供的图形方法之间一一对应。因此，当利用AWT来创建图形界面的时候，实际上是在利用操作系统所提供的图形库。AWT组件没有做到完全的跨平台。
由于AWT是依靠本地方法来实现其功能的，通常把AWT组件称为重量级组件。
AWT提供了一系列用于实现图形界面的组件，如窗口、按钮、文本框、对话框等。在JDK中针对每个组件都提供了对应的Java类，这些类都位于java.awt包中，该包包含用于创建用户界面和绘制图形图像的所有类和接口。

Component类

通常被称为组件，是构成Java图形用户界面的基本元素，Component类及其子类的对象用来描述以图形化的方式显示在屏幕上并能与用户进行交互的GUI元素，根据Component的不同作用，可将其分为基本组件类和容器类。基本组件类是诸如按钮、文本框之类的图形界面元素，而容器类则是通过Component的子类Container实例化的对象。

Container类

是Component的子类，为容器组件，是一个可以包含组件和其它容器的特殊组件。Container容器又分为两种类型，分别是Window和Panel。
Container对象可使用add(Component comp)向其中添加其他Component对象或其他Container对象。
也可通过使用remove(Component comp)方法从当前容器组件中删除指定组件。

Window类

Window类不依赖于其他容器而独立存在的容器，可以作为一个应用程序的窗口，独立显示出来的，其对象表示自由停泊的顶级窗口。
顶级容器是一个能够提供图形绘制的容器，是进行图形编程的基础，一切图形化的东西，都包括在顶级容器中。

①Frame类

Window的子类，表示框架，是一种顶层容器，是用来设计类似于Windows系统中的窗口形式的应用程序。

Frame的常用构造方法：

Frame()：构造一个最初不可见的 Frame 新实例。
Frame(String s)：构造一个新的、最初不可见的、具有指定标题s的 Frame 对象。
Frame的其他常用方法：
setBounds(int x,int y,int width,int height)：设置窗体的位置和大小，x、y是左上角坐标，width和height是宽度和高度，单位为像素。
setSize(int width,int height)：设置窗体的大小，width和height是宽度和高度
setLocation(int x, int y)：设置窗体的位置，x、y是左上角的坐标
setBackground(Color c)：设置背景颜色，参数为Color对象
setVisible(boolean b)：设置窗体是否可见
setTitle(String name)：设置窗体标题栏为字符串name
String getTitle()：获取窗体标题栏
setResizable(boolean b)：设置是否可以调整大小。
Frame类的应用：

public class Test1 {
    public static void main(String[] args) {            
        Frame f=new Frame("My First Test");
        f.setLocation(300,300);
        f.setSize(170,100);
        f.setBackground(Color.yellow);
        f.setResizable(false);
        f.setVisible(true);
    }
}

②Dialog类

Window的子类，表示对话框，是向用户显示信息并获取程序运行所需数据的窗口，可以起到与用户交互的作用。与一般窗口不同的是，对话框依赖于其他窗口，当它所依赖的窗口消失或最小化时，对话框也将消失；窗口还原时，对话框又会自动恢复。

Panel类

面板，不能作为应用程序的独立窗口存在，必须被添加到其它Container中才能显示出来，因此，Panel为中间容器。
中间容器属于容器性组件，可包含组件和其他容器的组件，但自身又必须包含在其他容器（如顶级容器）中。
比较典型的Panel为Applet，用来设计可以嵌入在网页中的Java小程序。
Panel的构造方法：
Panel()：使用默认的FlowLayout类布局管理器初始化
Panel(LayoutMannage layout)：使用指定的布局管理器初始化
Panel类常常用方法：
setBounds(int x, int y, int width, int height)
setSize(int width,int height)
setLocation(int x,int y)
setBackground(Color c)
setLayout(LayoutManager mgr)等
Panel类的应用：

public class Test1 {
    public static void main(String[] args) {            
        Frame f=new Frame("Java Frame with Panel");
        Panel p=new Panel(null);
        f.setLayout(null);
        f.setBounds(300,300,500,500);//相对于屏幕的坐标
        f.setBackground(new Color(0,0,102));
        p.setBounds(50,50,400,400);//坐标相对于外层的Frame
        p.setBackground(new Color(204,204,255));
        f.add(p);//把panel添加到Frame中
        f.setVisible(true);
    }
}

Component类的其他常用子类

非容器组件：不可以包含组件和其他容器的组件

Swing

SUN公司于1997年推出了Swing，它是在AWT的基础上构建的一套新的图形界面系统，它包含AWT 所能够提供的所有功能，并且用纯粹的Java代码对AWT 的功能进行了大幅度的扩充，是AWT组件的增强组件。
由于在Swing中没有使用本地方法来实现图形功能，因此，Swing在不同的操作平台上表现一致，并且有能力提供本地窗口系统不支持的其它功能，通常把Swing组件称为轻量级组件。

AWT是基于本地方法的，所以其运行速度比较快；Swing是基于AWT的Java程序，其运行速度相对AWT慢。
Swing更多的使用在基于PC或者是工作站的标准Java应用中，通过牺牲速度来提高应用程序的性能，如果在嵌入式应用，则采用相对高效的AWT，通过牺牲性能而保障速度。
javax.swing包：提供一组“轻量级”（全部是 Java 语言）组件，尽量让这些在所有平台上的工作方式都相同。
java和javax都是Java的API包，java是核心包，javax的x是extension的意思，表明javax是java类库的扩展包。
使用Swing容器和组件要导入javax.swing包，格式：
import javax.swing.*;
为了能更好的使用Swing，我们还经常要导入另外的两个包，格式如下：

    import java.awt.*;
    import java.awt.event.*;

Swing组件的类名和对应的AWT组件类名基本一致，大部分都是在AWT组件类名的前面添加了“J”，但也有一些例外，比如Swing的JComboBox组件对应的是AWT中的Choice组件(下拉框)。

Swing中的容器

（1）顶层容器类

JFrame：用于框架窗口的类。
JDialog：用于对话框的类。
JApplet：用于使用Swing组件的Java Applet的类。
JWindow：它没有标题栏、窗口管理按钮。

（2）中间容器类

JPanel：用于将小型的轻量级组件（如JButton、JLabel等非容器组件或JPanel组件）组合在一起。
JScrollPane：滚动窗口，与JPanel类似，有滚动条。
JTabbedPane：一次只显示一个组件。
JToolBar：按行或列排列一组组件（通常是一组按钮）。

绝大多数的Swing组件派生自JCompomnent类，它是除顶层容器外所有Swing组件的基类。
JComponent类只有一个无参构造方法：
格式：public JComponent()
功能：调用Container构造方法，除此之外不进行任何初始化工作。

Swing组件的使用

与AWT组件不同，Swing组件不能直接添加到顶层容器中，它必须添加到一个与Swing顶层容器相关联的内容面板（content pane）上。内容面板是顶层容器包含的一个普通容器，它是一个轻量级组件。

对JFrame添加组件有以下方法：

1）用getContentPane()方法获得JFrame的内容面板，再为其加入组件，格式：

frame.getContentPane().add(childComponent);

2）如果用户的自定义类为JFrame类的子类，则可以先创建一个JPanel面板对象，然后再向该面板中加入组件，格式：

   JPanel contentPane=new JPanel();
   contentPane.add(childComponent);

3）建立一个中间容器，把组件添加到容器中，用setContentPane()方法把该容器置为JFrame的内容面板，格式：

   Jpanel contentPane=new Jpanel(); 
   ……//把其它组件添加到Jpanel中;
   frame.setContentPane(contentPane); 
   //把contentPane对象设置成为frame的内容面板

使用JFrame容器进行图形界面程序开发基本步骤：

1）创建的JFrame窗口是不可见的，要使得可见，需要使用show()方法或setVisible(Boolean b)方法，其中setVisible中的参数b=true。
2）使用setSize方法设置窗口大小。
3）向JFrame中添加组件时，必须先取得ContentPane，然后再使用add()方法把组件加入到ContentPane中，这与AWT包中的Frame直接使用add()方法添加组件不同。
使用Swing组件编写的程序：

import javax.swing.*;
public class First {
    public static void main(String[] args) {
        JFrame frame=new JFrame();
        //创建有文本的标签
        JLabel label=new JLabel("Swing组件");
        //获得内容面板后，用add()方法将label加入frame
        frame.getContentPane().add(label);
        //调用如下方法可以通过单击“关闭”按钮关闭此框架
        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        frame.setSize(200,200);//设置frame的宽度和高度
        frame.setVisible(true);//设置frame为可见
    }
}

布局管理器

Java语言中，提供了布局管理器类的对象可以管理Component在Container中的布局，不必直接设置Component的位置和大小。
每个Container都有一个布局管理器对象，当容器需要对某个组件进行定位或判断其大小尺寸时，就会调用其对应的布局管理器，调用Container的setLayout()方法改变其布局管理器对象。

AWT提供的常用布局管理器：实现了LayoutManager接口

FlowLayout布局

流式布局管理器：java.awt.FlowLayout是java.lang.Object的直接子类，是Panel类的默认布局管理器，是最简单的布局管理器。
FlowLayout布局管理器对容器中的组件按照加入的顺序从左向右排列，当一行排满（到达容器的边界）之后就转到下一行继续从左至右排列。
不改变组件的大小，按照组件原有尺寸显示，可设置不同的组件间距、行距以及对其方式。
FlowLayout布局管理器中组件可以左对齐、居中对齐（默认方式）或右对齐的方式排列。

FlowLayout的构造方法：

FlowLayout()：用于创建一个设定为居中对齐、各组件的水平及垂直间隔为5个像素点的FlowLayout。
FlowLayout(int align) 用于创建一个FlowLayout类的对象，按给出的align值对齐，各组件的水平及垂直间隔为5个像素。align的值可以是FlowLayout.LEFT(左对齐)、FlowLayout.RIGHT(右对齐)、FlowLayout.CENTER(居中对齐)方式。
FlowLayout(int align，int hgap，int vgap) 用于创建一个既指定对齐方式，又指定组件间间隔的FlowLayout类的对象。参数align作用及取值同上；参数hgap指定组件间的水平间隔；参数vgap指定各组件间的垂直间隔。间隔单位为像素点。
FlowLayout举例：

import java.awt.*;
import javax.swing.*;
public class myFlowLayoutExample{
    public static void main(String args[]){
        JFrame jframe=new JFrame("一个滚动列表的例子");
        Container cp=jframe.getContentPane();
        cp.setLayout(new FlowLayout());
        JButton jbt1=new JButton("足球");
        JButton jbt2=new JButton("篮球");
        JButton jbt3=new JButton("排球");
        JButton jbt4=new JButton("羽毛球");
        JButton jbt5=new JButton("乒乓球");
        cp.add(jbt1);   cp.add(jbt2);   cp.add(jbt3);
        cp.add(jbt4);   cp.add(jbt5);
        jframe.setSize(150,200);
        jframe.setVisible(true);
    }
}

BorderLayout布局

边界布局管理器（BorderLayout）是Frame类的默认布局管理器，把容器分成5个区域：North、South、East、West和Center，每个区域只能放置一个组件，如加入多个，则先前加入的会被覆盖。
如不指定组件的加入区域，默认加入Center区。

BorderLayout的构造方法

public BorderLayout( )：创建一个各组件间的水平、垂直间隔为0的BorderLayout类的对象。
public BorderLayout( int hgap, int vgap )：创建一个各组件间的水平间隔为hgap、垂直间隔为vgap的BorderLayout类的对象。

BorderLayout举例：

import javax.swing.*;
import javax.swing.*;
public class BorderLayoutEx {
    public static void main(String[] args) {
        JFrame jf=new JFrame("BorderLayout示例程序"); 
        jf.setBounds(100,100,300,200);
        jf.setVisible(true); 
    //  jf.setLayout(new BorderLayout(5,10));
        JButton bSouth=new JButton("南");//创建按钮对象
        JButton bNorth=new JButton("北");
        JButton bEast=new JButton("东");
        JButton bWest=new JButton("西");
        JButton bCenter=new JButton("中");
        jf.add(bNorth,BorderLayout.NORTH);      
        jf.add(bSouth,BorderLayout.SOUTH);
        jf.add(bEast,BorderLayout.EAST);
        jf.add(bWest,BorderLayout.WEST); 
        jf.add(bCenter,BorderLayout.CENTER);        
        jf.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
    }
}

GridLayout布局

网格布局管理器：用纵横线将容器分成n行m列大小相等的网格，每个网格中放置一个组件。添加到容器中的组件首先放置在第1行第1列（左上角）的网格中，然后在第1行的网格中从左向右依次放置其他组件，行满后，继续在下一行中从左到右放置组件，放置在GridLayout布局管理器中的组件将自动占据网格的整个区域。

GridLayout类的三个构造方法如下：

GridLayout( )：按默认(1行1列)方式创建一个GridLayout布局。
GridLayout(int rows,int cols)：创建一个具有rows行、cols列的GridLayout布局。
GridLayout(int rows,int cols,int hgap,int vgap)：按指定的行数rows、列数cols、水平间隔hgap和垂直间隔vgap创建一个GridLayout布局。

GridLayout举例：

import javax.swing.*;
import java.awt.*;
public class GridLayoutEx {
    public static void main(String[] args) {
        JFrame jf=new JFrame("GridLayout示例程序"); 
        jf.setBounds(100,100,300,200);
        jf.setVisible(true);
        JButton b1=new JButton("计C171");//创建按钮
        JButton b2=new JButton("计C172");
        JButton b3=new JButton("计C173");
        JButton b4=new JButton("计C174");
        JButton b5=new JButton("计C175");
        JButton b6=new JButton("计C176");
        JButton b7=new JButton("计S181");
        JButton b8=new JButton("计S182");
        jf.setLayout(new GridLayout(3,3,10,10));
        jf.add(b1); jf.add(b2); jf.add(b3);//添加按钮
        jf.add(b4); jf.add(b5); jf.add(b6);jf.add(b7);jf.add(b8);
        jf.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
    }
}

网格包布局管理器：GridBagLayout是最灵活、最复杂的布局管理器。与GridLayout布局管理器类似，不同的是，它允许网格中的组件大小各不相同，允许一个组件跨越一个或多个网格，而且不需要组件的尺寸相同它就可以将组件在垂直方向和水平方向上对齐，它能解决几乎所有界面布局的问题。

使用GridBagLayout布局管理器的步骤：

①创建GridBagLayout布局管理器，并使容器采用该布局管理器。

    GridBagLayout layout=new GridBagLayout();
    container.setLayout(layout);

②创建GridBagContraints对象（布局约束条件，是控制GridBagLayout中每个组件布局的核心类），并设置该对象的相关属性。

属性 作用
gridx和gridy 设置组件的左上角所在网格的横向和纵向索引(即所在的行和列)。如果将gridx和gridy 的值设置为GridBagConstraints.RELATIVE(默认值)，表示当前组件紧跟在上一个组件后面
gridwidth和gridheight 设置组件横向、纵向跨越几个网格，两个属性的逻认值都是1。如果把这两个属性的值设为GridBagConstraints.REMAINER表示当前组件在其行或其列上为最后一个组件。如果把这两个属性的值设为GridBagConstraints.RELATVE，表示当前组件在其行或列上为倒数第二个组件
fill 如果当组件的显示区域大于组件需要的大小，设置是否以及如何改变组件大小，该属性接收以下几个属性值：NONE:默认，不改变组件大小；HORIZONTAL:使组件水平方向足够长以填充显示区域，但是高度不变；VERTICAL:使组件垂直方向最够高以填充显示区域，但长度不变；BOTH:使组件足够大，以填充整个显示区域
weightx和weighty 设置组件占领容器中多余的水平方向和垂直方向空白的比例(也称为权重)。假设容器的水平方向放嚣三个组件，其weightx分别为1、2、3，当容器宽度增加60个像素时，这三个容器分别增加10、20、和30的像素。这两个属性的默认值是0，即不占领多余的空间

③调用GridBagLayout对象的setConstraints()方法建立GridBagConstraints对象和受控组件之间的关联。

    layout.setConstraints(component, constraints);

④向容器中添加组件。

    container.add(component);

GridBagConstraints对象可以重复使用，只需要改变它的属性即可。若要向容器中添加多个组件，则重复步骤②③④。

GridBagLayout举例：

import java.awt.*;
class Layout extends Frame {
    // 增加组件的方法
    private void addComponent(String name, GridBagLayout layout,
            GridBagConstraints c) {
        Button bt = new Button(name); // 创建一个名为name的按钮
        // 设置GridBagConstraints对象和按钮的关联
        layout.setConstraints(bt, c);       
        this.add(bt); // 增加按钮
    }
    public Layout(String title) {
        GridBagLayout layout = new GridBagLayout();
        GridBagConstraints c = new GridBagConstraints();
        this.setLayout(layout);
        c.fill = GridBagConstraints.BOTH; // 设置组件横向纵向可以拉伸
        c.weightx = 1; // 设置横向权重为1
        c.weighty = 1; // 设置纵向权重为1
        this.addComponent("btn1", layout, c);
        this.addComponent("btn2", layout, c);
        this.addComponent("btn3", layout, c);
        c.gridwidth = GridBagConstraints.REMAINDER; // 添加的组件是本行最后一个组件
        this.addComponent("btn4", layout, c);
        c.weightx = 0; // 设置横向权重为0
        c.weighty = 0; // 设置纵向权重为0
        addComponent("btn5", layout, c);        
        c.gridwidth = 1; // 设置组件跨一个网格(默认值)
        this.addComponent("btn6", layout, c);
        c.gridwidth = GridBagConstraints.REMAINDER; // 添加的组件是本行最后一个组件
        this.addComponent("btn7", layout, c);
        c.gridheight = 2; // 设置组件纵向跨两个网格
        c.gridwidth = 1; // 设置组件横向跨一个网格
        c.weightx = 2; // 设置横向权重为2
        c.weighty = 2; // 设置纵向权重为2
        this.addComponent("btn8", layout, c);
        c.gridwidth = GridBagConstraints.REMAINDER;
        c.gridheight = 1;
        this.addComponent("btn9", layout, c);
        this.addComponent("btn10", layout, c);
        this.setTitle(title);
        this.pack();
        this.setVisible(true);  }}

CardLayout布局

卡片布局管理器：CardLayout将每个组件看成一张卡片,如同扑克牌一样将组件堆叠起来。一次只能看到一张卡片，容器则充当卡片的堆栈。当容器第一次显示时，第一个添加到 CardLayout 对象的组件为可见组件，这个被显示的组件将占据所有的容器空间。

CardLayout类的构造方法：

public CardLayout( ) ：使用默认(间隔为0)方式创建一个CardLayout( )类对象。
public CardLayout( int hgap, int vgap ) ：使用hgap指定的水平间隔和vgap指定的垂直间隔创建一个CardLayout( )类对象。

CardLayout类的常用方法：

public void first( Container parent ) ：显示parent容器的第一张卡片。
public void last( Container parent )：显示parent容器的最后一张卡片。
public void next( Container parent ) ：显示parent容器的的下一张卡片。
public void previous( Container parent )：显示parent容器的前一张卡片。
public void show(Container parent, String name)：显示parent容器中名称为name的组件，若不存在，则不会发生任何操作

CardLayout举例：

import java.awt.*;
import javax.swing.*;
public class TestCard {
    public static void main(String[] args) {
        JFrame jf=new JFrame("CardLayout示例程序");
        //Container cp=jf.getContentPane();
        JPanel cp=new JPanel(); jf.setContentPane(cp);
        CardLayout card=new CardLayout(20,20);
        jf.setLayout(card);
        JButton bt1=new JButton("足球");
        JButton bt2=new JButton("篮球");
        JButton bt3=new JButton("排球");
        JButton bt4=new JButton("乒乓球");
        JButton bt5=new JButton("羽毛球");
        cp.add(bt1);    cp.add(bt2);    cp.add(bt3);
        cp.add(bt4);    cp.add(bt5);
        card.next(cp);  jf.setSize(200,200);
        jf.setVisible(true);
        jf.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);  
    }
}

自定义布局

使用布局管理器时，布局管理器负责各个组件的大小和位置，用户无法在这种情况下设置组件大小和位置属性，如果使用使用Java语言提供的setLocation()、setSize()、setBounds()等方法，则都会被布局管理器覆盖。
自定义布局就是不使用布局管理器，格式如下：
setLayout(null);
因为没有使用布局管理器，可以使用setBounds()方法指定组件的位置和大小。自定义布局应用广泛，因为编程者可以不考虑布局只需要注意组件的位置。

利用AWT组件和Swing组件进行程序设计的基本步骤

事件处理

Java采用委托事件模型来处理事件。
委托事件模型的特点是将事件的处理委托给独立的对象，而不是组件本身。
委托事件模型包含三个重要概念：事件、事件源和事件监听器。

事件

用户在界面上的一个操作（通常使用各种输入设备，如鼠标、键盘等来完成），如拖动鼠标、按下回车键、通过键盘输入一个字符、选择某个菜单项、在列表中选择一个选项、取得焦点等都是事件。
当一个事件发生时，该事件用一个事件对象来表示。事件对象有对应的事件类。不同的事件类描述不同类型的用户动作。
事件类包含在java.awt.event和javax.swing.event中。

名称 说明
ActionEvent 处理按钮、列表项双击、单击菜单项目
AdjustmentEvent 滚动条位置改变
ComponentEvent 调整组件大小，移动、隐藏或显示组件
ContainerEvent 容器内组件的添加、删除
FocusEvent 组件失去或获取焦点
MouseEvent 鼠标拖动、移动、单击、按下、释放
ItemEvent 选择或取消列表框、复选框等选项
KeyEvent 按下、放开某键
InputEvent 处理复选框和列表项单击、控件的选择和可选菜单项选择的事件
TextEvent 处理文本区域或者文本区域的值的改动
WindowEvent 处理窗口激活、失去活动窗口、最小化、打开、关闭或者退出的事件

事件源

产生事件的组件叫做事件源。
如在一个按钮上单机鼠标时，该按钮就是事件源，会产生一个ActionEvent类型的事件。

监听器

监听器：Listener，负责监听事件源上发生的事件（接收事件对象），并对各种事件进行相应处理的对象。
事件监听类：负责检查事件是否发生，若发生就激活事件监听器进行处理的类，必须实现事件监听器接口或继承事件监听器适配器类。
事件监听器接口：每种侦听器都带有一个接口，接口中定义了一个或多个处理事件必须实现的方法。实现这些方法就是当侦听到事件后所执行的一系列操作。
适配器类是一种特殊类，类中已经实现了接口，它为接口中的所有方法都增加了空语句体。所以可以通过适配器来替代侦听器的使用，根据程序的需要执行的方法就重写，不需要执行的方法不需要再重写了，简化了程序的编写。
事件监听器接口和事件监听器适配器类也都包含在java.awt.event和javax.swing.event包中。
每一个事件类都有一个“唯一”的事件处理方法接口。

注册事件监听器

为了能够让事件监听器检查某个组件（事件源）是否发生了某些事件，并且进行相应处理，必须在事件源上注册事件监听器。
通过使用事件源组件的以下方法完成。
addXxxListener(事件监听器对象）
其中，Xxx对应相应的事件类。

A. addXXXListener(B)：当A发生XXX事件时，对象B能得到通知，并将调用相应的方法处理该事件。
如：button事件，注册监听器为handler，则：
button. addActionListener(handler h);
方法一：自定义监听器类实现事件监听接口

class handler  implements ActionListener{
public void actionPerformed(ActionEvent e)
     {  ……  }          
}

方法二：用匿名内部类实现事件监听接口

button. addActionListener(new ActionListener(){
    public void actionPerformed(ActionEvent e)
     {  ……  }          
});

方法三：自定义类实现相应适配器类

button. addMouseListener(new MAdapter()); 
class MAdapter extends MouseAdapter{
        @Override
        public void mouseClicked(MouseEvent e) {
            //事件处理代码
        }
    }

Java中处理各组件事件的一般步骤

  1. 新建一个组件（如JButton）。
  2. 将该组件添加到相应的面板（如JPanel）。
  3. 注册监听器以监听事件源产生的事件（如通过ActionListener来响应用户点击按钮）。
  4. 定义处理事件的方法（如在ActionListener中的actionPerformed中定义相应方法）。

常用组件

窗口中可以添加各种组件，通过容器的add()方法可以将各种组件添加到容器中。
常用组件：按钮、标签、文本框、文本区域、复选框、单选按钮、列表、菜单、对话框等

按钮

按钮(Button、JButton)是常见组件，按钮上允许有图标或字符串，也可两者兼有，最常见的操作是单击按钮。

（1）构造方法

（2）常用方法

（3）常用事件

ActionEvent事件
当单击按钮，或者按钮已经取得焦点时按下空格键（Space键）时，发生ActionEvent事件。ActionLister接口用于侦听这个事件，ActionLister接口的方法actionPerformed()必须实现。

标签

标签(Label、JLabel)是常见组件，可以显示文本、图像或二者同时显示。标签一般用来显示提示信息，它不对输入事件作出反应。因此，它无法获得键盘焦点。

（1）构造方法

（2）常用方法

文本框

文本框(TextField、JTextField)组件允许编辑或输入单行文本。

（1）构造方法

（2）常用方法

（3）常用事件

ActionEvent事件

当在文本框中输入字符并按回车时，发生ActionEvent事件，然后执行重写的ActionListener接口的actionPerformed()方法。

FocusEvent事件

绝大部分组件都可以侦听FocusEvent事件，FocusEvent事件发生后，如果组件取得了焦点，执行focusGained()方法，如果组件失去了焦点，执行focusLost()方法。

JPanel

Java中的JPanel组件属于容器型组件。
可以在JPanel中放置按钮、文本框等非容器组件，甚至还可以在JPanel中再放置若干个JPanel组件。
Swing采用JPanel定义面板，面板必须包含在另一个容器（如JFrame）中。

（1）构造方法

（2）常用方法

（3）Border接口

public interface Border
该接口描述一个能够呈现围绕 swing 组件边缘边框的对象。
public class BorderFactory extends Object
提供标准 Border 对象的工厂类。在任何可能的地方，此工厂类都将提供对已共享 Border 实例的引用。该类中的方法均为静态方法。

单选按钮

单选按钮是让用户从一组组件中选择唯一的一个选项。Swing的JRadioButton类是用于创建单选框的。

（1）构造方法

（2）将单选钮组合成组

单选框可以像按钮一样添加到容器中。要将单选框分组，需要创建java.swing.ButtonGroup的一个实例，并用add方法把单选框添加到该实例中，如：

ButtonGroup btg = new ButtonGroup();
JRadioButton jrb1=new JRadioButton(“男”);
JRadioButton jrb2=new JRadioButton(“女”);
btg.add(jrb1);
btg.add(jrb2);

ButtonGroup类是一个不可见的组件，不需要将其增加到容器中显示，只是在逻辑上表示一个单选按钮组。

（3）ButtonGroup类常用方法

（4） JRadioButton类常用方法

（5） JRadioButton的事件

ActionEvent事件

监视器设置：addActionListener(ActionListener)
接口方法：actionPerformed(ActionEvent e)

ItemEvent事件

监视器设置： addItemListener(ItemListener)
接口方法： itemStateChanged(ItemEvent e)

public void itemStateChanged(ItemEvent e)
{
 // if(e.getSource() instanceof JRadioButton)
    if(jrb1.isSelected())
        //Process the selection for jrb1
    if(jrb2.isSelected())
        //Process the selection for jrb2
}

复选框

复选框是一种用户能够打开、关闭选项的组件，如同电灯开关一般。Swing的JCheckBox类是用于创建复选框的。

（1）构造方法

（2） JCheckBox类常用方法

（3） JCheckBox的事件

ActionEvent事件

监视器设置：addActionListener(ActionListener)
接口方法：actionPerformed(ActionEvent e)

ItemEvent事件

监视器设置： addItemListener(ItemListener)
接口方法：itemStateChanged(ItemEvent e)

public void itemStateChanged(ItemEvent e)
{
    if(e.getSource() instanceof JCheckBox)
        if(jchk1.isSelected())
            //Process the selection for jchk1;
        if(jchk2.isSelected())
            //Process the selection for jchk2;
}

组合框

JComboBox组件被称为组合框或者下列列表框，它将所有选项折叠收藏在一起，默认显示的是第一个添加的选项。当用户单击组合框时，会出现下拉式的选项列表，用户可以从中选择器中某一项并显示。
JComboBox组合框组件分为可编辑和不可编辑两种形式。

（1）构造方法

String items[]={“左对齐”,”右对齐”,”两端对齐”,”居中”,”分散对齐”};
JComboBox  jcb=new JcomboBox(items);

（2）常用方法

（3）JComboBox的事件

JComboBox可以引发ActionEvent和ItemEvent事件以及其他事件。选中一个新的选项时，JComboBox会产生两次ItemEvent事件，一次是取消前一个选项，另一次是选择当前选项。产生ItemEvent事件后JComboBox产生一个ActionEvent事件。要响应ItemEvent事件，需要实现处理方法itemStateChanged(ItemEvent e)来处理选择。

文本区

文本区(JTextArea)组件与文本框组件类似，区别是文本区组件显示的是多行文本，内容超出显示范围时，具有滚动显示的功能，文本框组件显示的是单行文本。

（1）构造方法

（2）常用方法

（3）常用事件

ActionEvent事件: 与文本框的ActionEvent事件相似。
DocumentEvent事件: 当用户在文本区编辑文本时，发生此事件，DocumentListener接口的三个方法要实现，方法格式如下：

密码框

密码框（JPasswordField extends JTextField）组件与文本框组件类似，区别在于密码框不显示输入的信息，而显示设置的回显字符，默认的回显字符是'*'。

（1）构造方法

（2）常用方法

（3）密码框的事件

与文本框的ActionEvent事件相似

列表

列表用于在多个列表项中选择，列表项是从0开始编号。AWT的List类和Swing的Jlist类用于列表。
注意：
List在缺省方式下不支持多选，而Jlist支持多选。
JList必须放在JScrollPane中，否则不支持滚动。

（1）构造方法

（2）常用方法

（3）ListModel

（4）Jlist的事件

ListSelectionEvent事件和ListDataEvent事件

JScrollPane

菜单

菜单是GUI中非常重要而常见的组件。
下拉式菜单一般位于窗口的顶部，包括菜单栏(JMenuBar)、菜单(JMenu)和菜单项(JMuneItem)，菜单项还可以再包含若干菜单项。
弹出菜单(JpopupMenu)也称为右键菜单或快捷菜单，单击鼠标右键会显示弹出菜单。

（1）菜单栏

菜单栏组件是存放菜单的容器，菜单栏不响应事件。
构造方法：public JMenuBar()
常用方法：

（2）菜单

菜单包含若干菜单项和分隔条。鼠标单击某个菜单时，该菜单展开。

构造方法：

常用方法：

常用事件：

（3）菜单项

菜单项是菜单中“项”的具体实现。当用鼠标或键盘选中时，就触发一个动作事件。菜单项可以是一个命令，也可以是另一个菜单（子菜单）。

构造方法：

常用方法：

（4）创建菜单的步骤：

1.创建菜单栏：MenuBar mnuBar=new MenuBar();
2.创建菜单并添加到菜单栏：
JMenu mnuFile=new JMenu("文件");
mnuBar.add(mnuFile);
3.创建菜单项并添加到菜单上
JMenuItem mnuNew=new JMenuItem("新建");
mnuFile.add(mnuNew);
4.将菜单栏添加到容器中： setJMenuBar(mnuNotepad);
5.添加事件侦听器并实现侦听器接口的相应方法： MenuListener、ActionListener

对话框

对话框是应用广泛的组件之一，它不能作为应用程序的主窗口，也没有最小化、最大化按钮，不能设置菜单栏。
对话框分为模式和非模式两种。模式对话框在显示时将阻塞用户对其他窗口的操作，如JOptionPane；非模式对话框在显示时并不阻塞用户对其他窗口的操作，如JDialog。

（1）JOptionPane类

JOptionPane是简单而常用的模式对话框类，它提供了四种常用的对话框样式。可以通过构造方法来创建对话框，也可以通过其静态方法showXxxDialog创建对话框。

import java.awt.*;   
import javax.swing.*;   
class JOptionPaneEx
{   
     public static void main(String[] arg)
    {   
              String s=JOptionPane.showInputDialog("请输入你的名字:");   
                  JOptionPane.showMessageDialog(null,"你好，"+s);   
    }   
}

（2）JDialog类

当JOptionPane类提供的四种常用的对话框模式无法满足需求时，就可以使用JDialog类来设计自定义的对话框。
构造方法：详见API文档

JFileChooser

JFileChooser 为用户选择文件提供了一种简单的机制。

构造方法：

常用方法：

JFileChooser jfc=new JFileChooser();
if(jfc.showSaveDialog(null)!= JFileChooser.APPROVE_OPTION)  return;
File file= jfc.getSelectedFile();

常用事件

鼠标事件

鼠标事件包括两大类，一类是发生在鼠标左键和右键上的事件，称为MouseEvent；另一类是发生在鼠标滚轮上的事件，称为MouseWheelEvent。
通过MouseListener侦听器接口和MouseMotionListener侦听器接口分别处理不同的MouseEvent事件。
通过MouseWheelListener侦听器接口处理MouseWheelEvent事件。

MouseEvent事件

MouseEvent事件包括以下两类：
鼠标事件类

MouseEvent事件的常用方法

MouseWheelEvent事件

MouseWheelEvent事件表示鼠标滚轮在组件中滚动。

MouseWheelEvent事件的常用方法

键盘事件

键盘事件KeyEvent是指按下、释放或键入某个键时发生的事件。

KeyEvent的常用方法

窗体事件

大部分GUI应用程序都需要使用Window窗体对象作为最外层的容器，可以说窗体对象时所有GUI应用程序的基础，应用程序中通常都是将其他组件直接或间接地置于窗体中。
当对窗体进行操作时，如窗体的打开、关闭、激活、停用等，这些动作都属于窗体事件，JDK中提供了一个类WindowEvent用于表示这些窗体事件。
WindowListener侦听器处理WindowEvent事件：当WindowListener侦听器侦听到WindowEvent事件发生时，根据发生的行为，执行相应的以下方法：

JFrame中实现窗口关闭的方法：

public void setDefaultCloseOperation(int operation)
参数的默认取值是“HIDE_ON_CLOSE”，其取值是下列常量之一：

上一篇下一篇

猜你喜欢

热点阅读