V2AS问路
201871010132--张潇潇--《面向对象程序设计（java）》第十三周学习总结
阅读原文时间：2023年07月12日阅读：1

博文正文开头格式：（2分）

项目

内容

这个作业属于哪个课程

https://www.cnblogs.com/nwnu-daizh/

这个作业的要求在哪里

https://www.cnblogs.com/nwnu-daizh/p/11435127.html

作业学习目标

本章内容：
  1. 在AWT所知的事件范围内，完全可以控制事件从事件源（event source）例如，按钮或滚动条，到事件监听器（event listener）的传递过程，并将任何对象指派给事件监听器。不过事实上，应该选择一个能够便于响应事件的对象。这种事件委托模型（event delegation event）与Visual Basic那种预定义监听器模型比较起来更加灵活。
  2. 事件源有一些向其注册事件监听器的方法。当某个事件源产生事件时，事件源会向为事件注册的所有事件监听器对象发送一个通告。
  3. 像Java这样的面向对象语言，都将事件的相关信息封装在一个事件对象（event object）中。在Java中，所有的事件对象都最终派生于java.util.EventObject类。
  4. 不同的事件源可以产生不同类别的事件。
  5. AWT事件处理机制的概要：
    • 监听器对象是一个实现了特定监听器接口（listener interface）的类的实例。
    • 事件源是一个能够注册监听器对象并发送事件对象的对象。
    • 当事件发生时，事件源将事件对象传递给所有注册的监听器。
    • 监听器对象将利用事件对象中的信息决定如何对事件做出响应。

11.1.1 实例：处理按钮点击事件

  1. 可以通过在按钮构造器中指定一个标签字符串、一个图标或两项都指定来创建一个按钮。
  2. ActionListener接口并不仅限于按钮点击事件。它可以应用于很多情况：
    • 当采用鼠标双击的方式选择了列表框中的一个选项时；
    • 当选择一个菜单项时；
    • 当在文本域中按回车键时；
    • 对于一个Timer组件来说，当达到指定的时间间隔时。
      在所有这些情况下，使用ActionListener接口的方式都是一样的：actionPerformed方法（ActionListener中的唯一方法）将接收一个ActionEvent类型的对象作为参数。这个事件对象包含了事件发生时的相关信息。
  3. 事件监听器对象通常需要执行一些对其他对象可能产生影响的操作。可以策略性地将监听器类放置在需要修改状态的那个类中。
  4. jaxax.swing.JButton 1.2
    • JButton(String label)
    • JButton(Icon icon)
    • JButton(String label,Icon icon)
      构造一个按钮，标签可以是常规的文本，从Java1.3开始，也可以是HTML。
  5. java.awt.Container 1.0
    • Component add(Component c)
      将组件c添加到这个容器中。

11.1.2 建议使用内部类

  1. 内部类机制将自动地生成一个构造器，其中存储着所有用在内部类方法中的final局部变量。
  2. java.util.EventObject 1.1
    • Object getSource()
      返回发生事件的对象引用。
  3. java.awt.event.ActionEvent 1.1
    • String getActionCommand()
      返回与这个动作事件相关的命令字符串。如果动作事件来源于按钮，命令字符串就等于按钮标签，除非已经使用setActionCommand方法对字符串进行了修改。

11.1.3 创建包含一个方法调用的监听器

  1. EventHandler类可以使用下列调用，自动地创建这样一个监听器：EventHandler.create(ActionListener.class,frame,"loadData")。
  2. java.beans.EventHandler 1.4
    • static Object create(Class listenerInterface,Object target,String action)
    • static Object create(Class listenerInterface,Object target, String action,String eventProperty)
    • static Object create(Class listenerInterface,Object target,String action,String eventProperty,String listenerMethod)
      构造实现给定接口的一个代理类对象。命名方法或接口的所有方法都将在目标对象上执行给定动作。
      这个动作可以是一个方法名或目标的一个属性。如果是一个属性，将执行其设置方法。
      事件属性包括一个或多个用点号分割的属性名。第一个属性从监听器方法的参数读取，第二个属性由结果对象读取，依次类推。最后的结果将作为动作的参数。

11.1.4 实例：改变观感

  1. 在默认情况下，Swing程序使用Metal观感，可以采用两种方式改变观感。第一种方式是在Java安装的子目录jre/lib下有一个文件swing.properties。在这个文件中，将属性swing.defaultlaf设置为所希望的观感类名。
    注意，Metal观感位于javax.swing包中。其他的观感位于com.sun.java包中，并且不是在每个Java实现中都提供。现在，鉴于版权的原因，Windows和Macintosh的观感包只与Windows和Macintosh版本的Java运行时环境一起发布。
    第二种方式是动态地改变观感。这需要调用静态的UIManager.setLookAndFeel方法，并提供所想要的观感类名，然后再调用静态方法SwingUtilities.updateComponentTreeUI来刷新全部的组件集。这里需要向这个方法提供一个组件，并由此找到其他的所有组件。当UIManager.setLookAndFeel方法没有找到所希望的观感或在加载过程中出现错误时，将会抛出异常。
  2. javax.swing.UIManager 1.2
    • static UIManager.LookAndFeelInfo[] getInstalledLookAndFeels()
      获取一个用于描述已安装的观感实现的对象数组。
    • static setLookAndFeel(String className)
      利用给定的类名设置当前的观感。例如，javax.swing.plaf.MetalLookAndFeel。
  3. javax.swing.UIManager.LookAndFeelInfo 1.2
    • String getName()
      返回观感的显示名称。
    • String getClassName()
      返回观感实现类的名称。

11.1.5 适配器类

  1. 为了能够查看窗口是否被最大化，需要安装WindowStateListener。

  2. 每个含有多个方法的AWT监听器接口都配有一个适配器（adapter）类，这个类实现了接口中的所有方法，但每个方法没有做任何事情。这意味着适配器类自动满足了Java实现相关监听器接口的技术需求。可以通过扩展适配器类来指定对某些时间的响应动作，而不必实现接口中的每个方法。

  3. java.awt.event.WindowListener 1.1

    • void windowOpened(WindowEvent e)
      窗口打开后调用这个方法。
    • void windowClosing(WindowEvent e)
      在用户发出窗口管理器命令关闭窗口时调用这个方法。需要注意的是，仅当调用hide或dispose方法后窗口才能够关闭。
    • void windowClosed(WindowEvent e)
      窗口关闭后调用这个方法。
    • void windowIconified(WindowEvent e)
      窗口图标化后调用这个方法。
    • void windowDeiconified(WindowEvent e)
      窗口非图标化后调用这个方法。
    • void windowActivated(WindowEvent e)
      激活窗口后调用这个方法。只有框架或对话框可以被激活。通常，窗口管理器会对活动窗口进行修饰，比如，高亮度标题栏。
    • void windowDeactivated(WindowEvent e)
      窗口变为未激活状态后调用这个方法。
    • void windowStateChanged(WindowEvent event)
      窗口最大化、图标化或恢复为正常大小时调用这个方法。
    • int getNewState()1.4
    • int getOldState() 1.4
      返回窗口状态改变事件中窗口的新、旧状态。返回的整型数值是下列数值之一：Frame.NORMAL、Frame.ICONIFIED、Frame.MAXIMIZED_HORIZ、Frame.MAXIMIZED_VERT、Frame.MAXIMIZED_BOTH。

  4. 通常，激活一个命令可以有多种方式。用户可以通过菜单、击键或工具栏上的按钮选择特定的功能。在AWT事件模型中实现这些非常容易：将所有事件连接到同一个监听器上。

  5. Swing包提供了一种非常实用的机制来封装命令，并将它们连接到多个事件源，这就是Action接口。一个动作是一个封装下列内容的对象：

    • 命令的说明（一个文本字符串和一个可选图标）；
    • 执行命令所需要的参数。

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

  7. 预定义动作表名称

    名称

    值

    NAME

    动作名称，显示在按钮和菜单上

    SMALL_ICON

    存储小图标的地方；显示在按钮、菜单项或工具栏中

    SHORT_DESCRIPTION

    图标的简要说明；显示在工具提示中

    LONG_DESCRIPTION

    图标的详细说明；使用在在线帮助中。没有Swing组件使用这个值

    MNEMONIC_KEY

    快捷键缩写；显示在菜单项中

    ACCELERATOR_KEY

    存储加速击键的地方；Swing组件不使用这个值

    ACTION_COMMAND_KEY

    历史遗留；仅在旧版本的registerKeyboardAction方法中使用

    DEFAULT

    常用的综合属性；Swing组件不使用这个值

  8. 如果动作对象添加到菜单或工具栏上，它的名称和图标就会被自动地提取出来，并显示在菜单栏或工具栏项中。SHORT_DESCRIPTION值变成了工具提示。

  9. Action是一个接口，而不是一个类。有一个类实现了这个接口除actionPerformed方法之外的所有方法，它就是AbstractAction。这个类存储了所有名、值对。并管理着属性变更监听器。可以直接扩展AbstractAction类，并在扩展类中实现了actionPerformed方法。

  10. 每个JComponent有三个输入映射（input maps），每一个映射的KeyStore对象都与动作关联。三个输入映射对应着三个不同的条件。
    输入映射表

    标志

    激活动作

    WHEN_FOCUSED

    当这个组件拥有键盘焦点时

    WHEN_ANCESTOR_OF_FOCUSED_COMPONENT

    当这个组件包含了拥有键盘焦点的组件时

    WHEN_IN_FOCUSED_WINDOW

    当这个组件被包含在一个拥有键盘焦点组件的窗口中时

  11. 按键处理将按照下列顺序检查这些映射：
    1）检查具有输入焦点组件的WHEN_FOCUSED映射。如果这个按键存在，将执行对应的动作。如果动作已启动，则停止处理。
    2）从具有输入焦点的组件开始，检查其父组件的WHEN_ANCESTOR_OF_FOCUSED_COMPONENT映射。一旦找到按键对应的映射，就执行对应的动作。如果动作已启用，将停止处理。
    3）查看具有输入焦点的窗口中的所有可视的和启用的组件，这个按键被注册到WHEN_IN_FOCUSED_WINDOW映射中。给这些组件（按照按键注册的顺序）一个执行对应动作的机会。一旦第一个启用的动作被执行，就停止处理。如果一个按键咋多个WHEN_IN+FOCUSED_WINDOW映射中出现，这部分处理就可能会出现问题。

  12. 可以使用getInputMap方法从组件中得到输入映射。

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

  14. 每个组件都可以有三个输入映射和一个动作映射。为了将他们组合起来，需要为动作命名。

  15. 用同一个动作响应按钮、菜单项或按键的方式：
    1）实现一个扩展于AbstractAction类的类。多个相关的动作可以使用同一个类。
    2）构造一个动作类的对象。
    3）使用动作对象创建按钮或菜单项。构造器将从动作对象中读取标签文本和图标。
    4）为了能够通过按键触发动作，必须额外地执行几步操作。首先定位顶层窗口组件，例如，包含所有其他组件的面板。
    5）然后，得到顶层组件的WHEN_ANCESTOR_OF_FOCUS_COMPONENT输入映射。为需要的按键创建一个KeyStore对象。创建一个描述动作字符串这样的动作键对象。将（按键，动作键）对添加到输入映射中。
    6）最后，得到顶层组件的动作映射。将（动作键，动作对象）添加到映射中。

  16. javax.swing.Action 1.2

    • boolean isEnabled()
    • void setEnabled(boolean b)
      获得或设置这个动作额enabled属性。
    • void putValue(String key,Object value)
      将名/值对防止在动作对象内。
      参数：key 用动作对象存储性能的名字。它可以是一个字符串，但预定义了几个名字。 value 与名字关联的对象。
    • Object getValue(String key)
      返回被存储的名/值对的值。

  17. javax.swing.KeyStore 1.2

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

  18. javax.swing.JComponent 1.2

    • ActionMap getActionMap() 1.3
      返回关联动作映射键（可以是任意的对象）和动作对象的映射。
    • InputMap getInputMap(int flag) 1.3
      获得将案件映射到动作键的输入映射。
      参数：flag 触发动作的键盘焦点条件。

  19. 当用户点击鼠标按钮时，将会调用三个监听器方法：鼠标第一次按下时调用mousePressed；鼠标被释放时调用mouseReleased；最后调用mouseClicked。如果只对最终的点击事件感兴趣，就可以忽略前两个方法。用MouseEvent类对象作为参数，调用getX和getY方法可以获得鼠标被按下时鼠标指针所在x和y坐标。要想区分单击、双击和三击（！），需要使用getClickCount方法。

  20. getModifiersEx方法能够准确地报告鼠标事件的鼠标按钮和键盘修饰符。

  21. 在Windows环境下，使用BUTTON3_DOWN_MASK检测鼠标右键（非主要的）的状态。

  22. java.awt.event.MouseEvent 1.1

    • int getX()
    • int getY()
    • Point getPoint()
      返回事件发生时，事件源组件左上角的坐标x（水平）和y（垂直），或点信息。
    • int getClickCount()
      返回与事件关联的鼠标连击次数（“连击”所指定的时间间隔与具体系统有关）。

  23. java.awt.event.InputEvent 1.1

    • int getModifiersEx() 1.4
      返回事件扩展的或“按下”（down）的修饰符。使用下面的掩码值检测返回值：BTTON1_DOWN_MASK、BUTTON2_DOWN_MASK、BUTTON3_DOWN_MASK、SHIFT_DOWN_MASK、CTRL_DOWN_MASK、ALT_DOWN_MASK、ALT_GRAPH_DOWN_MASK、META_DOWN_MASK。
    • static String getModifiersExText(int modifiers) 1.4
      返回用给定标志集描述的扩展或“按下”（down）的修饰符字符串，例如“Shift+Button1”。

  24. java.awt.Toolkit 1.0

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

  25. java.awt.Component 1.0

    • public void setCursor(Cursor cursor) 1.1
      用光标图像设置给定光标。

二：实验部分。

2、实验目的与要求

(1) 掌握事件处理的基本原理，理解其用途；

(2) 掌握AWT事件模型的工作机制；

(3) 掌握事件处理的基本编程模型；

(4) 了解GUI界面组件观感设置方法；

(5) 掌握WindowAdapter类、AbstractAction类的用法；

(6) 掌握GUI程序中鼠标事件处理技术。

2、实验内容和步骤

实验1： 导入第11章示例程序，测试程序并进行代码注释。

测试程序1：

l 在elipse IDE中调试运行教材443页-444页程序11-1，结合程序运行结果理解程序；

l 在事件处理相关代码处添加注释；

l 用lambda表达式简化程序；

l 掌握JButton组件的基本API；

l 掌握Java中事件处理的基本编程模型。

程序如下：

import java.awt.*;
import javax.swing.*;

import button.ButtonFrame;

/**
* @version 1.34 2015-06-12
* @author Cay Horstmann
*/
public class ButtonTest
{
public static void main(String[] args)
{
EventQueue.invokeLater(() ->//lambda表达式
{
JFrame frame = new ButtonFrame();
frame.setTitle("ButtonTest");//标题
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
frame.setVisible(true);//可见
});
}
}

package button;

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

/**
* 带有按钮的面板框架
*/
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);

  //创建按钮  
  JButton yellowButton = new JButton("Yellow");  
  JButton blueButton = new JButton("Blue");  
  JButton redButton = new JButton("Red");  
  JButton greenButton = new JButton("Green");  
  buttonPanel = new JPanel();

  // add buttons to panel  
  buttonPanel.add(yellowButton);  
  buttonPanel.add(blueButton);  
  buttonPanel.add(redButton);  
  buttonPanel.add(greenButton);  
  // add panel to frame  
  add(buttonPanel);

  //按钮将要执行的操作  
  ColorAction yellowAction = new ColorAction(Color.YELLOW);  
  ColorAction blueAction = new ColorAction(Color.BLUE);  
  ColorAction redAction = new ColorAction(Color.RED);  
  ColorAction greenAction = new ColorAction(Color.GREEN);  
  // 将按钮与操作进行联系  
  yellowButton.addActionListener(yellowAction);  
  blueButton.addActionListener(blueAction);  
  redButton.addActionListener(redAction);  
  greenButton.addActionListener(greenAction);

}

/**
* An action listener that sets the panel's background color.
*/
private class ColorAction implements ActionListener//实现监听器接口
{
private Color backgroundColor;//定义背景色

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

  public void actionPerformed(ActionEvent event)//按钮单机操作  
  {  
     buttonPanel.setBackground(backgroundColor);  
  }

}
}

程序运行结果如下：

改进后：

package button;
import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
/**
* A frame with a button panel
*/
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);
buttonPanel = new JPanel();

  add(buttonPanel);

makeButton("yellow",Color.YELLOW);
makeButton("blue",Color.BLUE);
makeButton("red",Color.RED);
makeButton("green",Color.GREEN);
}
public void makeButton(String name , Color backgroundColor)
{
JButton button=new JButton(name);
buttonPanel.add(button);
ColorAction action=new ColorAction(backgroundColor);
button.addActionListener(action);
}

/**
* An action listener that sets the panel's background color.
*/
private class ColorAction implements ActionListener
{
private Color backgroundColor;
public ColorAction(Color c)
{
backgroundColor = c;
}
public void actionPerformed(ActionEvent event)
{
buttonPanel.setBackground(backgroundColor);
}
}
}

测试程序2：

l 在elipse IDE中调试运行教材449页程序11-2，结合程序运行结果理解程序；

l 在组件观感设置代码处添加注释；

l 了解GUI程序中观感的设置方法。

程序如下：

import java.awt.*;
import javax.swing.*;

/**
* @version 1.32 2015-06-12
* @author Cay Horstmann
*/
public class PlafTest
{
public static void main(String[] args)
{
EventQueue.invokeLater(() -> {
JFrame frame = new PlafFrame();
frame.setTitle("PlafTest");
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
frame.setVisible(true);
});
}
}

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();

}

/**
* 创建一个按钮来更改可插入的外观.
* @param name the button name
* @param className the name of the look-and-feel class
*/
private void makeButton(String name, String className)
{
//添加按钮到面板

  JButton button = new JButton(name);  
  buttonPanel.add(button);

  //设置按钮要进行的操作

  button.addActionListener(event -> {  
     // 按钮操作结果: 切换到新的外观  
     try //可能出错的代码放入try子句中  
     {  
        UIManager.setLookAndFeel(className);  
        SwingUtilities.updateComponentTreeUI(this);  
        pack();  
     }  
     catch (Exception e)  
     {  
        e.printStackTrace();  
     }  
  });

}
}

程序运行结果如下：

测试程序3：

l 在elipse IDE中调试运行教材457页-458页程序11-3，结合程序运行结果理解程序；

l 掌握AbstractAction类及其动作对象；

l 掌握GUI程序中按钮、键盘动作映射到动作对象的方法。

程序如下：

import java.awt.*;
import javax.swing.*;

/**
* @version 1.34 2015-06-12
* @author Cay Horstmann
*/
public class ActionTest
{
public static void main(String[] args)
{
EventQueue.invokeLater(() -> //lambda表达式
{
JFrame frame = new ActionFrame();
frame.setTitle("ActionTest");//标题
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
frame.setVisible(true);//可见
});
}
}

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

/**
* A frame with a panel that demonstrates color change actions.
*/
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();

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

  // add buttons for these actions  
  buttonPanel.add(new JButton(yellowAction));  
  buttonPanel.add(new JButton(blueAction));  
  buttonPanel.add(new JButton(redAction));

  // add panel to frame  
  add(buttonPanel);

  // 将Y、B和R键与名称关联起来  
  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");

  // associate the names with 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
{
/**
* Constructs a color action.
* @param name the name to show on the button
* @param icon the icon to display on the button
* @param c the background color
*/
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);  
  }

}
}

程序运行时只需同时按Ctrl+Y或R或B键，窗口就会自动显示某种颜色，如下：

测试程序4：

l  在elipse IDE中调试运行教材462页程序11-4、11-5，结合程序运行结果理解程序；

l  掌握GUI程序中鼠标事件处理技术。

程序如下：

package mouse;
import java.awt.*;
import java.awt.event.*;
import java.awt.geom.*;
import java.util.*;
import javax.swing.*;
/**
* A component with mouse operations for adding and removing squares.
*/
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 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);
}
/**
* Finds the first square containing a point.
* @param p a point
* @return the first square that contains p
*/
public Rectangle2D find(Point2D p)
{
for (Rectangle2D r : squares)
{
if (r.contains(p)) return r;
}
return null;
}
/**
* Adds a square to the collection.
* @param p the center of the square
*/
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();
}
/**
* Removes a square from the collection.
* @param s the square to remove
*/
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();
//拖动当前矩形，使其居中(x, y)
current.setFrame(x - SIDELENGTH / 2, y - SIDELENGTH / 2, SIDELENGTH, SIDELENGTH);
repaint();
}
}
}
}

package mouse;
import javax.swing.*;
/**
* A frame containing a panel for testing mouse operations
*/
public class MouseFrame extends JFrame
{
public MouseFrame()
{
add(new MouseComponent());
pack();
}
}

package mouse;
import java.awt.*;
import javax.swing.*;
/**
* @version 1.34 2015-06-12
* @author Cay Horstmann
*/
public class MouseTest
{
public static void main(String[] args)
{
EventQueue.invokeLater(() -> {
JFrame frame = new MouseFrame();
frame.setTitle("MouseTest");
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
frame.setVisible(true);
});
}
}

实验2：结对编程练习

利用班级名单文件、文本框和按钮组件，设计一个有如下界面（图1）的点名器，要求用户点击开始按钮后在文本输入框随机显示2018级计算机科学与技术（1）班同学姓名，如图2所示，点击停止按钮后，文本输入框不再变换同学姓名，此同学则是被点到的同学姓名，如图3所示。

设计思路：

（1）首先创建一个控件，上面是一个随机点名器的标签和一个开始按钮，字体设置为宋体，并且在标签的中间，取消按钮文字周围的边框；

（2）初始化图形用户界面，设置背景的颜色，设置图形用户界面的标题等等，设置pane面板布局为空，自己调整组件位置；

（3）添加控件，添加按钮的点击事件，获取学生姓名，然后是一个计时器，每个50毫秒就是一个同学的名字，在运行的过程中，会自动生成0-30之间的随机数；

（4）定义一个数组用来保存学生姓名，读取文件，里面包含了读文件时会遇到的异常，用try  catch语句将其捕获，

实现1，代码如下:

import java.awt.BorderLayout;
import java.awt.EventQueue;
import javax.swing.JFrame;
import javax.swing.JPanel;
import javax.swing.border.EmptyBorder;
import javax.swing.JButton;
import javax.swing.JTextField;
import javax.swing.JLabel;
import java.awt.Color;
import java.awt.Font;
import javax.swing.SwingConstants;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.KeyAdapter;
import java.awt.event.KeyEvent;
import java.awt.event.KeyListener;
import java.io.BufferedReader;
import java.io.File;
import java.io.FileReader;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Random;
public class Dianming extends JFrame {
private JPanel contentPane;
private static JTextField textField;
private JLabel label;
private ArrayList names = new ArrayList();
private String File = "D:/2019studentlist.txt";//设置地址，必须为txt文本
private File f;
private JButton btnNewButton;
private FileReader fr;
private BufferedReader br;
private String strName;

/**
* Launch the application.
*/
public static void main(String[] args) {

EventQueue.invokeLater(new Runnable() {  
    public void run() {  
        try {  
            Dianming frame = new Dianming();  
            frame.setTitle("手动点名器");  
            frame.setDefaultCloseOperation(JFrame.EXIT\_ON\_CLOSE);  
            frame.setVisible(true);  
        } catch (Exception e) {  
            e.printStackTrace();  
        }  
    }  
});

}
/**
* Create the frame.
*/
public Dianming() {
setBounds(100, 100, 427, 328);
contentPane = new JPanel();
contentPane.setBackground(Color.pink);
contentPane.setBorder(new EmptyBorder(5, 5, 5, 5));
setContentPane(contentPane);
contentPane.setLayout(null);

btnNewButton = new JButton("开始");  
btnNewButton.addActionListener(new ActionListener() {

@Override
public void actionPerformed(ActionEvent e) {
write();
textField.setText(strName);
}
});
btnNewButton.setForeground(Color.green);
btnNewButton.setBackground(Color.magenta);
btnNewButton.setBounds(142, 188, 113, 52);
contentPane.add(btnNewButton);
textField = new JTextField();
textField.setHorizontalAlignment(SwingConstants.CENTER);
textField.setForeground(Color.green);
textField.setBounds(131, 13, 135, 101);
contentPane.add(textField);
textField.setColumns(10);
label = new JLabel("中奖了！！！");
label.setBackground(Color.pink);
label.setBounds(159, 127, 88, 36);
contentPane.add(label);
}

public void read() {
try {
f = new File(File);
if (!f.exists()) {
f.createNewFile();
}
fr = new FileReader(f);
br = new BufferedReader(fr);
String str = br.readLine();
while (str != null) {
names.add(str);
str = br.readLine();
}
} catch (IOException e) {
e.printStackTrace();
}

}

public void write() {
read();
int index = (int) (Math.random() * names.size());
strName = names.get(index);
}
public void text(){
}
}

aaarticlea/png;base64,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" alt="" />

aaarticlea/png;base64,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" alt="" />

实现2，代码如下：

package 第十一章;

public class Main {
public static void main(String[] args) {
GUI gui = new GUI();
}
}

package 第十一章;

import java.awt.Container;
import java.awt.Dimension;
import java.awt.Panel;
import java.awt.Toolkit;

public class Center {
public static void setCenter(Container pane) {
Dimension size = Toolkit.getDefaultToolkit().getScreenSize();
int width = size.width;
int height = size.height;
int Pwidth = pane.getWidth();
int Pheight = pane.getHeight();
int Cwidth=(width-Pwidth)/2;
int Cheight=(height-Pheight)/2;
pane.setLocation(Cwidth, Cheight);

}

}

package 第十一章;

import java.awt.Color;
import java.awt.Container;
import java.awt.Dimension;
import java.awt.FlowLayout;
import java.awt.Font;
import java.awt.GridBagLayout;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.util.ArrayList;
import java.util.Timer;
import java.util.TimerTask;

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

@SuppressWarnings("serial")
public class GUI extends JFrame {
//创建控件
private JLabel jLabel;
private JButton jButton;
private ArrayList namelist;
public GUI() {
jLabel = new JLabel("随机点名器",SwingConstants.CENTER);
jButton = new JButton("开始");
Font font = new Font("宋体", SwingConstants.CENTER, 16);
jLabel.setFont(font);
jButton.setFont(font);
//取消按钮文字周围的边框
jButton.setFocusPainted(false);
jLabel.setOpaque(true);
jLabel.setBackground(Color.GRAY);
jButton.setBackground(Color.red);
// 初始化图形界面
Container pane = this.getContentPane();
this.setSize(600,400 );
Center.setCenter(this);;
this.setTitle("点名器");
//设置pane面板布局为空，自己调整组件位置
pane.setLayout(null);
//添加控件
this.getContentPane().setBackground(Color.green);
this.add(jLabel);
jLabel.setBounds(260, 100, 80, 36);
this.add(jButton);
jButton.setBounds(260, 180, 80, 36);
this.setVisible(true);
this.setDefaultCloseOperation(EXIT_ON_CLOSE);
//添加按钮的点击事件
jButton.addActionListener(new myActionListener());
//获取学生姓名
ReadFile rf = new ReadFile();
namelist = rf.getList();

}  
public class myActionListener implements ActionListener{

    @Override  
    public void actionPerformed(ActionEvent e) {  
        // TODO 自动生成的方法存根  
        //生成0-30之间的随机数  
        if (!jButton.getText().equals("停止")) {  
            jButton.setText("停止");  
            jButton.setBackground(Color.yellow);  
        }  
        else {  
            jButton.setText("开始");  
            jButton.setBackground(Color.red);  
        }  
        Timer timer = new Timer();  
        TimerTask task = new TimerTask() {

            @Override  
            public void run() {  
                // TODO 自动生成的方法存根  
                int temp=(int)(Math.random()\*30);  
                System.out.println(temp);  
                jLabel.setText(namelist.get(temp));  
                jLabel.setBackground(Color.red);  
                if (jButton.getText().equals("开始")) {  
                    timer.cancel();  
                    jLabel.setBackground(Color.gray);  
                }  
            }  
        };  
        //做定时任务，每隔50毫秒刷新一次名字  
        timer.schedule(task, 10, 50);  
    }

}

}

package 第十一章;

import java.io.BufferedReader;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import java.util.ArrayList;

public class ReadFile {
private ArrayList list;

//定义一个数组用来保存学生姓名  
@SuppressWarnings("resource")  
public ReadFile() {  
    list = new ArrayList<>();  
    try {  
        BufferedReader br = new BufferedReader(new FileReader("2019studentlist.txt"));  
        String temp;  
        while ((temp=br.readLine()) != null) {  
            list.add(temp);  
        }  
    } catch (FileNotFoundException e) {  
        // TODO 自动生成的 catch 块  
        System.out.println("文件studentlist.txt不存在");  
    } catch (IOException e) {  
        // TODO 自动生成的 catch 块  
        System.out.println("文件studentlist.txt读取异常");  
    }  
}  
public ArrayList<String> getList() {  
    return list;  
}

}

结对编程图：

三、实验总结：

这周学习了如何对事件进行处理，比如通过点击按钮或者鼠标对界面进行操控，对于图形用户界面的程序来说，事件处理显得十分重要。通过实验课上学长演示实验，再用lambda表达式以及匿名类等简化程序，使得自己对实验有了更多的了解。通过和合作伙伴结对编程，合作完成点名器的实验，对事件处理机制有了更深的体会。但是这个实验还是借助了外力才得以完成，有一些地方还是不懂，希望之后学长或老师能够再讲解一下。

手机扫一扫

移动阅读更方便

阿里云服务器
腾讯云服务器
七牛云服务器

你可能感兴趣的文章

SpringCloud-分布式配置中心【加密-对称加密】
Java IO编程全解（三）——伪异步IO编程
Java-马士兵设计模式学习笔记-代理模式-动态代理 调用Proxy.newProxyInstance()

4

04-01 Java switch、for、while、do while语句，循环嵌套，跳转语句break、continue、return

5

第五章 springboot + mybatis(转载)

6

eclipse集成testng插件

7

SpringBoot对接OpenAI

8

深入探讨I/O模型：Java中的阻塞和非阻塞和其他高级IO应用

9

UnrecognizedPropertyException: Unrecognized field 解决

10

hadoop集群搭建及编程实践