201871010105-曹玉中《面向对象程序设计（java）》第十五周学习总结

  • Z时代
  • 2024-01-10
  • 分类：综合

java

201871010105-曹玉中《面向对象程序设计（java）》第十五周学习总结

项目内容
这个作业属于哪个过程https://www.cnblogs.com/nwnu-daizh/
这个作业的要求在哪里https://www.cnblogs.com/zyja/p/11963340.html
作业学习目标

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

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

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

第一部分：理论知识。

 菜单

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

菜单创建

  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)
      为这个框架设置菜单栏。

菜单项中的图标

  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)
      用给定的名字和图标构造一个抽象的动作。

 复选框和单选按钮菜单项

  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为选定）。

弹出菜单

  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，则应用上一级弹出菜单。

快捷键和加速器

  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字符设定为带下划线。如果不希望第一个出现的快捷键字符带下划线，就可以使用这个方法。

启用和禁用菜单项

  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)
      当菜单被取消时被调用。例如，用户单击菜单以外的区域。

工具栏

  1. 工具栏是在程序中提供的快速访问常用命令的按钮栏。

  2. 工具栏的特殊之处在于可以将它随处移动。可以将它拖拽到框架的四个边框上。

  3. 工具栏只有位于采用边框布局或者任何支持North、East、South和Weat约束布局管理器的容器内才能够被拖拽。

  4. 工具栏可以完全脱离框架。这样的工具栏将包含在自己的框架中。当关闭包含工具栏的框架时，它会回到原始的框架中。

工具提示

  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)
      设置当鼠标停留在组件上时显示在工具提示中的文本。

复杂的布局管理

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

 网格组布局

  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建议这个构造器只用在自动代码生成器只用在自动生成器中，因为它会使得代码非常难于阅读。

组布局

  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。

不使用布局管理器

  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 组件新的尺寸。

 定制布局管理器

  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)
      摆放容器内的组件。

遍历顺序

  1. 当把很多组件添加到窗口中时，需要考虑遍历顺序（traversal order）的问题。

  2. 调用compnent.setFocusable(false);可以从焦点遍历中删除一个组件。这对于不接受键盘输入、自行绘制的组件很有用。

对话框

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

  2. Swing有一个很容易使用的类JOptionPane，它可以弹出一个简单的对话框，而不必编写任何对话框的相关代码。

选项对话框

  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 呈现给用户的默认值。

创建对话框

  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代表模式对话框（模式对话框阻塞其他窗口的输入）。

数据交换

  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。

 文件对话框

  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，用于标示文件选择器应该使用默认视图。

第二部分：实验。

测试程序1

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

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

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

代码如下：

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(() -> {
         MenuFrame 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"));
      // demonstrate accelerators
      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);
            }
         });
      // demonstrate checkbox and radio button menus
      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);
      // demonstrate icons
      TestAction cutAction = new TestAction("Cut");
      cutAction.putValue(Action.SMALL_ICON, new ImageIcon("cut.gif"));
      TestAction copyAction = new TestAction("Copy");
      copyAction.putValue(Action.SMALL_ICON, new ImageIcon("copy.gif"));
      TestAction 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);
      // demonstrate nested menus
      JMenu optionMenu = new JMenu("Options");
      optionMenu.add(readonlyItem);
      optionMenu.addSeparator();
      optionMenu.add(insertItem);
      optionMenu.add(overtypeItem);
      editMenu.addSeparator();
      editMenu.add(optionMenu);
      // demonstrate mnemonics
      JMenu helpMenu = new JMenu("Help");
      helpMenu.setMnemonic('H');
      JMenuItem indexItem = new JMenuItem("Index");
      indexItem.setMnemonic('I');
      helpMenu.add(indexItem);
      // you can also add the mnemonic key to an action
      TestAction aboutAction = new TestAction("About");
      aboutAction.putValue(Action.MNEMONIC_KEY, new Integer('A'));
      helpMenu.add(aboutAction);
      // add all top-level menus to menu bar
      JMenuBar menuBar = new JMenuBar();
      setJMenuBar(menuBar);
      menuBar.add(fileMenu);
      menuBar.add(editMenu);
      menuBar.add(helpMenu);
      // demonstrate pop-ups
      popup = new JPopupMenu();
      popup.add(cutAction);
      popup.add(copyAction);
      popup.add(pasteAction);
      JPanel panel = new JPanel();
      panel.setComponentPopupMenu(popup);
      add(panel);
   }
}

运行结果如下：

测试程序2

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

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

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

代码如下：

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(() -> {
         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();
      add(panel, BorderLayout.CENTER);
      // set up actions
      ColorAction blueAction = new ColorAction("Blue", new ImageIcon("blue-ball.gif"), Color.BLUE);
      ColorAction yellowAction = new ColorAction("Yellow", new ImageIcon("yellow-ball.gif"),
            Color.YELLOW);
      ColorAction redAction = new ColorAction("Red", new ImageIcon("red-ball.gif"), Color.RED);
      AbstractAction 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);
      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);
      }
   }
}

运行结果如下：

测试程序3

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

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

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

代码如下：

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(() -> {
         OptionDialogFrame 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.awt.geom.Rectangle2D.Double;
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;
      Double 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);
   }
}

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 button = new JRadioButton(option);
         button.setActionCommand(option);
         add(button);
         group.add(button);
         button.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();
   }
}

运行结果如下：

测试程序4

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

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

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

代码如下：

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.
 */
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);
      // construct a File menu
      var menuBar = new JMenuBar();
      setJMenuBar(menuBar);
      var fileMenu = new JMenu("File");
      menuBar.add(fileMenu);
      // add About and Exit menu items
      // the About item shows the About dialog
      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);
      // the Exit item exits the program
      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;
/**
 * 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)
   {
      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);
      // OK button closes the dialog
      var ok = new JButton("OK");
      ok.addActionListener(event -> setVisible(false));
      // add OK button to southern border
      var panel = new JPanel();
      panel.add(ok);
      add(panel, BorderLayout.SOUTH);
      pack();
   }
}

运行结果如下：

测试程序5

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

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

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

代码如下：

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()
   {
      // construct a File menu
      var mbar = new JMenuBar();
      setJMenuBar(mbar);
      var fileMenu = new JMenu("File");
      mbar.add(fileMenu);
      // add Connect and Exit menu items
      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();
   }
   /**
    * The Connect action pops up the password dialog.
    */
   private class ConnectAction implements ActionListener
   {
      public void actionPerformed(ActionEvent event)
      {
         // if first time, construct dialog
         if (dialog == null) dialog = new PasswordChooser();
         // set default values
         dialog.setUser(new User("yourname", null));
         // pop up dialog
         if (dialog.showDialog(DataExchangeFrame.this, "Connect"))
         {
            // if accepted, retrieve user input
            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
      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);
      // create Ok and Cancel buttons that terminate the dialog
      okButton = new JButton("Ok");
      okButton.addActionListener(event -> {
         ok = true;
         dialog.setVisible(false);
      });
      var cancelButton = new JButton("Cancel");
      cancelButton.addActionListener(event -> dialog.setVisible(false));
      // add buttons to southern border
      var 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;
   }
}

运行结果如下：

测试程序6

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

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

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

代码如下：

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;
/**
 * 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;
   /**
    * Constructs a FileIconView.
    * @param aFilter a file filter--all files that this filter accepts will be shown 
    * with the icon.
    * @param anIcon--the icon shown with all accepted files.
    */
   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 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
            var 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
      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("."));
         // 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();
            }
         });
      var 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
      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")));
   }
}

运行结果如下：

测试程序7

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

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

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

代码如下：

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 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);
      // 添加颜色选择器面板到框架
      ColorChooserPanel panel = new ColorChooserPanel();
      add(panel);
   }
}

运行结果如下：

第三部分：实验总结。

       本周学习的内容依然是Swing用户界面组件的部分内容，本章的内容较散较多，容易混淆，所以在学习的时候学的一片混乱，好在课下通过看书

和在Mooc上 看翁凯老师的课才对本章内容有了一定的了解，但还需要再做一些练习才能够掌握本章内容的精髓，由于本周的实验都是验证性实验，

所以在做实验部分内容的时候，并没有遇到很多困难，同时体验到了本章实验内容的重要。

以上是 201871010105-曹玉中《面向对象程序设计（java）》第十五周学习总结 的全部内容， 来源链接： utcz.com/z/389646.html

回到顶部