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

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

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

本章内容：

12.5 菜单

1. 位于窗口顶部的菜单栏（menu bar）包括了下拉菜单的名字。点击一个名字就可以打开包含菜单项（menu items）和子菜单（submenus）的菜单。当用户点击菜单项时，所有的菜单都会被关闭并且将一条消息发送给程序。

12.5.1 菜单创建

1. 在通常情况下，菜单项触发的命令也可以通过其他用户界面元素（如工具栏上的按钮）激活。
2. 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)
     从菜单中删除指定的菜单项。
3. javax.swing.JMenuItem 1.2
   • JMenuItem(String label)
     用给定标签构造一个菜单项。
   • JMenuItem(Acton a) 1.3
     为给定动作构造一个菜单项。
4. javax.swing.AbstractButton 1.2
   • void setAction(Action a) 1.3
     为这个按钮或菜单项设置动作。
5. javax.swing.JFrame 1.2
   • void setJMenuBar(JMenuBar menubar)
     为这个框架设置菜单栏。

12.5.2 菜单项中的图标

1. JMenuItem类扩展了AbstractButton类。与按钮一样，菜单可以包含文本标签、图标，也可以两者都包含。既可以利用JMenuItem(String,Icon)或者JMenuItem(Icon)构造器为菜单指定一个图标，也可以利用JmenuItem类中的setIcon方法（继承自AbstractButton类）指定一个图标。
2. javax.swing.JMenuItem 1.2
   • JMenuItem(String label,Icon icon)
     用给定的标签和图标构造一个菜单项。
3. javax.swing.AbstractButton 1.2
   • void setHorizontalTextPosition(int pos)
     设置文本对应图标的水平位置。
     参数：pos SwingConstants.RIGHT（文本在图标的右侧）或SwingConstants.LEFT。
4. javax.swing.AbstractAction 1.2
   • AbstractAction(String name,Icon smallIcon)
     用给定的名字和图标构造一个抽象的动作。

12.5.3 复选框和单选按钮菜单项

1. 复选框和单选按钮菜单项在文本旁边显示了一个复选框或一个单选按钮。当用户选择一个菜单框时，菜单项就会自动地在选择和未选择间进行切换。
2. javax.swing.JCheckBoxMenuItem 1.2
   • JCheckBoxMenuItem(String label)
     用给定的标签构造一个复选框菜单项。
   • JCheckBoxMenuItem(String label,boolean state)
     用给定的标签个给定的初始状态（true为选定）构造一个复选框菜单。
3. javax.swing.JRadioButtonMenuItem 1.2
   • JRadioButtonMenuItem(String label)
     用给定的标签构造一个单选按钮菜单项。
   • JRadioButtonMenuItem(String label,boolean state)
     用给定的标签和给定的初始状态（true为选定）构造一个单选按钮菜单项。
4. javax.swing.AbstractButton 1.2
   • boolean isSelected()
   • void setSelected(boolean state)
     获取或设置这个菜单项的选择状态（true为选定）。

12.5.4 弹出菜单

1. 弹出菜单（pop-up menu）是不固定在菜单栏中随处浮动的菜单。
2. 通常，当用户点击某个鼠标键时弹出菜单。这就是所谓的弹出式触发器（pop-up trigger）。在Window或者Linux中，弹出式触发器是鼠标右键。
3. javax.swing.JPopupMenu 1.2
   • void show(Component c,int x,int y)
     显示一个弹出菜单。
     参数：c 显示弹出菜单的组件。 x,y 弹出菜单左上角的坐标（c的坐标空间内）。
   • boolean isPopupTrigger(MouseEvent event) 1.3
     如果鼠标事件是弹出菜单触发器，则返回true。
4. java.awt.event.MouseEvent 1.1
   • boolean isPopupTrigger()
     如果鼠标事件是弹出菜单触发器，则返回true。
5. javax.swing.JComponent 1.2
   • JPopupMenu getComponentPopupMenu() 5.0
   • void setComponentPopupMenu(JPopupMenu popup)
     获取或设置用于这个组件的弹出菜单。
   • boolean getInheritsPopupMenu() 5.0
   • void setInheritsPopupMenu(boolean b) 5.0
     获取或设置inheritsPopupMenu特性。如果这个特性被设置或这个组件的弹出菜单为null，则应用上一级弹出菜单。

12.5.5 快捷键和加速器

1. 可以通过在菜单项的构造器中指定一个快捷字母来为菜单项设置快捷键。
2. 快捷键会自动地显示在菜单项中，并带有一条下划线。
3. 在Java SE 1.4中，可以调用setDiaplayedMnemonicIndex方法指定希望加下划线的字符。
4. 如果有一个Action对象，就可以把快捷键作为Action.MNEMONIC_KEY的键值添加到对象中。
5. 只能在菜单项的构造器中设定快捷键祖母，而不是在菜单构造器中。如果想为菜单设置快捷键，需要调用setMnemonic方法。
6. 可以同时按下ALT键和菜单的快捷键来实现在菜单栏中选择一个顶层菜单的操作。
7. 可以使用快捷键从当前打开的菜单中选择一个子菜单或者菜单项。而加速器是在不打开菜单的情况下选择菜单项的快捷键。
8. 当用户按下加速器组合键时，就会自动地选择相应的菜单项，同时激活一个动作事件，这与手动地选择这个菜单项一样。
9. 加速器只能关联到菜单项上，不能关联到菜单上。加速器键并不实际打开菜单。它将直接地激活菜单关联的动作事件。
10. javax.swing.HMenuItem 1.2
    • JMenuItem(String label, int mnemonic)
      用给定的标签和快捷键字符构成一个菜单项。
      参数：label 菜单项的标签。 mnemonic 菜单项的快捷键字符，在标签中这个字符下面会有一个下划线。
    • void setAccelerator(KeyStroke k)
      将k设置为这个菜单项的加速器。加速器显示在标签的旁边。
11. javax.swing.AbstractButton 1.2
    • void setMnemonic(int mnemonic)
      设置按钮的快捷字符。该字符会在标签中以下划线的形式显示。
    • void setDisplayedMnemonicIndex(int index) 1.4
      将按钮文本中的index字符设定为带下划线。如果不希望第一个出现的快捷键字符带下划线，就可以使用这个方法。

12.5.6 启用和禁用菜单项

1. 启动和禁用菜单项有两种策略。每次环境发生变化就对相关的菜单项或动作调用setEnabled。另一种方式是在现实菜单之前禁用这些菜单栏。
2. javax.swing.JMenuItem 1.2
   • void setEnabled(boolean b)
     启用或禁用菜单项。
3. javax.swing.event.MenuListener 1.2
   • void menuSelected(MenuEvent e)
     在菜单被选择但尚未打开之前调用。
   • void menuDeselected(MenuEvent e)
     在菜单被取消选择并且已经关闭之后被调用。
   • void menuCanceled(MenuEvent e)
     当菜单被取消时被调用。例如，用户单击菜单以外的区域。

12.5.7 工具栏

1. 工具栏是在程序中提供的快速访问常用命令的按钮栏。
2. 工具栏的特殊之处在于可以将它随处移动。可以将它拖拽到框架的四个边框上。
3. 工具栏只有位于采用边框布局或者任何支持North、East、South和Weat约束布局管理器的容器内才能够被拖拽。
4. 工具栏可以完全脱离框架。这样的工具栏将包含在自己的框架中。当关闭包含工具栏的框架时，它会回到原始的框架中。

12.5.8 工具提示

1. 当光标停留在某个按钮上片刻时，工具提示就会被激活。工具提示文本显示在一个有颜色的矩形里。当用户移开鼠标时，工具提示就会自动地消失。
2. javax.swing.JToolBar 1.2
   • JToolBar()
   • JToolBar(String titleString)
   • JToolBar(int orientation)
   • JToolBar(String titleString,int orientation)
     用给定的标题字符串和方向构造一个工具栏。Orientation可以是SwingConstants.HORIZONTAL(默认)或SwingConstants.VERTICAL。
   • JButton add(Action a)
     用给定的动作名、图标、简要的说明和动作回调构造一个工具栏中的新按钮。
   • void addSeparator()
     将一个分隔符添加到工具栏的尾部。
3. javax.swing.JComponent 1.2
   • void setToolTipText(String text)
     设置当鼠标停留在组件上时显示在工具提示中的文本。

12.6 复杂的布局管理

1. Java布局管理器是一种用于组件布局的好方法。应用布局管理器，布局就可以使用组件间关系的指令来完成布局操作。

12.6.1 网格组布局

1. 网格足布局是所有布局管理器之母。可以将网格组布局看成是没有任何限制的网格布局。在网格组布局中，行和列的尺寸可以改变。可以将相邻的单元合并以适应较大的组件（很多字处理器以及HTML都利用这个功能编辑表格：一旦需要就合并相邻的单元格）。组件不需要填充这个单元格区域，并可以指定它们在单元格内的对齐方式。
2. 要想使用网格组管理器进行布局，必须经过下列过程：

• 建立一个GridBagLayout的对象。不需要指定网格的行数和列数。布局管理器会根据后面所给的信息猜测出来。
• 将GridBagLayout对象设置成组件的布局管理器。
• 为每个组件建立一个GridBagConstraints对象。设置GridBagConstraints对象的域以便指出组件在网格组中的布局方案。
• 最后，通过下面的调用添加组件的约束：add(component,constraints);。

1. GridBagConstraints对象的几个最重要的约束
   （1）gridx、girdy、gridwidth和gridheight参数
   这些约束定义了组件在网格中的位置。gridx和girdy指定了被添加组件左上角的行、列位置。gridwidth和gridheight制定了组件占据的行数和列数。
   （2）增量域
   在网格布局中，需要为每个区域设置增量域（weightx和weighty）。如果将增量设置为0，则这个区域将永远为初始尺寸。如果将所有区域的增量都设置为0，容器就会集聚在为它分配的区域中间，而不是通过拉伸来填充它。
   从概念上讲，增量参数属于行和列的属性，而不属于某个单独的单元格。但却需要在单元格上指定它们，这是因为网格组布局并不暴露行和列。行和列的增量等于每行或每列单元格的增量最大值。因此，如果想让一行或一列的大小保持不变，就需要将这行、这列的所有组件的增量都设置为0。
   注意，增量并不实际给出列的相对大小。当容器超过首选大小时，增量表示分配给每个区域的扩展比例值。
   （3）fill和anchor参数
   如果不希望组件拉伸至整个区域，就需要设置fill约束。它有四个有效值：GridBagConstraints.NONE、GridBagConstraints.HORIZONTAL、GridBagConstraints.VERTICAL和GridBagConstraints.BOTH。
   （4）填充
   可以通过设置GridBagLayout的insets域在组件周围增加附件的空白区域。通过设置Insets对象的left、top、right和bottom指定组件周围的空间量。这被称为外部填充（或外边距）（external padding）。
   通过设置ipadx和ipady指定内部填充（或内外距）（internal padding）。这两个值被加到组件的最小宽度和最小高度上。这样可以保证组件不会收缩至最小尺寸之下。
   （5）指定gridx,gridy,gridwidth和gridheight参数的另一种方法
   需要通过为gridheight和gridwidth域指定一个适当的值来设置组件横跨的行数和列数。除此之外，如果组件扩展至最后一行或最后一列，则不要给出一个实际的数值，而是用常量GridBagConstraints.REMAINDER替代，这样会告诉布局管理器这个组件时本行上的最后一个组件。
   （6）使用帮助类来管理（tame）网格组约束
2. java.awt.GridBagConstraints 1.0
   • int girdx,girdy
     指定单元格的起始行和列。默认值为0.
     • int gridwidth,girdheight
       指定单元格的行和列的范围。默认值为1.
   • double weightx,weighty
     指定单元格扩大时的容量。默认值为0.
   • int anchor
     表示组件在单元格内的对齐方式。可以选择的绝对位置有：NORTHWEAT、NORTH、NORTHEAST、WEST、CENTER、EAST、SOUTHWEST、SOUTH、SPUTHEAS。或者各个方向上的相对位置：FIRST_LINE_START、LINE_START、FIRST_LINE_END、PAUSE_START、CENTER、PAGE_END、LAST_LINE_START、LINE_END、LAST_LINE_END。如果应用程序有可能从右向左，或者自顶至底排列文本，就应该使用后者。默认值为CENTER。
   • int fill
     指定组件在单元格内的填充行为，取值为NONE、BOTH、HORIZONTAL，或者VERTICAL。默认值为NONE。
   • int ipadx,ipady
     指定组件周围的“内部”填充。默认值为0。
   • Insets insets
     指定组件边框周围的“外部”填充。默认为不填充。
   • GridBagConstraints(int gridx,int gridy,int girdwidth,int
     gridheight,double weightx,double weighty,int anchor,int fill,Insets
     insets,int ipadx,int ipady) 1.2
     用参数中给定的多有域值构造GridBagConstains。Sun建议这个构造器只用在自动代码生成器只用在自动生成器中，因为它会使得代码非常难于阅读。

12.6.2 组布局

1. javax.swing.GroupLayout 6
   • GroupLayout(Container host)
     构造一个GroupLayout对象，用于布局host容器中的组件（注意：host容器仍然需要调用setLayout）。
   • void setHorizontalGroup(GroupLayout.Group g)
   • void setVerticalGroup（GroupLayout.Group g）
     设置用于控制水平或垂直容器的组。
   • void linkSize(Component… components)
   • void linkSize(int axis,Component… components)
     强制给定的几个组件具有相同的尺寸，或者在指定的坐标轴上有相同的尺寸（SwingConstants.HORIZONTAL或者SwingContants.VERTICAL）。
   • GroupLayout.SequentialGroup createSequentialGroup()
     创建一个组，用于并行地布局子组件。
   • GroupLayout.ParallelGroup createParallelGroup()
   • GroupLayout.ParallerGroup createParallerGroup(GroupLayout.Alignment align)
   • GroupLayout.ParallelGroup createParallelGroup(GroupLayout.Alignment align,boolean resizable)
     创建一个组，用于并行地布局子组件。
     参数：align BASELINE、LEADING(默认值)、TRAILING或CENTER。resizable 如果组可以调整大小，这个值为true(默认值)；如果首选的尺寸是最小尺寸或最大尺寸，这个值为false。
   • boolean getHonorsvisibility()
   • void setHonorsvisibility(boolean b)
     获取或设置honorsVisibility特性。当这个值为true(默认值)时，不可见的组件不参与布局。当这个值为false时，好像可见的组件一样，这些组件也参与布局。这个特性主要用于想要临时影藏一些组件，而又不希望改变布局的情况。
   • boolean getAutoCreateCaps()
   • void setAutoCreateaps(boolean b)
   • boolean getAutoCreateContainerCaps()
   • void setAutoCreateContainerCaps(boolean b)
     获取或设置autoCreateCaps和autoCreateContainerCaps特性。当这个值为true时，将自动地在组件或容器边框之间添加空隙。默认值是false。在手工地构造GroupLayout时，true值很有用。
2. javax.swing.GroupLayout.Group
   • GroupLayout.Group addComponent(Component c)
   • GroupLayout.Group addComponent(Component c,int minimumSize,int preferredSize,int maximumSize)
     添加一个组件至本组中。尺寸参数可以是一个实际值（非负值），或者是一个特定的常量GroupLayout.DEFAULT_SIZE或GroupLayout.PREFERRED_SIZE。当使用DEFAULT_SIZE，将调用组件的getMinimumSize、getPreferredSize或getMaximumSize。当使用PREFERRED_SIZE时，将调用组件的getPreferredSize方法。
   • GroupLayout.Group addCap(int size)
   • GroupLayout.Group addCap(int minimumSize,int preferredSize,int maximumSize)
     添加一个固定的或可调节的空隙。
   • GroupLayout.Group addGroup(GroupLayout.Group g)
     将一个给定的组添加到本组中。
3. javax.swing.GroupLayout.ParallelGroup
   • GroupLayout.ParallelGroup addComponent(Component c,GroupLayout.Alignment align)
   • GroupLayout.ParallelGroup addComponent(Component
     c,GroupLayout.Alignment align,int minimumSize,int preferredSize,int
     maximumSize)
   • GroupLayout.ParallelGroup addGroup(GroupLayout.Group g,GroupLayout.Alignment align)
     利用给定的对齐方式（BASELINE、LEADING、TRAILINC或CENTER）添加一个组件或组至本组中。
4. javax.swing.GroupLayout.SequentialGroup
   • GroupLayout.SequentialGroup addContainerCap()
   • GroupLayout.SequentialGroup addContainerCap(int preferredSize,int maximumSize)
     为分割组件和容器的边缘添加一个间隙。
   • GroupLayout.SequentialGroup addPreferredCap(LayoutStyle.ComponentPlacement type)
     为分隔组件添加一个间隙。间隙的类型是LayoutStyle.ComponentPlacement.RELATED或LayoutStyle.ComponentPlacement。

12.6.3 不使用布局管理器

1. 下面是将一个组件定位到某个绝对定位的步骤：
   （1）将布局管理器设置为null。
   （2）将组件添加到容器中。
   （3）指定想要放置的位置和大小。
2. java.awt.Component 1.0
   • void setBounds(int x,int y,int edth,int height)
     移动并调整组件的尺寸。
     参数：x,y 组件新的左上角位置。width,height 组件新的尺寸。

12.6.4 定制布局管理器

1. 定制布局管理器必须实现LayoutManager接口，并且需要覆盖下面5个方法：void addLayoutComponent(String s,Component c);,void removeLayout(Component c);,Dimension preferredLayoutSize(Container parent);、Dimension minimumLayoutSize(Container parent)、void layoutContainer(Container parent)。
   在添加或删除一个组件时会抵用前面两个方法。如果不需要保存组件的任何附加信息，那么可以让这两个方法什么都不做。接下来的两个方法计算组件的最小布局和首选布局所需要的空间。两者通常相等。第5个方法真正地实施操作，它调用所有组件的setBounds方法。
2. java.awt.LayoutManager 1.0
   • void addLayoutComponent(String name,Component cmp)
     将组件添加到布局中。
     参数：name 组件位置的标识符。 comp 被添加的组件。
   • void removeLayoutComponent(Component comp)
     从本布局中删除一个组件。
   • Dimension preferredLayoutSize(Container cont)
     返回本布局下的容器的首选尺寸。
   • Dimension minimumLayoutSize(Container cont)
     返回本布局中下容器的最小尺寸。
   • void layoutContainer(Container cont)
     摆放容器内的组件。

12.6.5 遍历顺序

1. 当把很多组件添加到窗口中时，需要考虑遍历顺序（traversal order）的问题。
2. 调用compnent.setFocusable(false);可以从焦点遍历中删除一个组件。这对于不接受键盘输入、自行绘制的组件很有用。

12.7 对话框

1. 与大多数的窗口系统一样，AWT也分为模式对话框和无模式对话框。所谓模式对话框是指在结束对它的处理之前，不允许用户与应用程序的其余窗口进行交互。模式对话框主要用于在程序继续运行之前获取用户提供的信息。
   所谓无模式对话框是指允许用户同时在对话框和应用程序的其他窗口中输入信息。使用无模式对话框的最好例子就是工具栏。工具栏可以停靠在任何地方，并且用户可以在需要的时候，同时与应用程序窗口和工具栏进行交互。
2. Swing有一个很容易使用的类JOptionPane，它可以弹出一个简单的对话框，而不必编写任何对话框的相关代码。

12.7.1 选项对话框

1. Swing有一套简单的对话框，用于获取用户的一些简单信息。JOptionPane有4个用于显示这些对话框的静态方法：
   showMessageDialog：显示一条消息并等待用户点击OK
   showConfirmDialog：显示一条消息并等待用户确认（与OK/Cancel类似）
   showOptionDialog：显示一条消息并获得用户在一组选项中的选择
   showInputDialog：显示一条消息并获得用户输入的一行文本
2. 输入对话框有一个用于接收用户输入的额外组件。它既可能是用于输入任何字符串的文本域，也可能是允许用户从中选择的组合框。
3. 这些对话框的确切布局和为标准消息类型选择的图标都取决于具体的观感。
4. 每个对话框类型都有一个方法，可以用来提供自己的图标，以替代原来的图标。
5. 可以为每个对话框类型指定一条消息。这的消息既可以是字符串、图标、用户界面组件，也可以是其他类型的对象。下面是显示消息对象的基本方法：
   String: 绘制字符串
   Icon： 显示图标
   Component： 显示组件
   Object[]： 显示数组中的所有对象，一次叠加
   任何其他对象： 调用toString方法来显示结果字符串
6. 唯一底部的按钮取决于对话框类型和选项类型。当调用showMessageDialog和showInputDailog时，只能看到一组标准按钮（分别是OK/Cancel）。当调用showConfirmDialog时，可以选择下面四种选项类型之一：DEFAULT_OPTION、YES_NO_OPTION、YES_NO_CANCEL_OPTION、OK_CANCEL_OPTION。
7. 使用showOptionDialog可以指定任意的选项。这里需要为选项提供一个对象数组。每个数组元素可以是下列类型之一：
   String：使用字符串标签创建一个按钮
   Icon：使用图标创建一个按钮
   Component：显示这个组件
   其他类型的对象：使用toString方法，然后用结果字符串作为标签创建按钮。
8. 这些方法的返回值：
   showMessageDialog 无
   showConfirmDialog 表示被选项的一个整数
   showOptionDialog 表示被选项的一个整数
   showInputDialog 用户选择或输入的字符串
   showConfirmDialog和showOptionDialog返回一个整数用来表示用户选择了哪个按钮。对于选项对话框来说，这个值就是被选的选项的索引值或者是CLOSED_OPTION（此时用户没有选择可选项，而是关闭了对话框），对于确认对话框，返回值可以是下列值之一：OK_OPTION、CANCEL_OPTION、YES_OPTION、NO_OPTION、CLOSED_OPTION。
9. 消息字符串中可以包含换行符（’\n’）。这样就可以让字符串多行显示。
10. javax.swing.JOptionPane 1.2
    • static void showMessageDialog(Component parent,Object message,String title,int messageType,Icon icon)
    • static void showMessageDialog(Component parent,Object message,String title,int messageType)
    • static void showMessageDialog(Component parent,Object message)
    • static void showInternalMessageDialog(Component parent,Object message,String title,int messageType,Icon icon)
    • static void showInternalMessageDialog(Component parent,Object message,String title,int messageType)
    • static void showInternalMessageDialog(Component parent,Object message)
      显示一个消息对话框或者一个内部消息对话框（内部对话框完全显示在所在的框架内）。
      参数：parent
      父组件（可以为null）。 message 显示在对话框中的消息（可以是字符串、图标、组件或者一个这些类型的数组）。title
      对话框标题栏中的字符串。messageType
      取值为ERROR_MESSAGE、INFORMATION_MESSAGE、WARNING_MESSAGE、QUESTION_MESSAGE、PLAIN_MESSAGE之一。icon
      用于替代标准图标的图标。
    • static int showConfirmDialog(Component parent,Object message,String title,int optionType,int messageType,Icon icon)
    • static int showConfirmDialog(Component parent,Object message,String title,int optionType,int messageType)
    • static int showConfirmDialog(Component parent,Object message,String title,int optionType)
    • static int showConfirmDialog(Component parent,Object message)
    • static int showInternalConfirmDialog(Component parent,Object message,String title,int optionType,int messageType,Icon icon)
    • static int showInternalConfirmDialog(Cmponent parent,Object message,String title,int optionType,int messageType)
    • static int showInternalConfirmDialog(Component parent,Object message,String title,int optionType)
    • static int showInternalConfirmDialog(Component parent,Object message)
      显示一个确认对话框或者内部确认对话框（内部对话框完全显示在所在的框架内）。返回用户选择的选项（取值为OK_OPTION，CANCEL_OPTION，YES_OPTION，NO_OPTION0）;如果用户关闭对话框将返回CLOSED_OPTION。
      参数：parent
      父组件（可以为null）。 message 显示在对话框中的消息（可以是字符串、图标、组件或者一个这些类型的数组）。 title
      对话框标题栏中的字符串。 messageType
      取值为ERROR_MESSAGE、INFORMATION_MESSAGE、WARNING_MESSAGE、QUESTION_MESSAGE、PLAN_MESSAGE之一。optionType

      取值为DEFAULT_OPTION、YES_NO_OPTION、YES_NO_CANCEL_OPTION、OK_CANCEL_OPTION之一。icon
      用于替代标准图标的图标。

    • static int showOptionDialog(Component parent,Object message,String
      title,int optionType,int messageType,Icon icon,Object[] options,Object
      default)
    • static int showInternalOptionDialog(Component parent,Object
      message,String title,int optionType,int messageType,Icon icon,Object[]
      options,Object default)
      显示一个选项对话框或者内部选项对话框（内部对话框完全显示在所在的框架内）。返回用户选择的选项索引；如果用户取消对话框返回CLOSED_OPTION。
      参数：parent
      父组件（可以为null）。message 显示在对话框中的消息（可以是字符串，图标，组件或者一个这些类型的数组）。title
      对话框标题栏中的字符串。messageType
      取值为ERROR_MESSAGE、INFORMATION_MESSAGE、WARNING_MESSAGE、QUESTION_MESSAGE、PLAIN_MESSAGE之一。optionType

      取值为DEFAULT_OPTION、YES_NO_OPTION、YES_NO_CANCEL_OPTION、OK_CANCEL_OPTION之一。icon
      用来替代标准图标的图标。options 一组选项（可以是字符串、图标或者组件）。default 呈现给用户的默认值。

    • static Object showInputDialog(Component parent,Object message,String
      title,int messageType,Icon icon,Object[] values,Object default)
    • static String showInputDialog(Component parent,Object message,String title,int messageType)
    • static String showInputDialog(Component parent,Object message)
    • static String showInputDialog(object message)
    • static String showInputDialog(Component parent,Object message,Object default) 1.4
    • static String showInputDialog(Object message,Object default) 1.4
    • static String showInternalInputDialog(Component parent,Object
      message,String title,int messageType,Icon icon,Object[] values,Object
      default)
    • static Strng showInternalInputDialog(Component parent,Object message,String title,int messageType)
    • static String showInternalInputDialog(Component parent,Object message)
      显示一个输入对话框或者内部输入对话框（内部对话框完全显示在所在的框架内）。返回用户输入的字符串；如果用户取消对话框返回null。
      参数：parent
      父组件（可以为null）。message 显示在对话框中的消息（可以是字符串、图标、组件或者一个这些类型的数组）。title
      对话框标题栏中的字符串。 messageType
      取值为ERROR_MESSAGE、INFORMATION_MESSAGE、WARNING_MESSAGE、QUESTION_MESSAGE、PLAI_MESSAGE之一。icon
      用于替代标准图标的图标。values 在组合框中显示的一组值。default 呈现给用户的默认值。

12.7.2 创建对话框

1. 要想创建一个对话框，需要从JDialog派生一个类。具体过程如下：
   （1）在对话框构造器中，调用超类JDialog的构造器。
   （2）添加对话框的用户界面组件。
   （3）添加事件处理器。
   （4）设置对话框的大小。
2. 在调用超类构造器时，需要提供拥有者框架（owner frame）、对话框标题及模式特征。
3. 拥有者框架控制对话框的显示位置，如果将拥有者标识为null，那么对话框将由一个隐藏框架所拥有。
4. 模式特征将指定对话框处于显示状态时，应用程序中其他窗口是否被锁住。无模式对话框不会锁住其他窗口，而有模式对话框将锁住应用程序中的所有其他窗口（除对话框的子窗口外）。用户经常使用的工具栏就是无模式对话框，另一方面，如果想强迫用户在继续操作之前提供一些必要的信息就应该使用模式对话框。
5. javax.swing.JDialog 1.2
   • public JDialog(Frame parent,String title,boolean modal)
     构造一个对话框。在没有明确地让对话框显示之前，它是不可见的。
     参数：parent 对话框拥有者的框架。 title 对话框的标题。 modal True代表模式对话框（模式对话框阻塞其他窗口的输入）。

12.7.3 数据交换

1. 很多对话框都有默认按钮。如果用户按下一个触发器键就自动地选择了它。默认按钮通常用加粗的轮廓给予特别的标识。
2. javax.swing.SwingUtilities 1.2
   • Container getAncestorOfClass(Clas c,Component comp)
     返回给定组件的最先的父容器。这个组件属于给定的类或者其子类之一。
3. javax.swing/JComponent 1.2
   • JRootPane getRootPane()
     获得最靠近这个组件的根窗格，如果这个组件的祖先没有根窗格返回null。
4. javax.swing.JRootPane 1.2
   • void setDefaultButton(JButton button)
     设置根窗格的默认按钮。要想禁用默认按钮，需要将参数设置为null。
5. javax.swing.JButton 1.2
   • boolean isDefaultButton()
     如果这个按钮是它的根窗格的默认按钮，返回true。

12.7.4 文件对话框

1. Swing中提供了JFileChooser类，它可以显示一个文本对话框，其外观与本地应用程序中使用的文件对话框基本一样。JFileChooser是一个模式对话框。注意，JFileChooser类并不是JDialog类的子类。需要调用showOpenDialog，而不是调用setVisible(true)显示打开文件的对话框，或者调用showSaveDialog显示保存文件的对话框。接收文件的按钮被自动地标签为Open或者Save。也可以调用sowDialog方法为按钮设定标签。
2. 建立文件对话框并且获取用户选择信息的步骤：
   （1）建立一个JFileChooser对象。与JDialog类的构造器不同，它不需要指定父组件。允许在多个框架中重用一个文件选择器。
   （2）调用setCurrentDirectory方法设置当前目录。
   （3）如果有一个想要作为用户选择的默认文件名，可以使用setSelectedFile方法进行指定。
   （4）如果允许用户在对话框中选择多个文件，需要调用setMultiSelectionEnabled方法。当然，这是可选的。
   （5）如果想让对话框仅显示某一种类型的文件，西药设置文件过滤器。
   （6）在默认情况下，用户在文件选择器中只能选择文件。如果希望选择目录，需要调用setFileSelectionMode方法。参数值为：JFileChooser.FILES_ONLY（默认值），JFileChooser.DIRECTORIES_ONLY或者JFileChooser.FILES_AND_DIRECTORIES。
   （7）调用showOpenDialog或者showSaveDialog方法显示对话框。
   （8）调用getSelectedFile()或者getSelectedFiles()方法获取用户选择的一个或多个文件。这些方法将返回一个文件对象或者一组文件对象。如果需要知道文件对象名时，可以调用getPath方法。
3. 若想限制显示的文件，需要创建一个实现了抽象类javax.swing.filechooser.FileFilter的对象。文件选择器将每个文件传递给文件过滤器，只有文件过滤器接受的文件才被最终显示出来。
4. 用户可以从文件对话框底部的组合框中选择过滤器。在默认情况下，All File过滤器总是显示在组合框中。如果想禁用All files过滤器，需要调用：chooser.setAcceptAllFileFilterUsed(false)。
5. 如果为加载和保存不同类型的文件重用一个文件选择器，就需要调用：chooser.resetChoosablefILTERS()，这样可以在添加新文件过滤器之前清除旧文件过滤器。
6. 可以通过为文件选择器显示的每个文件提供特定的图标和文件描述来定制文件选择器。者需要应用一个扩展于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方法将文件视图安装到文件选择器中。
7. 文件选择器为每个希望显示的文件或目录调用这些方法。如果方法返回的图标、名字或描述信息为null，那么文件选择器将会构造当前观感的默认文件视图。这样处理很好，器援用是这样只需要处理具有不同显示的文件类型。
8. 文件选择器调用isTravesable方法来决定是否在用户点击一个目录的时候打开这个目录。
9. javax.swing.JFileChooser 1.2
   • JFileChooser()
     创建一个可用于多框架的文件选择器对话框。
   • void setCurrentDirectory(File file)
     设置文件对话框的初始目录。
   • void setSelectedFile(File file)
   • void setSelectedFiles(File[] file)
     设置文件对话框的默认文件选择。
   • void setMultiSelectionEnabled(boolean b)
     设置或清除多选模式。
   • void setFileSelectionMode(int mode)
     设置用户选择模式，只可以选择文件（默认），只可以选择目录，或者文件和目录均可以选择。mode参数的取值可以是JFileChooser.FILES_ONLY、JFileChooser.DIRECTORIES_ONLY和JFileChooser.FILES_AND_DIRECTORIES之一。
   • int showOpenDialog(Component parent)
   • int showSaveDialog(Component parent)
   • int showDialog(Component parent,String approveButtonText)
     显示按钮标签为Open，Save或者approveButtonText字符串的对话框，并返回APPROVE_OPTION、CANCEL_OPTION（或者用户选择取消按钮或者离开了对话框）或者ERROR_OPTION（如果发生错误）。
   • File getSelectedFile()
   • File[] getSelectedFiles()
     获取用户选择的一个文件或多个文件（如果用户没有选择文件，返回null）。
   • void setFileFilter(FileFilter filter)
     设置文件对话框的文件过滤器。所有让filter.accept返回true的文件都会被显示，并且将过滤器添加到可选过滤器列表中。
   • void addChooseableFileFilter(FileFilter filter)
     将文件过滤器添加到可选过滤器列表中。
   • void setAcceptAllFileFilterUsed(boolean b)
     在过滤器组合框中包括或者取消All files过滤器。
   • void resetChoosableFileFilters()
     清除可选过滤器列表。除非All filtes过滤器被显式地清除，否则它仍然会存在。
   • void setFileView(FileView view)
     设置一个文件视图来提供文件选择器显示信息。
   • void setAccessory(JComponent component)
     设置一个附件组件。
10. javax.swing.fileCooser.FileFilter 1.2
    • boolean accept(File f)
      如果文件选择器可以显示这个文件，返回true。
    • String getDescription()
      返回这个文件过滤器的说明信息，例如，Image Fils(.gif,.jpeg)。
11. javax.swing.fileChooser.FileNameExtensionFiler 6
    • FileNameExtensFilter(String description,String… extensions)
      利用给定的描述构造一个文件过滤器。这些描述限定了被接收的所有目录和文件其名称结尾的句点之后所包含的扩展字符串。
12. javax.swing.filechooser.FileView 1.2
    • String getName(File f)
      返回文件f的文件名，或者null。通常这个方法返回f.getName()。
    • String getDescription(File f)
      返回文件f的可读性描述，或者null。例如，如果f是HTML文档，那么这个方法有可能返回它的标题。
    • String getTypeDescription(File f)
      返回文件f的类型的可读性描述。例如，如果f是HTML文档，那么这个方法有可能返回Hypertext document字符串。
    • Icon getIcon(File f)
      返回文件f的图标，或者null。例如，如果f是JPEG文件，那么这个方法有可能返回简略的图标。
    • Boolean isTraversable(File f)
      如果f是用户可以打开的目录，返回Boolean.TRUE。如果目录在概念上是符合文档，那么这个方法有可能返回false。与所有的FileView方法一样，这个方法有可能返回null，用于标示文件选择器应该使用默认视图。

12.7.5 颜色选择器

1. Swing还提供了一种选择器-JColorChooser。可以利用这个选择器选取颜色。与JFileChooser一样，颜色选择器也是一个组件，而不是一个对话框，但是它包含了用于创建包含颜色选择器组件的对话框方法。
2. 显示颜色选择器对话框，需要提供：
   • 一个父组件。
   • 对话框的标题。
   • 选择模式/无模式对话框的标志。
   • 颜色选择器。
   • OK和Cancel按钮的监听器。
3. javax.swing.JColorChooser 1.2
   • JColorChooser()
     构造一个初始颜色为白色的颜色选择器。
   • Color getColor()
   • void setColor(Color c)
     获取和设置颜色选择器的当前颜色。
   • static Color showDialog(Component parent,String title,Color initialColor)
     显示包含颜色选择器的模式对话框。
     参数：parent 对话框显示在上面的组件。 title 对话框框架的标题。 initialColor 颜色选择器的初始颜色。
   • static JDialog createDialog(Component parent,String title,boolean
     modal,JColorChooser chooser,ActionLstener okListener,ActionListener
     cancelListener)
     创建一个包含颜色选择器的对话框。
     参数：parent 对话框显示在上面的组件。title
     对话框框架的标题。modal 如果直到对话框关闭，这个调用都被阻塞，则返回true。chooser
     添加到对话框中的颜色选择器。okListener,cancelListener OK和Cancel按钮的监听器。

二、实验部分

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

实验代码如下：

package menu;

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

/**
 * @version 1.24 2012-06-12
 * @author Cay Horstmann
 */
public class MenuTest
{
   public static void main(String[] args)
   {
      EventQueue.invokeLater(() -> {
         JFrame 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
    */
   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);

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

      //演示加速器

      JMenuItem 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);
               saveAsAction.setEnabled(saveOk);
            }
         });

      ButtonGroup group = new ButtonGroup();

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

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

      //演示图标

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

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

      // 演示嵌套菜单

      JMenu optionMenu = new JMenu("Options");

      optionMenu.add(readonlyItem);
      optionMenu.addSeparator();
      optionMenu.add(insertItem);
      optionMenu.add(overtypeItem);

      editMenu.addSeparator();
      editMenu.add(optionMenu);

      // 说明助记符

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

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

      //您还可以向操作添加助记符键
      Action aboutAction = new TestAction("About");
      aboutAction.putValue(Action.MNEMONIC_KEY, new Integer('A'));
      helpMenu.add(aboutAction);

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

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

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

运行结果如下：

  

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

实验代码如下：

package toolBar;

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

/**
 * @version 1.14 2015-06-12
 * @author Cay Horstmann
 */
public class ToolBarTest
{
   public static void main(String[] args)
   {
      EventQueue.invokeLater(() -> {
         ToolBarFrame 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);
      // add a panel for color change
      panel = new JPanel();//创建新的JPanel
      add(panel, BorderLayout.CENTER);
      // set up actions
      //建立动作
      Action blueAction = new ColorAction("Blue", new ImageIcon("blue-ball.gif"), Color.BLUE);
      Action yellowAction = new ColorAction("Yellow", new ImageIcon("yellow-ball.gif"),
            Color.YELLOW);
      Action redAction = new ColorAction("Red", new ImageIcon("red-ball.gif"), Color.RED);
      Action exitAction = new AbstractAction("Exit", new ImageIcon("exit.gif"))
         {
            public void actionPerformed(ActionEvent event)
            {
               System.exit(0);
            }
         };
      exitAction.putValue(Action.SHORT_DESCRIPTION, "Exit");
      // populate toolbar
      JToolBar bar = new JToolBar();
      bar.add(blueAction);//用Action对象填充工具栏
      bar.add(yellowAction);
      bar.add(redAction);
      bar.addSeparator();//用分隔符将按钮分组
      bar.add(exitAction);
      add(bar, BorderLayout.NORTH);
      // populate menu
      JMenu menu = new JMenu("Color");//显示颜色的菜单
      menu.add(yellowAction);//在菜单添加颜色动作
      menu.add(blueAction);
      menu.add(redAction);
      menu.add(exitAction);
      JMenuBar 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(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分）

实验代码如下：

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

import javax.swing.*;

/**
 * A panel with radio buttons inside a titled border.
 */
public class ButtonPanel extends JPanel
{
   private ButtonGroup group;

   /**
    * Constructs a button panel.
    * @param title the title shown in the border
    * @param options an array of radio button labels
    */
   public ButtonPanel(String title, String... options)
   {
      setBorder(BorderFactory.createTitledBorder(BorderFactory.createEtchedBorder(), title));
      setLayout(new BoxLayout(this, BoxLayout.Y_AXIS));
      group = new ButtonGroup();

      // make one radio button for each option
      for (String option : options)
      {
         JRadioButton b = new JRadioButton(option);
         b.setActionCommand(option);
         add(b);
         group.add(b);
         b.setSelected(option == options[0]);
      }
   }

   /**
    * Gets the currently selected option.
    * @return the label of the currently selected radio button.
    */
   public String getSelection()
   {
      return group.getSelection().getActionCommand();
   }
}

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

      // add a panel with a Show button

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

      add(gridPanel, BorderLayout.CENTER);
      add(showPanel, BorderLayout.SOUTH);
      pack();
   }

   /**
    * Gets the currently selected message.
    * @return a string, icon, component, or object array, depending on the Message panel selection
    */
   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;
   }

   /**
    * Gets the currently selected options.
    * @return an array of strings, icons, or objects, depending on the Option panel selection
    */
   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;
   }

   /**
    * Gets the selected message or option type
    * @param panel the Message Type or Confirm panel
    * @return the selected XXX_MESSAGE or XXX_OPTION constant from the JOptionPane class
    */
   public int getType(ButtonPanel panel)
   {
      String s = panel.getSelection();
      try
      {
         return JOptionPane.class.getField(s).getInt(null);
      }
      catch (Exception e)
      {
         return -1;
      }
   }

   /**
    * The action listener for the Show button shows a Confirm, Input, Message, or Option dialog
    * depending on the Type panel selection.
    */
   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]);
      }
   }
}

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

class SampleComponent extends JComponent
{
   public void paintComponent(Graphics g)
   {
      Graphics2D g2 = (Graphics2D) g;
      Rectangle2D 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);
   }
}

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

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

         DialogFrame 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.
 */
public class DialogFrame extends JFrame
{
   private static final int DEFAULT_WIDTH = 300;   //常量的定义
   private static final int DEFAULT_HEIGHT = 200;
   private AboutDialog dialog;   //定义一个私有类AboutDialog

   public DialogFrame()    //DialogFrame构造器
   {
      setSize(DEFAULT_WIDTH, DEFAULT_HEIGHT);   //设置框架的大小为宽为DEFAULT_WIDTH、高为DEFAULT_HEIGHT的框架

      // construct a File menu

      JMenuBar menuBar = new JMenuBar();  //新建一个菜单栏类对象
      setJMenuBar(menuBar);
      JMenu fileMenu = new JMenu("File");  //新建一个菜单类对象fileMenu，File菜单
      menuBar.add(fileMenu);   //将菜单添加到菜单栏当中

      // add About and Exit menu items

      // the About item shows the About dialog

      JMenuItem aboutItem = new JMenuItem("About");   //新建一个About子菜单
      aboutItem.addActionListener(event -> {
         if (dialog == null) // first time
            dialog = new AboutDialog(DialogFrame.this);
         dialog.setVisible(true); // pop up dialog
      });
      fileMenu.add(aboutItem);   //将子菜单添加到fileMenu菜单当中

      // the Exit item exits the program

      JMenuItem exitItem = new JMenuItem("Exit");   //新建一个子菜单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;

/**
 * A sample modal dialog that displays a message and waits for the user to click
 * the OK button.
 */
public class AboutDialog extends JDialog
{
   public AboutDialog(JFrame owner)  //AboutDialog构造器，入口参数为JFrame类对象owner
   {
      super(owner, "About DialogTest", true);   //完成父类的构造

      // add HTML label to center

      add(
         new JLabel(
            "<html><h1><i>Core Java</i></h1><hr>By Cay Horstmann</html>"),
         BorderLayout.CENTER);
     //设置为边框布局管理方式，放置CENTER位置
      // OK button closes the dialog

      JButton ok = new JButton("OK");   //新建一个JButton类对象，OK按钮
      ok.addActionListener(event -> setVisible(false));
      //设置组件可见
      // add OK button to southern border

      JPanel panel = new JPanel();
      panel.add(ok);   //将ok按钮添加到面板上
      add(panel, BorderLayout.SOUTH);   //将面板添加到边框布局管理方式中的SOUTH位置

      pack();   //考虑首选组件的大小
   }
}

运行结果如下：

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

实验代码如下：

/**
 * @version 1.34 2015-06-12
 * @author Cay Horstmann
 */
public class DataExchangeTest
{
   public static void main(String[] args)
   {
      EventQueue.invokeLater(() -> {
         JFrame frame = new DataExchangeFrame();
         frame.setTitle("DataExchangeTest");
         frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
         frame.setVisible(true);
      });
   }
import java.awt.*import java.awt.event.*/* * 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()
   {

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

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

      // The Exit item exits the program

      JMenuItem 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 (dialog == null) dialog = new PasswordChooser();

         dialog.etUser(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());

      // construct a panel with user name and password fields

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

      // create Ok and Cancel buttons that terminate the dialog

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

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

      // add buttons to southern border

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

   /**
    * Sets the dialog defaults.
    * @param u the default user information
    */
   public void setUser(User u)
   {
      username.setText(u.getName());
   }

   /**
    * Gets the dialog entries.
    * @return a User object whose state represents the dialog entries
    */
   public User getUser()
   {
      return new User(username.getText(), password.getPassword());
   }

   /**
    * Show the chooser panel in a dialog
    * @param parent a component in the owner frame or null
    * @param title the dialog window title
    */
   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 first time, or if owner has changed, make new dialog

      if (dialog == null || dialog.getOwner() != owner)
      {
         dialog = new JDialog(owner, true);
         dialog.add(this);
         dialog.getRootPane().setDefaultButton(okButton);
         dialog.pack();
      }

      // set title and show dialog

      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.25 2015-06-12
 * @author Cay Horstmann
 */
public class FileChooserTest
{
   public static void main(String[] args)
   {
      EventQueue.invokeLater(() -> {
         JFrame frame = new ImageViewerFrame();
         frame.setTitle("FileChooserTest");
         frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
         frame.setVisible(true);
      });
   }
}

package fileChooser;

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

import javax.swing.*;

/**
 * A file chooser accessory that previews images.
 */
public class ImagePreviewer extends JLabel
{
   /**
    * Constructs an ImagePreviewer.
    * @param chooser the file chooser whose property changes trigger an image
    *        change in this previewer
    */
   public ImagePreviewer(JFileChooser chooser)
   {
      setPreferredSize(new Dimension(100, 100));
      setBorder(BorderFactory.createEtchedBorder());

      chooser.addPropertyChangeListener(event -> {
         if (event.getPropertyName() == JFileChooser.SELECTED_FILE_CHANGED_PROPERTY)
         {
            // the user has selected a new file
            File f = (File) event.getNewValue();
            if (f == null)
            {
               setIcon(null);
               return;
            }

            // read the image into an icon
            ImageIcon icon = new ImageIcon(f.getPath());

            // if the icon is too large to fit, scale it
            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 frame that has a menu for loading an image and a display area for the
 * loaded image.
 */
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);

      // set up menu bar
      JMenuBar menuBar = new JMenuBar();
      setJMenuBar(menuBar);

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

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

         // show file chooser dialog
            int result = chooser.showOpenDialog(ImageViewerFrame.this);

            // if image file accepted, set it as icon of the label
            if (result == JFileChooser.APPROVE_OPTION)
            {
               String name = chooser.getSelectedFile().getPath();
               label.setIcon(new ImageIcon(name));
               pack();
            }
         });

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

      // use a label to display the images
      label = new JLabel();
      add(label);

      // set up file chooser
      chooser = new JFileChooser();

      // accept all image files ending with .jpg, .jpeg, .gif
      FileFilter 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")));
   }
}

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

实验代码如下：

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);
   }
   /**
    * This listener pops up a modal color chooser
    */
   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);
      }
   }
   /**
    * This listener pops up a modeless color chooser. The panel color is changed when the user
    * clicks the OK button.
    */
   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);
      }
   }
   /**
    * This listener pops up a modeless color chooser. The panel color is changed immediately when
    * the user picks a new color.
    */
   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 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);
      // add color chooser panel to frame
      ColorChooserPanel panel = new ColorChooserPanel();
      add(panel);
   }
}

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();//生成ColorChooserFrame类
         frame.setTitle("ColorChooserTest");
         frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);//关闭界面操作
         frame.setVisible(true);
      });
   }
}

三：实验总结。

这一周学习了Swing用户界面组件以及GUI相关组件。在学习过程中，自己对理论知识的学习学的比较混乱，混淆了这几部分的学习内容。另外，对于本周的实验，实验都有很多相同和类似的地方，在实验过程中任然没有理解的太清楚。在查了课本上的内容之后，稍微有了掌握。此外，通过小组协作进行实验，结合两个人对实验的理解，相比独自完成试验，在互相学习中有了更好的理解和掌握。