201871010114李岩松《面向对象程序设计（java）》第十五周学习总结

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

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

菜单

  (1)菜单也是一种常用的GUI组件，菜单采用的是一种层次结构，最顶层是菜单栏(JMenuBar)；在菜单栏中可以添加若干个菜单(JMenu)，每个菜单中又可以添加若干个菜单选项(JMenuItem)、分隔线(Separator)或是菜单(称之为子菜单)。

  (2)构建应用程序的菜单时，先创建一个菜单栏：

                  JMemuBar menuBar=new JMenuBar()

        通常使用框架的setJMenuBar(JMenuBar aMenuBar)方法将菜单栏置于框架中：

                  frame.setJMenuBar(menuBar);

随后，创建所需要的各菜单并逐个添加到菜单栏中，例如：

        JMenu menuDBAccount=new JMenu("电表出帐(C)");

       JMenu menuSysConfig=new JMenu("系统设置(X)");

            menuBar.add(menuDBAccount);

            menuBar.add(menuSysConfig);

最后，向各个菜单中添加菜单选项、分隔线或是子菜单，如图所示的系统设置菜单为例：

//创建菜单选项或是子菜单

  JMenuItem sysConfigItem=new JMenuItem("参数设置(S)...");

 JMenu viewMenu=new JMenu("外观设置");

JRadioButtonMenuItem metalItem=new JRadioButtonMenuItem("金属外观");

JRadioButtonMenuItem classicItem=new JRadioButtonMenuItem("传统外观");

JRadioButtonMenuItem modernItem=new JRadioButtonMenuItem("现代外观");

JMenuItem cascadeItem=new JMenuItem("层叠窗口(C)");

JMenuItem iconifyItem=new JMenuItem("排列图标(I)");

//将三个单选按钮添加到一个按钮组

ButtonGroup group=new ButtonGroup();

group.add(metalItem);

group.add(classicItem);

group.add(modernItem);

//构建子菜单

viewMenu.add(metalItem);

viewMenu.add(classicItem);

viewMenu.add(modernItem);

//添加到系统设置菜单

menuSysConfig.add(sysConfigItem); //添加菜单选项

menuSysConfig.add(viewMenu); //添加子菜单

menuSysConfig.add(cascadeItem); //添加菜单选项

menuSysConfig.addSeaparator(); //添加分隔线

menuSysConfig.add(iconifyItem); //添加菜单选项

(3)通常的菜单选项是JMenuItem，也可以使用复选框或是单选按钮类型的菜单选项，分别是JCheckBoxMenuItem和JRadioButtonMenuItem。和JRadioButton一样，使用JRadioButtonMenuItem时，需要将它们添加到同一个按钮组中。

(4)当点击一个菜单选项时，会生成一个动作事件(ActionEvent) 。为菜单选项添加事件侦听器就可以侦听其动作事件，例如：sysConfigItem.addActionListener(aListener);

(5)为一个菜单或是菜单选项设置快捷键：

    menuSysConfig.setMnemonic('X');

    sysConfigItem.setMnemonic('S');

(6)如果需要快速选择未打开的菜单中的菜单选项或是子菜单，可以使用加速键。例如，当希望按下CTRL+L时就立刻选中lockItem菜单选项，而不管lockItem所在的菜单是否已经打开，就可以使用下面的方法为lockItem设置加速键：

KeyStroke ks= KeyStroke.getKeyStroke( KeyEvent.VK_L,InputEvent.CTRL_MASK);

lockItem.setAccelerator(ks);

4.弹出式菜单

(1)弹出式菜单(JPopupMenu)是一种特殊的菜单，和普通菜单的区别在于其不固定在菜单栏中，而是可以四处浮动的。

(2)下面的语句创建了一个弹出式菜单：

JPopupMenu popup=new JPopupMenu();

与向菜单中添加菜单选项、分隔线或是子菜单一样，使用同样的方法向弹出式菜单中添加内容。

用户可以通过点击某个特殊的鼠标键(称为触发器)来触发弹出式菜单。例如，在Windows操作系统上，一般是鼠标右键。

为此，应用程序中应该监听弹出式菜单的父组件的鼠标事件：当有鼠标事件发生时，使用isPopupTrigger()方法来判断是否为弹出式菜单的触发器；如果是，则在该父组件上显示出弹出式菜单。同样以图所示意的弹出式菜单为例，该菜单的父组件是一个显示公司徽标的标签labLogo，当用户在该标签上右击鼠标时，弹出式菜单出现。下面的代码实现了上述功能：

labLogo.addMouseListener(new MouseAdapter(){

public void mouseReleased(MouseEvent e){

if (e.isPopupTrigger()){

popup.show(labLogo,e.getX(), e.getY());

}

}

});

对话框

(1)对话框是用户和应用程序进行交互(对话)的一个桥梁：对话框可以用于收集用户的输入数据传递给应用程序，或是显示应用程序的运行信息给用户。

(2)对话框分为模式(modal)和非模式两种。模式对话框处于可见状态时，用户将不能与应用程序的其它窗口进行交互，而非模式对话框则没有此限制。

(3)Java中提供了一个类JOptionPane用于创建简单的模式对话框，如果希望创建非模式对话框或是自定义对话框可以使用JDialog。

(4)JOptionPane类中提供了4种静态方法，用以显示4种常用的对话框：

showMessageDialog 消息对话框

showInputDialog 输入对话框

showConfirmDialog 确认对话框

showOptionDialog 选项对话框

(5)JOptionPane 对话框主要由如下几个部分构成：图标、消息以及按钮。

(6)类JOptionPane中定义了如下五个常量:

JOptionPane.QUESTION_MESSAGE

JOptionPane.INFORMATION_MESSAGE

JOptionPane.WARNING_MESSAGE

JOptionPane.ERROR_MESSAGE

JOptionPane.PLAIN_MESSAGE   //不使用图标

前四个常量对应着四个图标，第五个常量表示不使用图标。开发人员可以使用这些常量来指定对话框中显示的图标。当然，对话框也提供了方法使得开发人员可以使用自己的图标。

(7)JOptionPane对话框不仅仅可以显示字符串类型的消息，还可以显示其它类型的消息。例如，可以是一副图片、还可以是一个GUI组件。更广泛地说，这里的消息可以是任何类型的对象或是对象数组。在书上的例子中，你可以看到不同类型消息的应用。

(8)JOptionPane对话框底部的按钮取决于对话框类型和选项类型。例如，对于确认对话框，可以使用如下的四种选项类型之一：

DEFAULT_ OPTION

YES_NO_OPTION

YES_NO_CANCEL_OPTION

OK_CANCEL_OPTION

(9)如果设计一个包括两个标签、一个文本输入框、一个密码输入框和两个按钮的登录对话框，这些GUI组件被添加到一个使用了网格袋布局的面板panel中，面板panel又被添加到LoginDialog的内容窗格。类LoginDialog继承了JDialog，先来看一下LoginDialog的构建器：

public LoginDialog(Frame f,String s,boolean b)

该构建器中包含了3个参数，f和s分别是对话框的父窗口和标题，布尔类型的参数b用来确定对话框的类型，当取值为true时，表示是模式对话框；取值为false时，表示是非模式对话框。

第二部分：实验部分

1、实验目的与要求

(1) 掌握菜单组件用途及常用API；

(2) 掌握对话框组件用途及常用API；

(3) 学习设计简单应用程序的GUI。

2、实验内容和步骤

实验1： 导入第12章示例程序，测试程序并进行组内讨论。

测试程序1

l 在elipse IDE中调试运行教材512页程序12-8，结合运行结果理解程序；

l 掌握菜单的创建、菜单事件监听器、复选框和单选按钮菜单项、弹出菜单以及快捷键和加速器的用法。

l 记录示例代码阅读理解中存在的问题与疑惑。

运行结果：

package Swing图形界面;

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;

  //操作名称打印到System.out的示例操作,写AbstractAction的动作
   
   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
      fileMenu.add(new TestAction("New"));//为该菜单对象添加一个动作

      //  演示加速器
      var openItem = fileMenu.add(new TestAction("Open"));
      openItem.setAccelerator(KeyStroke.getKeyStroke("ctrl O"));
      //将加速器crtl+o 按钮关联到open对象
      fileMenu.addSeparator();
      //在菜单栏添加一条横线
      saveAction = new TestAction("Save");
      JMenuItem saveItem = fileMenu.add(saveAction);
      saveItem.setAccelerator(KeyStroke.getKeyStroke("ctrl S"));//将加速器crtl+s关联到save菜单项
      
      saveAsAction = new TestAction("Save As");
      fileMenu.add(saveAsAction);
      fileMenu.addSeparator();//在菜单栏添加一条横线

      fileMenu.add(new AbstractAction("Exit")//在菜单栏中添加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);
               saveAsAction.setEnabled(saveOk);
            }
         });

      var group = new ButtonGroup();//创建一个复选框的按钮组
      var insertItem = new JRadioButtonMenuItem("Insert");
      insertItem.setSelected(true);//
      var overtypeItem = new JRadioButtonMenuItem("Overtype");

      group.add(insertItem);//将insert按钮添加到按钮组
      group.add(overtypeItem);//将Overtype按钮添加到按钮组当中

      // 演示图标
      //在菜单中添加一个cut动作,并添加图标 
      var cutAction = new TestAction("Cut");
      cutAction.putValue(Action.SMALL_ICON, new ImageIcon("cut.gif"));
      var copyAction = new TestAction("Copy"); //在才点钟添加一个copy动作,并添加图标 
      copyAction.putValue(Action.SMALL_ICON, new ImageIcon("copy.gif"));
      var pasteAction = new TestAction("Paste");//在菜单中添加一个paste动作,并添加图标 
      pasteAction.putValue(Action.SMALL_ICON, new ImageIcon("paste.gif"));

      var editMenu = new JMenu("Edit");//在菜单中添加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);

      editMenu.addSeparator();//在嵌套菜单中添加了一条横线
      editMenu.add(optionMenu);

      // demonstrate mnemonics

      var helpMenu = new JMenu("Help");//在菜单中添加Help选项
      helpMenu.setMnemonic('H');//将help选项的第一个按钮下添加下划线

      var indexItem = new JMenuItem("Index");//创建help的子菜单并将其第一个字母加下划线
      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);

      // 演示弹出菜单
      popup = new JPopupMenu();
      popup.add(cutAction);
      popup.add(copyAction);
      popup.add(pasteAction);

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

package Swing图形界面;

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

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

测试程序2

l 在elipse IDE中调试运行教材517页程序12-9，结合运行结果理解程序；

l 掌握工具栏和工具提示的用法；

l 记录示例代码阅读理解中存在的问题与疑惑。

package Swing图形界面;

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



      //填充工具栏

      var bar = new JToolBar();
      bar.add(blueAction);
      bar.add(yellowAction);
      bar.add(redAction);
      bar.addSeparator();
      bar.add(exitAction);
      add(bar, BorderLayout.NORTH);

      // populate menu

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

   // "颜色"操作将帧的背景设置为给定颜色。
   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, name + " background");
         putValue("Color", c);
      }

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

package Swing图形界面;

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

 测试程序3

l 在elipse IDE中调试运行教材544页程序12-15、12-16，结合运行结果理解程序；

l 掌握选项对话框的用法。

l 记录示例代码阅读理解中存在的问题与疑惑。

package optionDialog;

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

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

package Swing图形界面;

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

   /* 获取选定的消息或选项类型panel消息类型或确认面板 ,从JOptionPane类返回选定的XXX_消息或XXX_选项常量*/
   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));
         else if (typePanel.getSelection().equals("Input"))
         {
            if (inputPanel.getSelection().equals("Text field")) JOptionPane.showInputDialog(
                  OptionDialogFrame.this, getMessage(), "Title", getType(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]);
      }
   }
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);
      g2.draw(rect);
   }

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

运行结果：

 

测试程序4

l 在elipse IDE中调试运行教材552页程序12-17、12-18，结合运行结果理解程序；

l 掌握对话框的创建方法；

l 记录示例代码阅读理解中存在的问题与疑惑。

package Swing图形界面;

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.
 */
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项显示About对话框

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

      // 退出项退出程序

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

package Swing图形界面;

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

运行结果：

测试程序5

l 在elipse IDE中调试运行教材556页程序12-19、12-20，结合运行结果理解程序；

l 掌握对话框的数据交换用法;

l 记录示例代码阅读理解中存在的问题与疑惑。

package Swing图形界面;

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

      // 创建终止对话框的“确定”和“取消”按钮
      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);
   }

  /*
           设置对话框默认值。
    */
   public void setUser(User u)
   {
      username.setText(u.getName());
   }

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

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

      // 定位所有者框架

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

      // 设置title和对话框

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

package Swing图形界面;

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

      // the Exit item exits the program

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

  //退出项退出程序


   private class ConnectAction implements ActionListener
   {
      public void actionPerformed(ActionEvent event)
      {
         // 如果是第一次，则构造对话框

         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 Swing图形界面;

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

测试程序6

l 在elipse IDE中调试运行教材556页程序12-21、12-2212-23，结合程序运行结果理解程序；

l 掌握文件对话框的用法;

记录示例代码阅读理解中存在的问题与疑惑

package Swing图形界面;

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 Swing图形界面;

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

/**
 * 显示与文件筛选器匹配的所有文件的图标的文件视图。
 */
public class FileIconView extends FileView
{
   private FileFilter filter;
   private Icon icon;

   /**
    * 构造文件图标视图。

    a filter文件筛选器--此筛选器接受的所有文件都将显示带着图标。
    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;
   }
}

package Swing图形界面;

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

import javax.swing.*;

/**
 * 
预览图像的文件选择器附件。
*/
public class ImagePreviewer extends JLabel
{
   /**
    * 构造图像预览器。
      chooser其属性更改触发图像的文件选择器
                  此预览器中的更改
    */
   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 Swing图形界面;

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")));
   }
}

 

l 在elipse IDE中调试运行教材570页程序12-24，结合运行结果理解程序；

l 了解颜色选择器的用法。

l 记录示例代码阅读理解中存在的问题与疑惑。

package Swing图形界面;

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 Swing图形界面;

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;

/**
* 
带有按钮的面板，可弹出三种颜色选择器
*/
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);
     }
  }

  /**
   *这个监听器弹出一个无模式颜色选择器。当用户单击确定按钮。
   */
  private class ModelessListener implements ActionListener
  {
     private JDialog dialog;
     private JColorChooser chooser;

     public ModelessListener()
     {
        chooser = new JColorChooser();
        dialog = JColorChooser.createDialog(ColorChooserPanel.this, "Background Color",
              false /* not modal */, chooser,
              event -> setBackground(chooser.getColor()),
              null /* no Cancel button listener */);
     }

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

package Swing图形界面;
 
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);
   }
}

 实验总结：

本周学习了关于菜单、对话框两类组件用途及常用API，通过学习了解了在javaGUI设计中的菜单栏和对话框的设计方式以及内在练习，通过编程练习再次复习了文件的读取功能和方法，对于以前只是和javaGUI的swing用户界面设计有了更多的知识积累