201871010132--张潇潇--《面向对象程序设计（java）》第十三周学习总结

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

项目	内容
这个作业属于哪个课程	https://www.cnblogs.com/nwnu-daizh/
这个作业的要求在哪里	https://www.cnblogs.com/nwnu-daizh/p/11435127.html
作业学习目标	理解泛型概念； 掌握泛型类的定义与使用； 掌握泛型方法的声明与使用； 掌握泛型接口的定义与实现； 了解泛型程序设计，理解其用途.

本章内容：

11.1 事件处理基础

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。

11.2 动作

1. 通常，激活一个命令可以有多种方式。用户可以通过菜单、击键或工具栏上的按钮选择特定的功能。在AWT事件模型中实现这些非常容易：将所有事件连接到同一个监听器上。
2. Swing包提供了一种非常实用的机制来封装命令，并将它们连接到多个事件源，这就是Action接口。一个动作是一个封装下列内容的对象：
   • 命令的说明（一个文本字符串和一个可选图标）；
   • 执行命令所需要的参数。
3. Action接口扩展于ActionListener接口，因此，可以在任何需要ActionListener对象的地方使用Action对象。
4. 预定义动作表名称

   名称	值
   NAME	动作名称，显示在按钮和菜单上
   SMALL_ICON	存储小图标的地方；显示在按钮、菜单项或工具栏中
   SHORT_DESCRIPTION	图标的简要说明；显示在工具提示中
   LONG_DESCRIPTION	图标的详细说明；使用在在线帮助中。没有Swing组件使用这个值
   MNEMONIC_KEY	快捷键缩写；显示在菜单项中
   ACCELERATOR_KEY	存储加速击键的地方；Swing组件不使用这个值
   ACTION_COMMAND_KEY	历史遗留；仅在旧版本的registerKeyboardAction方法中使用
   DEFAULT	常用的综合属性；Swing组件不使用这个值

5. 如果动作对象添加到菜单或工具栏上，它的名称和图标就会被自动地提取出来，并显示在菜单栏或工具栏项中。SHORT_DESCRIPTION值变成了工具提示。
6. Action是一个接口，而不是一个类。有一个类实现了这个接口除actionPerformed方法之外的所有方法，它就是AbstractAction。这个类存储了所有名、值对。并管理着属性变更监听器。可以直接扩展AbstractAction类，并在扩展类中实现了actionPerformed方法。
7. 每个JComponent有三个输入映射（input maps），每一个映射的KeyStore对象都与动作关联。三个输入映射对应着三个不同的条件。
   输入映射表

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

8. 按键处理将按照下列顺序检查这些映射：
   1）检查具有输入焦点组件的WHEN_FOCUSED映射。如果这个按键存在，将执行对应的动作。如果动作已启动，则停止处理。
   2）从具有输入焦点的组件开始，检查其父组件的WHEN_ANCESTOR_OF_FOCUSED_COMPONENT映射。一旦找到按键对应的映射，就执行对应的动作。如果动作已启用，将停止处理。
   3）查看具有输入焦点的窗口中的所有可视的和启用的组件，这个按键被注册到WHEN_IN_FOCUSED_WINDOW映射中。给这些组件（按照按键注册的顺序）一个执行对应动作的机会。一旦第一个启用的动作被执行，就停止处理。如果一个按键咋多个WHEN_IN+FOCUSED_WINDOW映射中出现，这部分处理就可能会出现问题。
9. 可以使用getInputMap方法从组件中得到输入映射。
10. InputMap不能直接将KeyStore对象映射到Actoin对象中。而是先映射到任意对象上，然后由ActionMap类实现将对象映射到动作上的第2个映射。这样很容易实现来自不同输入映射的按键共享一个动作的目的。
11. 每个组件都可以有三个输入映射和一个动作映射。为了将他们组合起来，需要为动作命名。
12. 用同一个动作响应按钮、菜单项或按键的方式：
    1）实现一个扩展于AbstractAction类的类。多个相关的动作可以使用同一个类。
    2）构造一个动作类的对象。
    3）使用动作对象创建按钮或菜单项。构造器将从动作对象中读取标签文本和图标。
    4）为了能够通过按键触发动作，必须额外地执行几步操作。首先定位顶层窗口组件，例如，包含所有其他组件的面板。
    5）然后，得到顶层组件的WHEN_ANCESTOR_OF_FOCUS_COMPONENT输入映射。为需要的按键创建一个KeyStore对象。创建一个描述动作字符串这样的动作键对象。将（按键，动作键）对添加到输入映射中。
    6）最后，得到顶层组件的动作映射。将（动作键，动作对象）添加到映射中。
13. javax.swing.Action 1.2
    • boolean isEnabled()
    • void setEnabled(boolean b)
      获得或设置这个动作额enabled属性。
    • void putValue(String key,Object value)
      将名/值对防止在动作对象内。
      参数：key 用动作对象存储性能的名字。它可以是一个字符串，但预定义了几个名字。 value 与名字关联的对象。
    • Object getValue(String key)
      返回被存储的名/值对的值。
14. 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。
15. javax.swing.JComponent 1.2
    • ActionMap getActionMap() 1.3
      返回关联动作映射键（可以是任意的对象）和动作对象的映射。
    • InputMap getInputMap(int flag) 1.3
      获得将案件映射到动作键的输入映射。
      参数：flag 触发动作的键盘焦点条件。

11.3 鼠标动作

1. 当用户点击鼠标按钮时，将会调用三个监听器方法：鼠标第一次按下时调用mousePressed；鼠标被释放时调用mouseReleased；最后调用mouseClicked。如果只对最终的点击事件感兴趣，就可以忽略前两个方法。用MouseEvent类对象作为参数，调用getX和getY方法可以获得鼠标被按下时鼠标指针所在x和y坐标。要想区分单击、双击和三击（！），需要使用getClickCount方法。
2. getModifiersEx方法能够准确地报告鼠标事件的鼠标按钮和键盘修饰符。
3. 在Windows环境下，使用BUTTON3_DOWN_MASK检测鼠标右键（非主要的）的状态。
4. java.awt.event.MouseEvent 1.1
   • int getX()
   • int getY()
   • Point getPoint()
     返回事件发生时，事件源组件左上角的坐标x（水平）和y（垂直），或点信息。
   • int getClickCount()
     返回与事件关联的鼠标连击次数（“连击”所指定的时间间隔与具体系统有关）。
5. 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”。
6. java.awt.Toolkit 1.0
   • public Cursor createCustomCursor(Image image,Point hotSpot,String name) 1.2
     创建一个新的定制光标对象。
     参数：image 光标活动时显示的图像。hotSpot 光标热点（箭头的顶点或十字中心）。name 光标的描述，用来支持特殊的访问环境。
7. java.awt.Component 1.0
   • public void setCursor(Cursor cursor) 1.1
     用光标图像设置给定光标。

11.4 AWT事件继承层次

1. Java事件处理采用的是面向对象方法，所有的事件都是由java.util包中的EventObject类扩展而来的。EventObject类有一个子类AWTEvent，它是所有AWT事件类的父类。有些Swing组件将生成其他事件类型的事件对象；它们都直接扩展于EventObject，而不是AWTEvent。事件对象封装了事件源与监听器彼此通信的事件信息。在必要的时候，可以对传递给监听器对象的事件对象进行分析。
2. AWT将事件分为低级（low-level）事件和语义（semantic）事件。语义事件是表示用户动作的事件，因此，ActionEvent是一种语义事件。低级事件是形成那些事件的事件。
3. java.awt.event包中最常用的语义事件类：
   • ActionEvent（对应按钮点击、菜单选择、选择列表项或文本框中ENTER）；
   • AdjustmentEvent（用户调节滚动条）；
   • ItemEvent（用户从复选框或列表框中选择一项）。
4. 常用的5个低级事件类是：
   • KeyEvent(一个键被按下或释放)；
   • MouseEvent(鼠标键被按下、释放、移动或拖动)；
   • MouseWheelEvent（鼠标滚轮被转动）；
   • FocusEvent（某个组件获得焦点或失去焦点）。
   • WindowEvent（窗口状态被改变）。
     下列接口将监听这些事件：ActionListener、AdjustmentListener、FocusListener、ItemListener、KeyListener、MouseListener、MouseMotionListener、MouseWheelListener、WindowListener、WindowFocusListener、WindowStateListener。
5. 常用的适配器类：FocusAdapter、KeyAdapter、MouseAdapter、MouseMotionAdapter、WindowAdapter。

二：实验部分。

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程序中按钮、键盘动作映射到动作对象的方法。

程序如下：

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<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);
   }
   /**
    * 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<String> names = new ArrayList<String>();
	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(){
	}
}

 

实现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<String> 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<String> 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表达式以及匿名类等简化程序，使得自己对实验有了更多的了解。通过和合作伙伴结对编程，合作完成点名器的实验，对事件处理机制有了更深的体会。但是这个实验还是借助了外力才得以完成，有一些地方还是不懂，希望之后学长或老师能够再讲解一下。