201871010110-李华《面向对象程序设计（java）》第十五周学习总结

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

项目	内容
这个作业属于哪个课程	https://www.cnblogs.com/nwnu-daizh/
这个作业的要求在哪里	https://www.cnblogs.com/nwnu-daizh/p/11995615.html
作业学习目标	(1) 掌握菜单组件用途及常用API； (2) 掌握对话框组件用途及常用API； (3) 学习设计简单应用程序的GUI。

随笔博文正文内容包括：

第一部分：总结菜单、对话框两类组件用途及常用API（30分）

 一.菜单

1.菜单创建

在通常情况下，菜单项触发的命令也可以通过其他用户界面元素（如工具栏上的按钮）激活。

javax.swing.JMenu

。JMenu(String labe)
用给定标签构造一个菜单。

。JMenuItem add(JMenuItem item)
添加一个菜单项（或一个菜单）。

。JMenuItem add(String label)
用给定标签将一个菜单项添加到菜单中，并返回这个菜单项。

。JMenuItem add(Action a)
用给定动作将一个菜单项添加到菜单中，并返回这个菜单项。

。void addSeparator()
将一个分隔符行（separator line）添加到菜单中。

。JMenuItem insert(JMenuItem menu,int index)
将一个新菜单项（或子菜单）添加到菜单的指定位置。

。JMenuItem insert(JMenuItem menu,int index)
将一个新菜单项（或子菜单）添加到菜单的指定位置。

。JMenuItem insert(Action a,int index)
用给定动作在菜单的指定位置添加一个新菜单项。

。void insertSeparator(int index)
将一个分隔符添加到菜单中。
参数：index 添加分隔符的位置。

。void remove(int index)

。void remove(JMenuItem item)
从菜单中删除指定的菜单项。

。javax.swing.JMenuItem

。JMenuItem(String label)
用给定标签构造一个菜单项。

。JMenuItem(Acton a) 
为给定动作构造一个菜单项。

。javax.swing.AbstractButton

。void setAction(Action a) 
为这个按钮或菜单项设置动作。

。javax.swing.JFrame

。void setJMenuBar(JMenuBar menubar)
为这个框架设置菜单栏。

2.菜单项中的图标

。JMenuItem类扩展了AbstractButton类。与按钮一样，菜单可以包含文本标签、图标，也可以两者都包含。既可以利用JMenuItem(String,Icon)或者JMenuItem(Icon)构造器为菜单指定一个图标，也可以利用JmenuItem类中的setIcon方法（继承自AbstractButton类）指定一个图标。

。javax.swing.JMenuItem

JMenuItem(String label,Icon icon)
用给定的标签和图标构造一个菜单项。

。javax.swing.AbstractButton

void setHorizontalTextPosition(int pos)
设置文本对应图标的水平位置。
参数：pos SwingConstants.RIGHT（文本在图标的右侧）或SwingConstants.LEFT。

3.复选框和单选按钮菜单项

。复选框和单选按钮菜单项在文本旁边显示了一个复选框或一个单选按钮。当用户选择一个菜单框时，菜单项就会自动地在选择和未选择间进行切换。

。javax.swing.JCheckBoxMenuItem

。JCheckBoxMenuItem(String label)
用给定的标签构造一个复选框菜单项。

。JCheckBoxMenuItem(String label,boolean state)
用给定的标签个给定的初始状态（true为选定）构造一个复选框菜单。

。javax.swing.JRadioButtonMenuItem

JRadioButtonMenuItem(String label)
用给定的标签构造一个单选按钮菜单项。

。JRadioButtonMenuItem(String label,boolean state)
用给定的标签和给定的初始状态（true为选定）构造一个单选按钮菜单项。

。javax.swing.AbstractButton

。boolean isSelected()

。void setSelected(boolean state)
获取或设置这个菜单项的选择状态（true为选定）。

4.弹出菜单

（1）创建一个弹出菜单与创建一个常规菜单的方法类似，但是弹出菜单没有标题；

　　JPopMenu   popup  =  new  JPopMenu（）；

　　（2）然后用常规方法为弹出菜单添加菜单项：

　　JMenuItem  item = new  JMenuItem（“Cut”）；

　　item.addActionListener（listener）；

　　popup.add（item）；

　　（3）弹出菜单调用show方法才能显示出来；

　　popup.show（panel，x，y）；

5.快捷键和加速器

（1）可以为菜单项设置快捷键。在当前菜单打开的情况下，可以按下某菜单项的快捷键，相当于鼠标单击了该菜单项；

　　JMenuItem  Cutltem = new  JMenuItem("Index")；

　　CutItem.setMnemonic("!")；

　　（2）此快捷键就会自动显示在菜单项中，快捷键下面有一条下划线。

（2）加速器：

　　（1）加速器可以在不打开菜单的情况下选中菜单项的快捷键。例如，很多应用程序把CTRL+O和CTRL+S关联到菜单中的Open和Save项。

　　（2）使用Set Accelerator方法可以将加速器关联到一个菜单项。该方法使用KeyStroke类型的对象作为参数；

　　（3）当用户按下加速器组合键时，就会自动选择了相应的菜单项，同时集火一个动作事件；

　　（4）加速器只能关联在菜单项，而不能关联菜单；

　　（5）加速器实际上并不打开菜单，而是直接激活菜单关联的动作事件。

6.启用和禁用菜单项

（1）在程序运行过程中，经常需要屏蔽某些暂时不适用的命令，待到条件允许时再使之重新利用。

　　（2）屏蔽/启用菜单项的方法：

　　aMenuItem.setEnable（boolean）；

　　当参数值为false时，屏蔽该菜单项；

　　当参数值为true时，启用该菜单项。

　　（3）如果需要动态启用/屏蔽某菜单项，则需要为菜单项注册“menuSelected”事件监听器；

　　Javax.swing.event 包定义了MenuListener接口，它有三个方法：

　　——void   menuSelected（Menu Event   event）

　　——void  menuDeselected（MenuEvent  event）

　　——void  menuCanceled（MenuEvent  event）

7.工具栏

（1）工具栏在程序中提供快速访问常用命令的按钮栏；

（2）工具栏的优点在于可以移动，脱离菜单栏或拖拽到框架其他地方；

（3）关闭包含工具栏的框架后，工具栏回到原始的框架中。

（4）工具提示：

　　提示工具栏中某个按钮的含义。当光标停留在某个按钮上时，工具提示就会激活，工具提示文本显示在一个矩形里。当用户移开鼠标时，工具提示就会自动消失；

　　调用setToolTest方法添加工具提示到JComponent；

　　另一种方法就是，如果使用Action对象，就可以用SHORT-DESCRIPTION关联工具提示

网格组布局 (GridBagLayout):GridBagLayout与GridLayout有点相似，它也是 将组件排在格子里，但是GridBagLayout在网格 的基础上提供更复杂的布局。

GridBagLayout允许单个组件在一个单元中不填 满整个单元，而只是占用最佳大小，也允许单个 组件扩展成不止一个单元，并且可以用任意顺序 加入组件。

。 定制布局管理器:程序员可通过自己设计LayoutManager类来实现 特殊的布局方式。定制布局管理器需要实现LayoutManager接口， 并覆盖以下方法。

二.对话框：

对话框是一种大小不能变化、不能有菜单的容器窗口；对话框不能作为一个应用程序的主框架，而必须包含在其他的容器中。

Java提供多种对话框类来支持多种形式的对话框。

　　——JOptionPane类：支持简单、标准的对话框；

　　——JFileChooser类：支持文件打开、保存对话框；

　　——ProgressMonitor类：支持操作进度条控制对话框等。

对话框依赖于框架。当框架撤销时，依赖该框架的对话框 也撤销。当框架图标化时，依赖它的对话框也从屏幕上消 失。当框架窗口恢复时，依赖框架的对话框又返回屏幕。

对话框分为有模式和无模式两种：

1）有模式的对话框处于激活状态时，程序只能响应对话框内部的事件，不能再激活它所依赖的窗口或组件，而且它将堵塞当前线程的执行，即堵塞使得对话框处于激活状态的线程，直到该对话框消失不可见；

2）无模式对话框处于激活状态时，程序仍能激活它所依赖的窗口或者组件，它不能堵塞线程的执行。

通过添加对文件选择器显示的每个文件的特殊图标和文件说明来定制自己的文件选择器。这需要扩展javax.swing.filechooser包中的FileView类。这是一项高级的技巧。在通常情况下，不需要提供文件视图——可插观感会提供。但是如果想为特殊的文件类型显示不同的图标，就需要安装自己的文件视图。这要扩展FileView并实现下面5个方法：

Icon getIcon(File f);

String getName(File f);

String getDescription(File f);

String getTypeDescription(File f);

Boolean isTraversable(File f）；

然后，使用setFileView方法将文件视图安装到文件选择器中。

使用setFileView方法可以将文件视图安装到文件选择器中

选项对话框:

JOptionPane提供的对话框是模式对话框。当模 式对话框显示时，它不允许用户输入到程序的 其他的窗口。使用JOptionPane，可以创建和自 定义问题、信息、警告和错误等几种类型的对 话框。

数据交换:

输入对话框含有供用户输入文本的文本框、一个确认和取 消按钮,是有模式对话框。当输入对话框可见时,要求用户 输入一个字符串。

文件对话框:

专门用于对文件（或目录）进行浏览和选择的对 话框，常用的构造方法: – JFileChooser()：根据用户的缺省目录创建文件对话框 – JFileChooser(File currentDirectory)：根据File型参数 currentDirectory指定的目录创建文件对话框

文本对话框：

1，Swing提供了JFileChoose类，特可以显示一个文件对话框。

2，JFileChoose类并不是JDialog类的子类。需要调用showOpenDialog，而不是调用setVisibel(true)来显示打开文件的对话框，或者调用showSaveDialog显示保存文件的对话框。接收文件的按钮被标签为Open或者Save，也可以调用showDialog方法制定自己的标签。

3，调用showOpenDialog或者showSaveDialog方法显示对话框。必须为这些调用提供父组件：

Int result = chooser.showOepnDialog(parent);

或者

Int result = chooser.showSaveDialog(parent);

这些调用的区别就是“确认按钮”的标签不同，点击“确认按钮”完成文件选择。也可以调用showDialog方法并将一个显示的文本传递个确认按钮。

Int result = chooser.showDialog(parent,”select”);

仅当用户确认、取消或者离开文件对话框时才返回调用。返回值可以是JFileChoose.APPROVE_OPEION,JFileChooser.CANCLE_OPTION或者JFileChooser.ERROR_OPTION。

4，若想限制显示的文件，需要创建扩展了抽象类javax.swing.filechooser.FileFilter的对象。文件选择器把每个文件传递个过滤器，只有文件过滤器接受的文件才被最终显示出来。编写专用文件过滤器非常简单，只要事先FileFilter子类中的两个抽象方法即可：

Public boolean accept(File f);

Public String getDescription();

颜色对话框:

javax.swing包中的JColorChooser类的静态方 法: public static Color showDialog(Component component, String title, Color initialColor)创建一个颜色对话框

参数component指定对话框所依赖的组件，title 指定对话框的标题；initialColor 指定对话框返回 的初始颜色，即对话框消失后，返回的默认值。 颜色对话框可根据用户在颜色对话框中选择的颜 色返回一个颜色对象.

第二部分：实验部分

实验1：测试程序1（7分）

12-8代码如下：

package menu;

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

/**
 * @version 1.25 2018-04-10
 * @author Cay Horstmann
 */
public class MenuTest
{
   public static void main(String[] args)
   {
      EventQueue.invokeLater(() -> {
         var frame = new MenuFrame();
         frame.setTitle("MenuTest");
         frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
         frame.setVisible(true);
      });
   }
}

package menu;

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

/**
 * A frame with a sample menu bar.
 * 带有示例菜单栏的框架。
 */
public class MenuFrame extends JFrame
{
   private static final int DEFAULT_WIDTH = 300;
   private static final int DEFAULT_HEIGHT = 200;
   private Action saveAction;
   private Action saveAsAction;
   private JCheckBoxMenuItem readonlyItem;
   private JPopupMenu popup;

   /**
    * A sample action that prints the action name to System.out.
    * 将操作名称打印到System.out的示例操作。
    */
   class TestAction extends AbstractAction
   {
      public TestAction(String name)
      {
         super(name);
      }

      public void actionPerformed(ActionEvent event)
      {
         System.out.println(getValue(Action.NAME) + " selected."); //在控制台上输出选择菜单按钮。
      }
   }

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

      var fileMenu = new JMenu("File");
      fileMenu.add(new TestAction("New"));

      // 演示加速器

      var openItem = fileMenu.add(new TestAction("Open"));
      openItem.setAccelerator(KeyStroke.getKeyStroke("ctrl O"));

      fileMenu.addSeparator();

      saveAction = new TestAction("Save");
      JMenuItem saveItem = fileMenu.add(saveAction);
      saveItem.setAccelerator(KeyStroke.getKeyStroke("ctrl S"));

      saveAsAction = new TestAction("Save As");
      fileMenu.add(saveAsAction);
      fileMenu.addSeparator();

      fileMenu.add(new AbstractAction("Exit")
         {
            public void actionPerformed(ActionEvent event)
            {
               System.exit(0);
            }
         });

      // 演示复选框和单选按钮菜单

      readonlyItem = new JCheckBoxMenuItem("Read-only");
      readonlyItem.addActionListener(new ActionListener()
         {
            public void actionPerformed(ActionEvent event)
            {
               boolean saveOk = !readonlyItem.isSelected();
               saveAction.setEnabled(saveOk);
             //设置 Action 的启用状态。
               saveAsAction.setEnabled(saveOk);
            }
         });

      var group = new ButtonGroup();

      var insertItem = new JRadioButtonMenuItem("Insert");
      insertItem.setSelected(true);
      var overtypeItem = new JRadioButtonMenuItem("Overtype");

      group.add(insertItem);
      group.add(overtypeItem);

      // 演示图标

      var cutAction = new TestAction("Cut");
      cutAction.putValue(Action.SMALL_ICON, new ImageIcon("cut.gif"));
      var copyAction = new TestAction("Copy");
      copyAction.putValue(Action.SMALL_ICON, new ImageIcon("copy.gif"));
      var pasteAction = new TestAction("Paste");
      pasteAction.putValue(Action.SMALL_ICON, new ImageIcon("paste.gif"));

      var editMenu = new JMenu("Edit");
      editMenu.add(cutAction);
      editMenu.add(copyAction);
      editMenu.add(pasteAction);

      // 演示嵌套菜单

      var optionMenu = new JMenu("Options");

      optionMenu.add(readonlyItem);
      optionMenu.addSeparator();//分隔符
      optionMenu.add(insertItem);
      optionMenu.add(overtypeItem);
     //将readonlyItem、insertItem、overtypeItem添加到选择菜单当中
      editMenu.addSeparator();
      editMenu.add(optionMenu);

      // 显示助记符

      var helpMenu = new JMenu("Help");
      helpMenu.setMnemonic('H');

      var indexItem = new JMenuItem("Index");
      indexItem.setMnemonic('I');
      helpMenu.add(indexItem);

      // 你也可以向一个动作添加助记键
      var aboutAction = new TestAction("About");
      aboutAction.putValue(Action.MNEMONIC_KEY, new Integer('A'));
      helpMenu.add(aboutAction);

      //将所有顶级菜单添加到菜单栏

      var menuBar = new JMenuBar();
      setJMenuBar(menuBar);

      menuBar.add(fileMenu);
      menuBar.add(editMenu);
      menuBar.add(helpMenu);//在menuBar中添加fileMenu、editMenu、helpMenu

      //显示弹出窗口

      popup = new JPopupMenu();
      popup.add(cutAction);
      popup.add(copyAction);
      popup.add(pasteAction);  //在弹出菜单中添加剪切、复制、粘贴动作

      var panel = new JPanel();
      panel.setComponentPopupMenu(popup);
      add(panel);
   }
}

　

运行结果：

       

实验1：测试程序2（7分）

12-9代码如下：

package toolBar;

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

/**
 * @version 1.15 2018-04-10
 * @author Cay Horstmann
 */
public class ToolBarTest
{
   public static void main(String[] args)
   {
      EventQueue.invokeLater(() -> {
         var frame = new ToolBarFrame();
         frame.setTitle("ToolBarTest");
         frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
         frame.setVisible(true);
      });
   }
}

　　

package toolBar;

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

/**
 * A frame with a toolbar and menu for color changes.
 * 带有工具栏和菜单的框架，用于颜色变化。
 */
public class ToolBarFrame extends JFrame
{
   private static final int DEFAULT_WIDTH = 300;
   private static final int DEFAULT_HEIGHT = 200;
   private JPanel panel;

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

      //  添加颜色变化面板

      panel = new JPanel();
      add(panel, BorderLayout.CENTER);

      // 设置动作

      var blueAction = new ColorAction("Blue", new ImageIcon("blue-ball.gif"), Color.BLUE);
      var yellowAction = new ColorAction("Yellow", new ImageIcon("yellow-ball.gif"),
            Color.YELLOW);
      var redAction = new ColorAction("Red", new ImageIcon("red-ball.gif"), Color.RED);

      var exitAction = new AbstractAction("Exit", new ImageIcon("exit.gif"))
         {
            public void actionPerformed(ActionEvent event)
            {
               System.exit(0);
            }
         };
      exitAction.putValue(Action.SHORT_DESCRIPTION, "Exit");

      //  填充工具栏
      //将blueAction、yellowAction、redAction、exitAction动作添加到工具栏当中
      var bar = new JToolBar();
      bar.add(blueAction);
      bar.add(yellowAction);
      bar.add(redAction);
      bar.addSeparator();
      bar.add(exitAction);
      add(bar, BorderLayout.NORTH);

      // 填充菜单

      var menu = new JMenu("Color");
      menu.add(yellowAction);
      menu.add(blueAction);
      menu.add(redAction);
      menu.add(exitAction);
      var menuBar = new JMenuBar();
      menuBar.add(menu);
      setJMenuBar(menuBar);
   }

   /**
    * The color action sets the background of the frame to a given color.
    * 颜色动作将帧的背景设置为给定的颜色。
    */
   class ColorAction extends AbstractAction
   {
      public ColorAction(String name, Icon icon, Color c)
      {
    	//调用putValue方法来存值
    	 putValue(Action.NAME, name);
         putValue(Action.SMALL_ICON, icon);
         putValue(Action.SHORT_DESCRIPTION, name + " background");
         putValue("Color", c);
      }

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

运行结果：

     

实验1：测试程序3（7分）

12-15代码如下：

package optionDialog;

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

/**
 * @version 1.35 2018-04-10
 * @author Cay Horstmann
 */
public class OptionDialogTest
{
   public static void main(String[] args)
   {
      EventQueue.invokeLater(() -> {
         var frame = new OptionDialogFrame();
         frame.setTitle("OptionDialogTest");
         frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
         frame.setVisible(true);
      });
   }
}

　　

package optionDialog;

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

/**
 * A frame that contains settings for selecting various option dialogs.
 * 包含用于选择各种选项对话框的设置的框架。
 */
public class OptionDialogFrame extends JFrame
{
   private ButtonPanel typePanel;
   private ButtonPanel messagePanel;
   private ButtonPanel messageTypePanel;
   private ButtonPanel optionTypePanel;
   private ButtonPanel optionsPanel;
   private ButtonPanel inputPanel;
   private String messageString = "Message";
   private Icon messageIcon = new ImageIcon("blue-ball.gif");
   private Object messageObject = new Date();
   private Component messageComponent = new SampleComponent();

   public OptionDialogFrame()
   {
      var gridPanel = new JPanel();
      gridPanel.setLayout(new GridLayout(2, 3));

      typePanel = new ButtonPanel("Type", "Message", "Confirm", "Option", "Input");
      messageTypePanel = new ButtonPanel("Message Type", "ERROR_MESSAGE", "INFORMATION_MESSAGE",
            "WARNING_MESSAGE", "QUESTION_MESSAGE", "PLAIN_MESSAGE");
      messagePanel = new ButtonPanel("Message", "String", "Icon", "Component", "Other",
            "Object[]");
      optionTypePanel = new ButtonPanel("Confirm", "DEFAULT_OPTION", "YES_NO_OPTION",
            "YES_NO_CANCEL_OPTION", "OK_CANCEL_OPTION");
      optionsPanel = new ButtonPanel("Option", "String[]", "Icon[]", "Object[]");
      inputPanel = new ButtonPanel("Input", "Text field", "Combo box");

      gridPanel.add(typePanel);
      gridPanel.add(messageTypePanel);
      gridPanel.add(messagePanel);
      gridPanel.add(optionTypePanel);
      gridPanel.add(optionsPanel);
      gridPanel.add(inputPanel);

      // 添加带有显示按钮的面板

      var showPanel = new JPanel();
      var showButton = new JButton("Show");
      showButton.addActionListener(new ShowAction());
      showPanel.add(showButton);

      add(gridPanel, BorderLayout.CENTER);
      add(showPanel, BorderLayout.SOUTH);
      //将网格面板添加到边框布局管理的CENTER和SOUTH位置
      pack();
   }

   /**
    * 获取当前选定的消息。
    * @返回一个字符串、图标、组件或对象数组，这取决于消息面板的选择
  */
   public Object getMessage()
   {
      String s = messagePanel.getSelection();
      if (s.equals("String")) return messageString;
      else if (s.equals("Icon")) return messageIcon;
      else if (s.equals("Component")) return messageComponent;
      else if (s.equals("Object[]")) return new Object[] { messageString, messageIcon,
            messageComponent, messageObject };
      else if (s.equals("Other")) return messageObject;
      else return null;
   }

   /**
    * 获取当前选定的选项。
    * @返回字符串、图标或对象的数组，具体取决于选项面板的选择
    */
   public Object[] getOptions()
   {
      String s = optionsPanel.getSelection();
      if (s.equals("String[]")) return new String[] { "Yellow", "Blue", "Red" };
      else if (s.equals("Icon[]")) return new Icon[] { new ImageIcon("yellow-ball.gif"),
            new ImageIcon("blue-ball.gif"), new ImageIcon("red-ball.gif") };
      else if (s.equals("Object[]")) return new Object[] { messageString, messageIcon,
            messageComponent, messageObject };
      else return null;
   }

   /**
    *获取所选消息或选项类型
    * @param面板消息类型或确认面板。
    * @从JOptionPane类中返回选择的XXX_MESSAGE或XXX_OPTION常量
    */
   public int getType(ButtonPanel panel)
   {
      String s = panel.getSelection();
      try
      {
         return JOptionPane.class.getField(s).getInt(null);
      }
      catch (Exception e)
      {
         return -1;
      }
   }

   /**
    * Show按钮的动作监听器显示确认、输入、消息或选项对话框
    *取决于类型面板的选择。
    */
   private class ShowAction implements ActionListener
   {
      public void actionPerformed(ActionEvent event)
      {
         if (typePanel.getSelection().equals("Confirm")) JOptionPane.showConfirmDialog(
               OptionDialogFrame.this, getMessage(), "Title", getType(optionTypePanel),
               getType(messageTypePanel));
         //如果typePanel中选择Confirm按钮，得到messageTypePanel内容
         else if (typePanel.getSelection().equals("Input"))
         {
            if (inputPanel.getSelection().equals("Text field")) JOptionPane.showInputDialog(
                  OptionDialogFrame.this, getMessage(), "Title", getType(messageTypePanel));
          //如果Input面板当中选择的是Text field，得到messageTypePanel内容
            else JOptionPane.showInputDialog(OptionDialogFrame.this, getMessage(), "Title",
                  getType(messageTypePanel), null, new String[] { "Yellow", "Blue", "Red" },
                  "Blue");
         }
         else if (typePanel.getSelection().equals("Message")) JOptionPane.showMessageDialog(
               OptionDialogFrame.this, getMessage(), "Title", getType(messageTypePanel));
         else if (typePanel.getSelection().equals("Option")) JOptionPane.showOptionDialog(
               OptionDialogFrame.this, getMessage(), "Title", getType(optionTypePanel),
               getType(messageTypePanel), null, getOptions(), getOptions()[0]);
      }
   }
}

/**
 * A component with a painted surface
 */

class SampleComponent extends JComponent
{
   public void paintComponent(Graphics g)
   {
      var g2 = (Graphics2D) g;
      var rect = new Rectangle2D.Double(0, 0, getWidth() - 1, getHeight() - 1);
      g2.setPaint(Color.YELLOW);
      g2.fill(rect);
      g2.setPaint(Color.BLUE);
    //调用setPaint方法来设置颜色
      g2.draw(rect);
   }

   public Dimension getPreferredSize()
   {
      return new Dimension(10, 10);
   }
}

package optionDialog;

import javax.swing.*;

/**
 * A panel with radio buttons inside a titled border.
 * 有标题的边框内带有单选按钮的面板。
 */
public class ButtonPanel extends JPanel
{
   private ButtonGroup group;

   /**
    * 构造一个按钮面板。
    * @param title边框显示的标题
    * @param选项一个单选按钮标签数组
    */
   public ButtonPanel(String title, String... options)
   {
      setBorder(BorderFactory.createTitledBorder(BorderFactory.createEtchedBorder(), title));
      setLayout(new BoxLayout(this, BoxLayout.Y_AXIS));
      group = new ButtonGroup();

      // 为每个选项设置一个单选按钮
      for (String option : options)
      {
         var button = new JRadioButton(option);
         button.setActionCommand(option);
         add(button);
         group.add(button);
         button.setSelected(option == options[0]);
      }
   }

   /**
    *获取当前选择的选项。
    * @返回当前选中单选按钮的标签。
    */
   public String getSelection()
   {
      return group.getSelection().getActionCommand();
   }
}

运行结果：

  

  

  

实验1：测试程序4（7分）

12-17代码如下：

package dialog;

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

/**
 * @version 1.35 2018-04-10
 * @author Cay Horstmann
 */
public class DialogTest
{
   public static void main(String[] args)
   {
      EventQueue.invokeLater(() -> {
         var frame = new DialogFrame();
         frame.setTitle("DialogTest");
         frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
         frame.setVisible(true);
      });
   }
}

　

package dialog;

import javax.swing.JFrame;
import javax.swing.JMenu;
import javax.swing.JMenuBar;
import javax.swing.JMenuItem;

/**
 * A frame with a menu whose File->About action shows a dialog.
 * 带有菜单的框架，其文件>About action显示一个对话框。
 */
public class DialogFrame extends JFrame
{
   private static final int DEFAULT_WIDTH = 300;
   private static final int DEFAULT_HEIGHT = 200;
   private AboutDialog dialog;

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

      // 构造一个文件菜单

      var menuBar = new JMenuBar();
      setJMenuBar(menuBar);
      var fileMenu = new JMenu("File");
      menuBar.add(fileMenu);

      // 添加About和Exit菜单项

      // About项显示了About对话框

      var aboutItem = new JMenuItem("About");
      aboutItem.addActionListener(event -> {
         if (dialog == null) // first time
            dialog = new AboutDialog(DialogFrame.this);
         dialog.setVisible(true); // 弹出对话框
      });
      fileMenu.add(aboutItem);

      //退出项退出程序

      var exitItem = new JMenuItem("Exit");
      exitItem.addActionListener(event -> System.exit(0));
      fileMenu.add(exitItem);
   }
}

　　

package dialog;

import java.awt.BorderLayout;

import javax.swing.JButton;
import javax.swing.JDialog;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JPanel;

/**
 * 显示消息并等待用户单击的模式对话框示例
 * the OK button.
 */
public class AboutDialog extends JDialog
{
   public AboutDialog(JFrame owner)
   {
      super(owner, "About DialogTest", true);

      // 将HTML标签添加到中心

      add(
         new JLabel(
            "<html><h1><i>Core Java</i></h1><hr>By Cay Horstmann</html>"),
         BorderLayout.CENTER);

      // OK按钮关闭对话框

      var ok = new JButton("OK");
      ok.addActionListener(event -> setVisible(false));

      // 向南部边界添加OK按钮

      var panel = new JPanel();
      panel.add(ok);
      add(panel, BorderLayout.SOUTH);

      pack();
   }
}　

运行结果：

   

实验1：测试程序5（7分）

代码如下：

package dataExchange;

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

/**
 * @version 1.35 2018-04-10
 * @author Cay Horstmann
 */
public class DataExchangeTest
{
   public static void main(String[] args)
   {
      EventQueue.invokeLater(() -> {
         var frame = new DataExchangeFrame();
         frame.setTitle("DataExchangeTest");
         frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
         frame.setVisible(true);
      });
   }
}

　　

package dataExchange;

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

/**
 * A frame with a menu whose File->Connect action shows a password dialog.
 * 带有菜单的框架，其文件->连接操作显示一个密码对话框。
 */
public class DataExchangeFrame extends JFrame
{
   public static final int TEXT_ROWS = 20;
   public static final int TEXT_COLUMNS = 40;
   private PasswordChooser dialog = null;
   private JTextArea textArea;

   public DataExchangeFrame()
   {
      //构造一个文件菜单

      var mbar = new JMenuBar();
      setJMenuBar(mbar);
      var fileMenu = new JMenu("File");
      mbar.add(fileMenu);

      //添加“连接”和“退出”菜单项

      var connectItem = new JMenuItem("Connect");
      connectItem.addActionListener(new ConnectAction());
      fileMenu.add(connectItem);

      //退出项目退出程序

      var exitItem = new JMenuItem("Exit");
      exitItem.addActionListener(event -> System.exit(0));
      fileMenu.add(exitItem);

      textArea = new JTextArea(TEXT_ROWS, TEXT_COLUMNS);
      add(new JScrollPane(textArea), BorderLayout.CENTER);
      pack();
   }

   /**
    * The Connect action pops up the password dialog.
    * 连接操作弹出密码对话框。
    */
   private class ConnectAction implements ActionListener
   {
      public void actionPerformed(ActionEvent event)
      {
         // if第一次，构造对话框

         if (dialog == null) dialog = new PasswordChooser();

         // 设置默认值
         dialog.setUser(new User("yourname", null));

         // 弹出对话框

         if (dialog.showDialog(DataExchangeFrame.this, "Connect"))
         {
            // 如果接受，检索用户输入
            User u = dialog.getUser();
            textArea.append("user name = " + u.getName() + ", password = "
               + (new String(u.getPassword())) + "\n");
         }
      }
   }
}

　　

package dataExchange;

import java.awt.BorderLayout;
import java.awt.Component;
import java.awt.Frame;
import java.awt.GridLayout;

import javax.swing.JButton;
import javax.swing.JDialog;
import javax.swing.JLabel;
import javax.swing.JPanel;
import javax.swing.JPasswordField;
import javax.swing.JTextField;
import javax.swing.SwingUtilities;

/**
 * A password chooser that is shown inside a dialog.
 * 对话框中显示的密码选择器。
 */
public class PasswordChooser extends JPanel
{
   private JTextField username;
   private JPasswordField password;
   private JButton okButton;
   private boolean ok;
   private JDialog dialog;

   public PasswordChooser()
   {
      setLayout(new BorderLayout());

      // 构造一个包含用户名和密码字段的面板

      var panel = new JPanel();
      panel.setLayout(new GridLayout(2, 2));
      panel.add(new JLabel("User name:"));
      panel.add(username = new JTextField(""));
      panel.add(new JLabel("Password:"));
      panel.add(password = new JPasswordField(""));
      add(panel, BorderLayout.CENTER);

      // 创建终止对话框的Ok和Cancel按钮

      okButton = new JButton("Ok");
      okButton.addActionListener(event -> {
         ok = true;
         dialog.setVisible(false);
      });

      var cancelButton = new JButton("Cancel");
      cancelButton.addActionListener(event -> dialog.setVisible(false));

      // 添加按钮到南部边界

      var buttonPanel = new JPanel();
      buttonPanel.add(okButton);
      buttonPanel.add(cancelButton);
      add(buttonPanel, BorderLayout.SOUTH);
   }

   /**
    * 设置对话框的默认值。
    * @param是默认的用户信息
    */
   public void setUser(User u)
   {
      username.setText(u.getName());
   }

   /**
   *获取对话框条目。
   * @返回一个状态表示对话框条目的用户对象
    */
   public User getUser()
   {
      return new User(username.getText(), password.getPassword());
   }

   /**
   *在对话框中显示选择面板。
   * @param在所有者框架中父组件或null
   *对话框窗口的标题
    */
   public boolean showDialog(Component parent, String title)
   {
      ok = false;

      // locate the owner frame

      Frame owner = null;
      if (parent instanceof Frame)
         owner = (Frame) parent;
      else
         owner = (Frame) SwingUtilities.getAncestorOfClass(Frame.class, parent);

     //如果是第一次，或者如果所有者改变了，创建一个新的对话框
      if (dialog == null || dialog.getOwner() != owner)
      {
         dialog = new JDialog(owner, true);
         dialog.add(this);
         dialog.getRootPane().setDefaultButton(okButton);
         dialog.pack();
      }

      //设置标题和显示对话框

      dialog.setTitle(title);
      dialog.setVisible(true);
      return ok;
   }
}

　　

package dataExchange;

/**
 * A user has a name and password. For security reasons, the password is stored as a char[], not a
 * String.
 */
public class User
{
   private String name;
   private char[] password;

   public User(String aName, char[] aPassword)
   {
      name = aName;
      password = aPassword;
   }

   public String getName()
   {
      return name;
   }

   public char[] getPassword()
   {
      return password;
   }

   public void setName(String aName)
   {
      name = aName;
   }

   public void setPassword(char[] aPassword)
   {
      password = aPassword;
   }
}

　　

运行结果：

        

实验1：测试程序6（7分）

代码如下：

package fileChooser;

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

/**
 * @version 1.26 2018-04-10
 * @author Cay Horstmann
 */
public class FileChooserTest
{
   public static void main(String[] args)
   {
      EventQueue.invokeLater(() -> {
         var frame = new ImageViewerFrame();
         frame.setTitle("FileChooserTest");
         frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
         frame.setVisible(true);
      });
   }
}

　　

package fileChooser;

import java.io.*;

import javax.swing.*;
import javax.swing.filechooser.*;
import javax.swing.filechooser.FileFilter;

/**
  *一个框架，它有一个加载图像的菜单和一个显示区域
  *加载图像。
  */
public class ImageViewerFrame extends JFrame
{
   private static final int DEFAULT_WIDTH = 300;
   private static final int DEFAULT_HEIGHT = 400;
   private JLabel label;
   private JFileChooser chooser;

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

    //设置菜单栏
      var menuBar = new JMenuBar();
      setJMenuBar(menuBar);

      var menu = new JMenu("File");
      menuBar.add(menu);

      var openItem = new JMenuItem("Open");
      menu.add(openItem);
      openItem.addActionListener(event -> {
         chooser.setCurrentDirectory(new File("."));

          //显示文件选择器对话框
            int result = chooser.showOpenDialog(ImageViewerFrame.this);

          //显示文件选择器对话框
            if (result == JFileChooser.APPROVE_OPTION)
            {
               String name = chooser.getSelectedFile().getPath();
               label.setIcon(new ImageIcon(name));
               pack();
            }
         });

      var exitItem = new JMenuItem("Exit");
      menu.add(exitItem);
      exitItem.addActionListener(event -> System.exit(0));

    //使用标签来显示图像
      label = new JLabel();
      add(label);

    //设置文件选择器
      chooser = new JFileChooser();

    //接受所有以.jpg、.jpeg、.gif结尾的图像文件
      var filter = new FileNameExtensionFilter(
            "Image files", "jpg", "jpeg", "gif");
      chooser.setFileFilter(filter);

      chooser.setAccessory(new ImagePreviewer(chooser));

      chooser.setFileView(new FileIconView(filter, new ImageIcon("palette.gif")));
   }
}

　　

package fileChooser;

import java.awt.*;
import java.io.*;

import javax.swing.*;

/**
 * A file chooser accessory that previews images.
 * 一个文件选择附件预览图像。
 */
public class ImagePreviewer extends JLabel
{
   /**
    * 构造一个ImagePreviewer。
    *属性变化触发图像的文件选择器
    *更改此预览器
    */
   public ImagePreviewer(JFileChooser chooser)
   {
      setPreferredSize(new Dimension(100, 100));
      setBorder(BorderFactory.createEtchedBorder());

      chooser.addPropertyChangeListener(event -> {
         if (event.getPropertyName() == JFileChooser.SELECTED_FILE_CHANGED_PROPERTY)
         {
            // 用户选择了一个新文件
            File f = (File) event.getNewValue();
            if (f == null)
            {
               setIcon(null);
               return;
            }

          //将图像读入图标
            var icon = new ImageIcon(f.getPath());

          //如果图标太大，不适合，请缩放
            if (icon.getIconWidth() > getWidth())
               icon = new ImageIcon(icon.getImage().getScaledInstance(
                     getWidth(), -1, Image.SCALE_DEFAULT));

            setIcon(icon);
         }
      });
   }
}

　　

package fileChooser;

import java.io.*;
import javax.swing.*;
import javax.swing.filechooser.*;
import javax.swing.filechooser.FileFilter;

/**
 * A file view that displays an icon for all files that match a file filter.
 * 文件视图，显示与文件过滤器匹配的所有文件的图标。
 */
public class FileIconView extends FileView
{
   private FileFilter filter;
   private Icon icon;

   /**
    *构造一个FileIconView。
    * @param aFilter文件过滤器——这个过滤器接受的所有文件都会显示出来
    *与图标。
    * @param anIcon—显示所有可接受文件的图标。
    */
   public FileIconView(FileFilter aFilter, Icon anIcon)
   {
      filter = aFilter;
      icon = anIcon;
   }

   public Icon getIcon(File f)
   {
      if (!f.isDirectory() && filter.accept(f)) return icon;
      else return null;
   }
}

　　

运行结果：

    

实验1：测试程序7（7分）

代码如下：

package colorChooser;

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

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

　　

package colorChooser;

import javax.swing.*;

/**
 * A frame with a color chooser panel
 * 带有颜色选择面板的框架
 */
public class ColorChooserFrame extends JFrame
{
   private static final int DEFAULT_WIDTH = 300;
   private static final int DEFAULT_HEIGHT = 200;

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

      // 添加颜色选择器面板到框架

      ColorChooserPanel panel = new ColorChooserPanel();
      add(panel);
   }
}

　　

package colorChooser;

import java.awt.Color;
import java.awt.Frame;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;

import javax.swing.JButton;
import javax.swing.JColorChooser;
import javax.swing.JDialog;
import javax.swing.JPanel;

/**
 * A panel with buttons to pop up three types of color choosers
 * 带有按钮的面板，弹出三种颜色选择器
 */
public class ColorChooserPanel extends JPanel
{
   public ColorChooserPanel()
   {
      JButton modalButton = new JButton("Modal");
      modalButton.addActionListener(new ModalListener());
      add(modalButton);

      JButton modelessButton = new JButton("Modeless");
      modelessButton.addActionListener(new ModelessListener());
      add(modelessButton);

      JButton immediateButton = new JButton("Immediate");
      immediateButton.addActionListener(new ImmediateListener());
      add(immediateButton);
   }

   /**
    * 这个监听器弹出一个模式颜色选择器
    */
   private class ModalListener implements ActionListener
   {
      public void actionPerformed(ActionEvent event)
      {
         Color defaultColor = getBackground();
         Color selected = JColorChooser.showDialog(ColorChooserPanel.this, "Set background",
               defaultColor);
         if (selected != null) setBackground(selected);
      }
   }

   /**
    * 这个监听器弹出一个非模态的颜色选择器。当用户更改面板颜色时单击OK按钮。
    */
   private class ModelessListener implements ActionListener
   {
      private JDialog dialog;
      private JColorChooser chooser;

      public ModelessListener()
      {
         chooser = new JColorChooser();
         dialog = JColorChooser.createDialog(ColorChooserPanel.this, "Background Color",
               false /* 非模态 */, chooser,
               event -> setBackground(chooser.getColor()),
               null /* 没有取消按钮监听器 */);
      }

      public void actionPerformed(ActionEvent event)
      {
         chooser.setColor(getBackground());
         dialog.setVisible(true);
      }
   }

   /**
    * 这个监听器弹出一个非模态的颜色选择器。面板颜色立即改变时用户选择一个新的颜色。
    */
   private class ImmediateListener implements ActionListener
   {
      private JDialog dialog;
      private JColorChooser chooser;

      public ImmediateListener()
      {
         chooser = new JColorChooser();
         chooser.getSelectionModel().addChangeListener(
               event -> setBackground(chooser.getColor()));

         dialog = new JDialog((Frame) null, false /* not modal */);
         dialog.add(chooser);
         dialog.pack();
      }

      public void actionPerformed(ActionEvent event)
      {
         chooser.setColor(getBackground());
         dialog.setVisible(true);
      }
   }
}

　　

运行结果：

  

       

实验总结：（16分）

本周学习了Swing用户界面组件上周剩下的部分内容，学习设计简单应用程序的GUI，主要学了菜单和对话框的内容，从掌握菜单组件用途及常用API开始，从创建菜单开始，对快捷键，加速器，工具栏进行应用，然后掌握对话框的组件用途及常用API，尤其对选项对话框的创建和应用较多，最后一个例题的编辑和运行对颜色对话框进行了详细的应用。在之后应该多加练习，对这些组件和工具栏更加熟悉。