Java核心技术1-GUI事件模型

字数统计: 4.8k字 | 阅读时长: 20分

2022-06-11

摘要: 本文是《Java核心技术 10th》中关于 GUI 事件模型的要点总结。

【对算法，数学，计算机感兴趣的同学，欢迎关注我哈，阅读更多原创文章】
我的网站：潮汐朝夕的生活实验室
我的公众号：算法题刷刷
我的知乎：潮汐朝夕
我的github：FennelDumplings
我的leetcode：FennelDumplings

本文是《Java核心技术1》第10版 Chap13 中关于 GUI 事件模型的要点总结。

本文只记录一些关键组件的各个类之间的关系，以及主要功能的示例代码。具体如下：

处理按钮点击事件
改变观感
动作对象
鼠标事件

事件处理基础

(1) 事件对象

Java 中，将事件的相关信息封装在一个事件对象（event object）中。
所有的事件对象都最终派生于 java.util.EventObject 类。
每个事件类型还有子类，ActionEvent 和 WindowEvent。

(2) AWT 事件处理机制的概要

监听器对象是一个实现了特定监听器接口（listenerinterface）的类的实例。
事件源是一个能够注册监听器对象并发送事件对象的对象。
当事件发生时，事件源将事件对象传递给所有注册的监听器。
监听器对象将利用事件对象中的信息决定如何对事件做出响应。

(3) 事件处理类和接口之间的关系

(4) 事件源、事件监听器和事件对象之间的协作关系

(5) 指定监听器的几种方法

内部类：为事件监听器定义类并构造对象

private class ExitAction implements ActionListener {
    public void actionPerformed(ActionEvent event) {
        System.exit(0);
    }
}

// 添加 button 的 actions
ExitAction exitAction = new ExitAction();
// 将 buttons 与 actions 关联起来
exitButton.addActionListener(exitAction);

不建立单独的类。使用 lambda 表达式

1	exitButton.addActionListener(event -> System.exit(0));

匿名类

exitButton.addActionListener(new ActionListener() {
        public void actionPerformed(new ActionEvent) {
            System.exit(0);
        }
    });

(6) 窗口事件与窗口监听器

窗口监听器必须是实现 WindowListener 接口的类的一个对象。在 WindowListener 接口中包含 7 个方法。当发生窗口事件(WindowEvent)时，框架将调用这些方法响应 7 个不同的事件。从它们的名字就可以得

public interface WindowListener {
    void windowOpened(WindowEvent e);
    void windowClosing(WindowEvent e);
    void windowClose(WindowEvent e);
    void windowIconified(WindowEvent e);
    void windowDeiconified(WindowEvent e);
    void windowActivated(WindowEvent e);
    void windowDecativated(WindowEvent e);
}

适配器

每个含有多个方法的 AWT 监听器接口都配有一个适配器（adapter）类，这个类实现了接口中的所有方法，但每个方法没有做任何事情。ActionListener 只有一个方法，因此没有适配器类。

这样扩展适配器类的时候，就可以只实现某些事件的响应动作，而不用每个方法都实现。

class Terminator extends WindowAdapter {
    public void windowClosing(WindowEvent e) {
        if(user agrees) {
            System.exit(0);
        }
    }
}

WindowListener listener = new Terminator();
frame.addWindowListener(listener);

匿名类

frame.addWindowListener(new WindowAdapter() {
        public void windowClosing(WindowEvent e) {
            if(user agrees) {
                System.exit(0);
            }
        }
    });

动作对象, Action 接口

Swing 提供了封装命令的机制，并将它们连接到多个事件源，这就是 Action 接口。

Action 接口扩展于 ActionListener 接口，可以在任何需要 ActionListener 对象的地方使用 Action 对象。

Action 接口包含下列方法：

// ActionListener 超类中的方法
void actionPerformed(ActionEvent event)

// 启用或禁用该动作
void setEnabled(boolean b)
boolean isEnabled()

// 存储和检索动作对象中的任意值
// 例如预定义的字符串 Action.NAME 和 Action.SMALL_ICON 表示动作对象中的名字和图标。
void putValue(String key, Object value)
Object getValue(String key)

//  让其他对象在动作对象的属性发生变化时得到通告
void addPropertyChangeListener(PropertyChangeListener listener)
void removePropertyChangeListener(PropertyChangeListener listener)

实现 Action 接口的类必须实现这 7 个方法。AbstractAction 实现了除 actionPerformed 方法之外的所有方法。这个类存储了所有名/值对，并管理属性变更监听器。

AWT 事件继承层次

Java 事件处理采用的是面向对象方法，所有的事件都是由 java.util 包中的 EventObject 类扩展而来的。

EventObject 类有一个子类 AWTEvent，它是所有 AWT 事件类的父类，AWT 事件的继承关系图如下：

有些 Swing 组件将生成其他事件类型的事件对象；它们都直接扩展于 EventObject，而不是 AWTEvent。

事件对象封装了事件源与监听器彼此通信的事件信息。

可以对传递给监听器对象的事件对象进行分析。可以用 java.util.EventObject.getSource 和 java.awt.event.ActionEvent.getActionCommand 方法实现对象分析。

AWT将事件分为底层（low-level）事件和语义（semantic）事件。

下面是 java.awt.event 包中最常用的语义事件类：

ActionEvent（对应按钮点击、菜单选择、选择列表项或在文本框中ENTER）；
AdjustmentEvent（用户调节滚动条）；
ItemEvent（用户从复选框或列表框中选择一项）。

常用的 5 个底层事件类是：

KeyEvent（一个键被按下或释放）；
MouseEvent（鼠标键被按下、释放、移动或拖动）；
MouseWheelEvent（鼠标滚轮被转动）；
FocusEvent（某个组件获得焦点或失去焦点）；
WindowEvent（窗口状态被改变）。

下列接口监听这些事件：

ActionListener
AdjestmentListener
FocusListener
ItemListener
KeyListener
MouseListener
MouseMotionListener
MouseWheelListener
WindowListener
WindowFocusListener
WindowStateListener

有几个监听器接口配有适配器类，实现了接口的所有方法，但所有方法都没有做任何事情：

FocusAdapter
KeyAdapter
MouseAdapter
MouseMotionAdapter
WindowAdapter

AWT 监听器接口、事件、事件源总结

代码模板

(1) 处理按钮点击事件

一个面板中放置三个按钮，添加三个监听器对象用来作为按钮的动作监听器。

在这个情况下，只要用户点击面板上的任何一个按钮，相关的监听器对象就会接收到一个 Action Event 对象，它表示有个按钮被点击了。

实现监听功能，需要一个实现了 ActionListener 接口的类，包含一个 actionPerformed 方法

actionPerformed 方法（ActionListener 中的唯一方法）将接收一个 ActionEvent 类型的对象作为参数。这个事件对象包含了事件发生时的相关信息。

ColorAction 对象需要能访问 buttonpanel 变量。可以采用两种方式解决这个问题：

(1) 一个是将面板存储在 ColorAction 对象中，并在 ColorAction 的构造器中设置它。
(2) 另一个是将 ColorAction 作为 ButtonFrame 类的内部类，这样一来，它的方法就自动地拥有访问外部面板的权限了。

import java.awt.Color;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import javax.swing.JFrame;
import javax.swing.JPanel;
import javax.swing.JButton;

/**
 * 带有 button panel 的 frame
 */
public class ButtonFrame extends JFrame {
    private JPanel buttonPanel;
    private static final int DEFAULT_WIDTH = 300;
    private static final int DEFAULT_HEIGHT = 200;

    public ButtonFrame() {
        setSize(DEFAULT_WIDTH, DEFAULT_HEIGHT);

        // 创建 buttons
        JButton yellowButton = new JButton("Yellow");
        JButton blueButton = new JButton("Blue");
        JButton redButton = new JButton("Red");

        buttonPanel = new JPanel();

        // 向 panel 加入 buttons
        buttonPanel.add(yellowButton);
        buttonPanel.add(blueButton);
        buttonPanel.add(redButton);

        // 将 panel 加入 frame
        add(buttonPanel);

        // 添加 button 的 actions
        ColorAction yellowAction = new ColorAction(Color.YELLOW);
        ColorAction blueAction = new ColorAction(Color.BLUE);
        ColorAction redAction = new ColorAction(Color.RED);

        // 将 buttons 与 actions 关联起来
        yellowButton.addActionListener(yellowAction);
        blueButton.addActionListener(blueAction);
        redButton.addActionListener(redAction);
    }

    /**
     * action lister
     */
    private class ColorAction implements ActionListener {
        private Color backgroundColor;

        public ColorAction(Color c) {
            backgroundColor = c;
        }

        public void actionPerformed(ActionEvent event) {
            buttonPanel.setBackground(backgroundColor);
        }
    }
}

(2) 改变观感

调用静态的 UIManager.setLookAndFeel 方法，并提供所想要的观感类名，然后再调用静态方法 SwingUtilities.updateComponentTreeUI 来刷新全部的组件集。

import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JPanel;
import javax.swing.SwingUtilities;
import javax.swing.UIManager;

public class PlafFrame extends JFrame {
    private JPanel buttonPanel;

    public PlafFrame() {
        buttonPanel = new JPanel();

        UIManager.LookAndFeelInfo[] infos = UIManager.getInstalledLookAndFeels();
        for(UIManager.LookAndFeelInfo info: infos) {
            makeButton(info.getName(), info.getClassName());
        }

        add(buttonPanel);
        pack();
    }

    private void makeButton(String name, String className) {
        // 将 button 加入 Panel
        JButton button = new JButton(name);
        buttonPanel.add(button);

        // 设置 button 的 action
        button.addActionListener(event -> {
            // button 的 action: 改变观感
            try {
                UIManager.setLookAndFeel(className);
                SwingUtilities.updateComponentTreeUI(this);
                pack();
            } catch (Exception e) {
                e.printStackTrace();
            }
        });
    }
}

(3) 动作对象

构造一个用于执行改变颜色命令的动作对象：首先存储这个命令的名称、图标和需要的颜色。将颜色存储在 AsbstractAction 类提供的【名/值】对表中。下面代码中的 ColorAction 类，构造器设置【名/值】对，而 actionPerformed 方法执行改变颜色的动作。

接下来将这个动作与一个按钮关联起来：JButton 有一个用 Action 对象作为参数的构造器。构造器读取动作的名称和图标，为工具提示设置简要说明，将动作设置为监听器。

最后，将这个动作对象添加到击键中：以便让用户敲击键盘命令来执行这项动作。为了将动作与击键关联起来，需要生成 KeyStroke 类对象。

keyboard focus 的概念：用户界面中可以包含许多按钮、菜单、滚动栏以及其他的组件。当用户敲击键盘时，这个动作会被发送给拥有焦点的组件。

每个 JComponent 有三个输入映射（imput map），每一个映射的 KeyStroke 对象都与动作关联。三个输入映射对应着三个不同的条件：

标志	激活动作
WHEN_FOCUSED	当这个组件有键盘焦点时
WHEN_ANCESTOR_OF_FOCUSED_COMPONENT	当这个组件包含了拥有键盘焦点的组件时
WHEN_IN_FOCUSED_WINDOW	当这个组件被包含在一个拥有键盘焦点组件的窗口中时

InputMap 不能直接地将 KeyStroke 对象映射到 Action 对象，而是先映射到任意对象上，然后由 ActionMap 类实现将对象映射到动作上的第 2 个映射。这样容易实现来自不同输入映射的按键共享一个动作的目的。

下面是将按钮和按键映射到动作对象的完整代码：

import java.awt.Color;
import java.awt.event.ActionEvent;
import javax.swing.JFrame;
import javax.swing.JPanel;
import javax.swing.JButton;
import javax.swing.KeyStroke;
import javax.swing.JComponent;
import javax.swing.AbstractAction;
import javax.swing.Action;
import javax.swing.ActionMap;
import javax.swing.InputMap;
import javax.swing.ImageIcon;
import javax.swing.Icon;

public class ActionFrame extends JFrame {
    private JPanel buttonPanel;
    private static final int DEFAULT_WIDTH = 300;
    private static final int DEFAULT_HEIGHT = 200;

    public ActionFrame() {
        setSize(DEFAULT_WIDTH, DEFAULT_HEIGHT);
        buttonPanel = new JPanel();

        // 定义 actions
        Action yellowAction = new ColorAction("Yellow", new ImageIcon("yellow-ball.gkf"), Color.YELLOW);
        Action blueAction = new ColorAction("Blue", new ImageIcon("blue-ball.gkf"), Color.BLUE);
        Action redAction = new ColorAction("Red", new ImageIcon("red-ball.gkf"), Color.RED);

        // 为 actions 添加按钮
        buttonPanel.add(new JButton(yellowAction));
        buttonPanel.add(new JButton(blueAction));
        buttonPanel.add(new JButton(redAction));

        // 将 panel 添加到 frame
        add(buttonPanel);

        // 将 Y, B, R keys 与 name 关联
        InputMap imap = buttonPanel.getInputMap(JComponent.WHEN_ANCESTOR_OF_FOCUSED_COMPONENT);
        imap.put(KeyStroke.getKeyStroke("ctrl Y"), "panel.yellow");
        imap.put(KeyStroke.getKeyStroke("ctrl B"), "panel.blue");
        imap.put(KeyStroke.getKeyStroke("ctrl R"), "panel.red");

        // 将 names 与 actions 关联
        ActionMap amap = buttonPanel.getActionMap();
        amap.put("panel.yellow", yellowAction);
        amap.put("panel.blue", blueAction);
        amap.put("panel.red", redAction);
    }

    public class ColorAction extends AbstractAction {
        public ColorAction(String name, Icon icon, Color c) {
            putValue(Action.NAME, name);
            putValue(Action.SMALL_ICON, icon);
            putValue(Action.SHORT_DESCRIPTION, "Set panel color to" + name.toLowerCase());
            putValue("color", c);
        }

        public void actionPerformed(ActionEvent event) {
            Color c = (Color) getValue("color");
            buttonPanel.setBackground(c);
        }
    }
}

(4) 鼠标事件

允许用户在画布上【放置、移动和擦除】方块。

当用户点击鼠标按钮时，将会调用三个监听器方法：鼠标第一次被按下时调用 mousePressed；鼠标被释放时调用 mouseReleased；最后调用 mouseClicked。如果只对最终的点击事件感兴趣，可以忽略前两个方法。

本例提供了 mousePressed 和 mouseClicked 方法。当鼠标点击在所有小方块的像素之外时，就会绘制一个新的小方块。这个操作是在 mousePressed 方法中实现的，这样可以让用户的操作立即得到响应，而不必等到释放鼠标按键。如果用户在某个小方块中双击鼠标，就会将它擦除。由于需要知道点击次数，所以这个操作将在 mouseClicked 方法中实现。

当鼠标在窗口上移动时，窗口将会收到一连串的鼠标移动事件。有两个独立的接口 MouseListener 和 MouseMotionListener。这样做有利于提高效率。当用户移动鼠标时，只关心鼠标点击（clicks）的监听器就不会被多余的鼠标移动（moves）所困扰。

捕获鼠标动作事件，以便在光标位于一个小方块之上时变成另外一种形状（十字）。实现这项操作需要使用 Cursor 类中的 getPredefinedCursor 方法。

可以利用 Toolkit 类中的 createCustomCursor 方法自定义光标类型

如果用户在移动鼠标的同时按下鼠标，就会调用 mouseMoved 而不是调用 mouseDragged。

还有两个鼠标事件方法：mouseEntered 和 mouseExited 。这两个方法是在鼠标进入或移出组件时被调用。

监听鼠标事件：鼠标点击由 mouseClicked 过程报告，它是 MouseListener 接口的一部分；鼠标移动事件与拖动事件定义在一个称为 MouseMotionListener 的独立接口中。

本例对两种鼠标事件类型都感兴趣。这里定义了两个内部类：MouseHandler 和 MouseMotionHandler。

MouseHandler 类扩展于 MouseAdapter 类，这是因为它只定义了 5 个 MouseListener 方法中的两个方法。
MouseMotionHandler 实现了 MouseMotionListener 接口，并定义了这个接口中的两个方法。

import java.awt.*;
import java.awt.geom.*;
import java.awt.event.*;
import java.util.*;
import javax.swing.*;

public class MouseComponent extends JComponent {
    private static final int DEFAULT_WIDTH = 300;
    private static final int DEFAULT_HEIGHT = 200;

    private static final int SIDELENGTH = 10;
    private ArrayList<Rectangle2D> squares;
    private Rectangle2D current; // 包含鼠标光标的区域

    public MouseComponent() {
        squares = new ArrayList<>();
        current = null;

        addMouseListener(new MouseHandler());
        addMouseMotionListener(new MouseMotionHandler());
    }

    public Dimension getPreferredSize() {
        return new Dimension(DEFAULT_WIDTH, DEFAULT_HEIGHT);
    }

    public void paintComponent(Graphics g) {
        Graphics2D g2 = (Graphics2D) g;

        for(Rectangle2D r: squares) {
            g2.draw(r);
        }
    }

    public Rectangle2D find(Point2D p) {
        for(Rectangle2D r: squares) {
            if(r.contains(p)) {
                return r;
            }
        }
        return null;
    }

    public void add(Point2D p) {
        double x = p.getX();
        double y = p.getY();

        current = new Rectangle2D.Double(x - SIDELENGTH / 2, y - SIDELENGTH / 2, SIDELENGTH, SIDELENGTH);
        squares.add(current);
        repaint();
    }

    public void remove(Rectangle2D s) {
        if(s == null) {
            return;
        }
        if(s == current) {
            current = null;
        }
        squares.remove(s);
        repaint();
    }

    private class MouseHandler extends MouseAdapter {
        public void mousePressed(MouseEvent event) {
            current = find(event.getPoint());
            if(current == null) {
                add(event.getPoint());
            }
        }

        public void mouseClicked(MouseEvent event) {
            current = find(event.getPoint());
            if(current != null && event.getClickCount() >= 2) {
                remove(current);
            }
        }
    }

    private class MouseMotionHandler implements MouseMotionListener {
        public void mouseMoved(MouseEvent event) {
            if(find(event.getPoint()) == null) {
                setCursor(Cursor.getDefaultCursor());
            } else {
                setCursor(Cursor.getPredefinedCursor(Cursor.CROSSHAIR_CURSOR));
            }
        }

        public void mouseDragged(MouseEvent event) {
            if(current != null) {
                int x = event.getX();
                int y = event.getY();

                current.setFrame(x - SIDELENGTH / 2, y - SIDELENGTH / 2, SIDELENGTH, SIDELENGTH);
                repaint();
            }
        }
    }
}

API 总结

`javax.swing.JButton`

// 构造一个按钮。标签可以是常规的文本，也可以是HTML。例如，“<html><b>Ok</b></html>”。
JButton(String label)
JButton(Icon icon)
JButton(String label, Icon icon)

`java.awt.Container`

1 2	// 将组件 c 添加到这个容器中。 Component add(Component c)

`java.awt.event.ActionEvent`

1
2
3

// 返回与这个动作事件关联的命令字符串
// 如果这个动作事件源自一个按钮，命令字符串就等于按钮标签，除非已经用 setActionCommand 方法改变了命令字符串。
String getActionCommand()

`java.beans.EventHandler`

// 构造实现给定接口的一个代理类的对象。接口的指定方法或所有方法会在目标对象上执行给定的动作。
// 这个动作可以是一个方法名，或者是目标的一个属性。
// 如果这是一个属性，则执行它的设置方法。例如，动作"text"会转换为一个setText方法调用。
// 事件属性由一个或多个由点号（.）分隔的属性名组成。第一个属性从监听器方法的参数读取，第二个属性由得到的对象读取，依此类推。
// 最终结果会成为动作的参数。例如，属性"source.text"会转换为 getSource 和 getText 方法调用。
static <T> T create(Class<T> listenerInterface, Objecttarget, String action)
static <T> T create(Class<T> listenerInterface, Objecttarget, String action, String eventProperty)
static <T> T create(Class<T> listenerInterface, Objecttarget, String action, String eventProperty, StringlistenerMethod)

`java.util.EventObject`

1 2	// 返回发生这个事件的对象的一个引用。 Object getSource()

`javax.swing.UIManager`

// 获得一个用于描述已安装的观感实现的对象数组。
static UIManager.LookAndFeelInfo[]getInstalledLookAndFeels()
// 利用给定的类名设置当前的观感。例如，javax.swing.plaf.metal.MetalLookAndFeel
static setLookAndFeel(String className)

`javax.swing.UIManager.LookAndFeelInfo`

// 返回观感的显示名称。
String getName()
// 返回观感实现类的名称。
String getClassName()

`java.awt.event.WindowListener`

// 窗口打开后调用这个方法。
void windowOpened(WindowEvent e)

// 在用户发出窗口管理器命令关闭窗口时调用这个方法。需要注意的是，仅当调用hide或dispose方法后窗口才能够关闭。
void windowClosing(WindowEvent e)

// 窗口关闭后调用这个方法。
void windowClosed(WindowEvent e)

// 窗口图标化后调用这个方法。
void windowIconified(WindowEvent e)

// 窗口非图标化后调用这个方法。
void windowDeiconified(WindowEvent e)

// 激活窗口后调用这个方法。只有框架或对话框可以被激活。通常，窗口管理器会对活动窗口进行修饰，比如，高亮度标题栏。
void windowActivated(WindowEvent e)

// 窗口变为未激活状态后调用这个方法。
void windowDeactivated(WindowEvent e)

`java.awt.event.WindowStateListener`

1 2	// 窗口被最大化、图标化或恢复为正常大小时调用这个方法。 void windowStateChanged(WindowEvent event)

`java.awt.event.WindowEvent`

// 返回窗口状态改变事件中窗口的新、旧状态。返回的整型数值是下列数值之一：
// Frame.NORMAL
// Frame.ICONIFIED
// Frame.MAXIMIZED_HORIZ
// Frame.MAXIMIZED_VERT
// Frame.MAXIMIZED_BOTH
int getNewState() 
int getOldState()

`javax.swing.Action`

// 获得或设置这个动作的enabled属性。
boolean isEnalbled()
void setEnabled(boolean b)

// 将【名/值】对放置在动作对象内。参数：
// key　用动作对象存储性能的名字。它可以是一个字符串，但预定义了几个名字。
// value　与名字关联的对象。
void putValue(String key, Object value)

// 返回被存储的名/值对的值。
Object getValue(String key)

`javax.swing.KeyStroke`

// 根据一个便于人们阅读的说明创建一个按键（由空格分隔的字符串序列）。
// 这个说明以 0 个或多个修饰符 shift control ctrl meta alt altGraph 开始，
// 以由 typed 和单个字符构成的字符串（例如：“typed a”）
// 或者一个可选的事件说明符（pressed 默认，或 released）紧跟一个键码结束。
// 以 VK_ 前缀开始的键码应该对应一个 KeyEvent 常量，例如，“INSERT” 对应 KeyEvent.VK_INSERT。
static KeyStroke getKeyStroke(String description)

`javax.swing.JComponent`

// 返回关联动作映射键（可以是任意的对象）和动作对象的映射。
ActionMap getActionMap()

// 获得将按键映射到动作键的输入映射。参数：
// flag　触发动作的键盘焦点条件。具体的值如下
// WHEN_FOCUSED: 当该组件拥有键盘焦点时
// WHEN_ANCESTOR_OF_FOCUSED_COMPONENT: 当这个组件包含了拥有键盘焦点的组件时
// WHEN_IN_FOCUSED_WINDOW: 当这个组件被包含在一个拥有键盘焦点组件的窗口中时
InputMap getInputMap(int flag)

`java.awt.event.MouseEvent`

// 返回事件发生时，事件源组件左上角的坐标x（水平）和y（竖直），或点信息。
int getX()
int getY()
Point getPoint()

// 返回与事件关联的鼠标连击次数（“连击”所指定的时间间隔与具体系统有关）。
int getClickCount()

`java.awt.event.InputEvent`

// 返回事件扩展的或“按下”（down）的修饰符。使用下面的掩码值检测返回值：
// BUTTON1_DOWN_MASK
// BUTTON2_DOWN_MASK
// BUTTON3_DOWN_MASK
// SHIFT_DOWN_MASK
// CTRL_DOWN_MASK
// ALT_DOWN_MASK
// ALT_GRAPH_DOWN_MASK
// META_DOWN_MASK
int getModifiersEx() 

// 返回用给定标志集描述的扩展或“按下”（down）的修饰符字符串，例如“Shift+Button1”。
static String getModifiersExText(int modifiers)

`java.awt.Toolkit`

// 创建一个新的定制光标对象。参数：
// image: 光标活动时显示的图像 
// hotSpot: 光标热点（箭头的顶点或十字中心）
// name: 光标的描述，用来支持特殊的访问环境
public Cursor createCustomCursor(Image image, PointhotSpot, String name)

`java.awt.Component`

1 2	// 用光标图像设置给定光标。 public void setCursor(Cursor cursor)

编程Java

事件处理基础

(1) 事件对象

(2) AWT 事件处理机制的概要

(3) 事件处理类和接口之间的关系

(4) 事件源、事件监听器和事件对象之间的协作关系

(5) 指定监听器的几种方法

内部类：为事件监听器定义类并构造对象

不建立单独的类。使用 lambda 表达式

匿名类

(6) 窗口事件与窗口监听器

适配器

匿名类

动作对象, Action 接口

AWT 事件继承层次

AWT 监听器接口、事件、事件源总结

代码模板

(1) 处理按钮点击事件

(2) 改变观感

(3) 动作对象

(4) 鼠标事件

API 总结

javax.swing.JButton

java.awt.Container

java.awt.event.ActionEvent

java.beans.EventHandler

java.util.EventObject

javax.swing.UIManager

javax.swing.UIManager.LookAndFeelInfo

java.awt.event.WindowListener

java.awt.event.WindowStateListener

java.awt.event.WindowEvent

javax.swing.Action

javax.swing.KeyStroke

javax.swing.JComponent

java.awt.event.MouseEvent

java.awt.event.InputEvent

java.awt.Toolkit

java.awt.Component