201771010113 李婷华《面向对象程序设计（java）》

阅读原文时间：2021年04月26日阅读：1

一.理论知识部分

设计模式（Design pattern）是设计者一种流行的思考设计问题的方法，是一套被反复使用，多数人知晓的，经过分类编目的，代码设计经验的总结。使用设计模式是为了可重用代码、让代码更容易被他人理解、保证代码可靠性。每一个模式描述了一个不断重复发生的设计问题，以及该问题的核心解决方案

模型-视图-控制器设计模式(Model –ViewController )是Java EE平台下创建 Web 应用程序的重要设计模式。

MVC设计模式 – Model（模型）：是程序中用于处理程序数据逻辑的部分，通常模型负责在数据库中存取数据。– View（视图）：是程序中处理数据显示的部分，通常视图依据模型存取的数据创建。 – Controller（控制器）：是程序中处理用户交互的部分。通常控制器负责从视图读取数据，控制用户输入，并向模型发送数据。

MVC模式可应用于Java的GUI组件设计中。MVC模式GUI组件设计的唯一的模式，还有很多设计的模式（设计方法）。

Java组件有内容、外观、行为三个主要元素；这三个主要元素与模型—视图—控制器模式的三部件的对应关系为：内容——控制器（作用：处理用户输入）外观——视图（作用：显示内容）行为——模型（作用：存储内容）

布局管理器是一组类。实现 java.awt.LayoutManager 接口；决定容器中组件的位置和大小

Java.awt包中定义了5种布局管理类，每一种布局管理类对应一种布局策略。每个容器都有与之相关的默认布局管理器。当一个容器选定一种布局策略时，它应该创建该策略对应的布局管理器对象，并将此对象设置为自己的布局管理器。

5种布局管理器：（1）FlowLayout:流布局(Applet和Panel的默认布局管理器）（2）BorderLayout：边框布局( Window、Frame和Dialog的默认布局管理器）（3）GridLayout:网格布局（4）GridBagLayout: 网格组布局（5）CardLayout :卡片布局

FlowLayout Manager 组件采用从左到右，从上到下逐行摆放。

GridBagLayout不需要组件的尺寸一致，容许组件扩展到多行、多列。

文本输入

（1）文本域(JTextField) : 用于获取单行文本输入。

（2）文本区（JTextArea）组件可让用户输入多行文本。生成JTextArea组件对象时，可以指定文本区的行数和列数： textArea = new JTextArea(8, 40);

(3)文本区与文本域的异同相同之处：文本域和文本区组件都可用于获取文本输入。

不同之处：  文本域只能接受单行文本的输入；  文本区能够接受多行文本的输入。

(4)文本区JTextArea的常用API：Java.swing. JTextArea 1.2 – JTextArea(int rows, int cols)

构造一个rows行cols列的文本区对象 – JTextArea(String text，int rows, int cols)

用初始文本构造一个文本区对象 – void setRows(int rows)

设置文本域使用的行数 – void append(String newText)

将给定文本附加到文本区中已有文本的后面 – void setLineWrap(boolean wrap)

打开或关闭换行

（5）标签组件：标签是容纳文本的组件。它们没有任何修饰（如没有边界），也不响应用户输入。

 标签的常用用途之一就是标识组件，例如标识文本域。

二.实验部分

1、实验目的与要求

(1) 掌握GUI布局管理器用法；

(2) 掌握各类Java Swing组件用途及常用API；

2、实验内容和步骤

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

测试程序1

l 在elipse IDE中运行教材479页程序12-1，结合运行结果理解程序；

l 掌握各种布局管理器的用法；

l 理解GUI界面中事件处理技术的用途。

l 在布局管理应用代码处添加注释；

package calculator;

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

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

Calculator

package calculator;

import javax.swing.*;

/**
* A frame with a calculator panel.
*/
public class CalculatorFrame extends JFrame
{
public CalculatorFrame()
{
add(new CalculatorPanel());
pack();
}
}

CalculatorFrame

package calculator;

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

/**
* A panel with calculator buttons and a result display.
*/
public class CalculatorPanel extends JPanel
{
private JButton display;
private JPanel panel;
private double result;
private String lastCommand;
private boolean start;

public CalculatorPanel()//生产GUI的组件写在构造器中
{
setLayout(new BorderLayout());

  result = 0;  
  lastCommand = "=";  
  start = true;

  // add the display

  display = new JButton("0");//初始化的Label值，完成计算结果的显示内容  
  display.setEnabled(false);//定义为flase，计算结果不能更改，仅具有显示功能  
  add(display, BorderLayout.NORTH);//显示在最上方

  ActionListener insert = new InsertAction();  
  ActionListener command = new CommandAction();

  // add the buttons in a 4 x 4 grid

  panel = new JPanel();//panel是一个容器组件  
  panel.setLayout(new GridLayout(4, 4));//设置一个4\*4的网格布局管理器

  addButton("0", insert);//  
  addButton("1", insert);  
  addButton("2", insert);  
  addButton("/", command);

  addButton("3", insert);  
  addButton("4", insert);  
  addButton("5", insert);  
  addButton("\*", command);

  addButton("6", insert);  
  addButton("7", insert);  
  addButton("8", insert);  
  addButton("-", command);

  addButton("9", insert);  
  addButton(".", insert);  
  addButton("=", command);  
  addButton("+", command);

  add(panel, BorderLayout.CENTER);

  /\*JButton b1=new JButton("验证");  
  add(b1,BorderLayout.SOUTH);

  JButton bl=new JButton("验证 1");  
  add(bl,BorderLayout.WEST);  
  JButton br=new JButton("验证2");  
  add(br,BorderLayout.EAST);\*/

}

/**
* Adds a button to the center panel.
* @param label the button label
* @param listener the button listener
*/
private void addButton(String label, ActionListener listener)
{
JButton button = new JButton(label);
button.addActionListener(listener);//将一个监听器添加到按钮中
panel.add(button);//将button添加到panel组件上
}

/**
* This action inserts the button action string to the end of the display text.
*/
private class InsertAction implements ActionListener//实现了一个监听器接口
{
public void actionPerformed(ActionEvent event)
{
String input = event.getActionCommand();
if (start)
{
display.setText("");
start = false;
}
display.setText(display.getText() + input);
}
}

/**
* This action executes the command that the button action string denotes.
*/
private class CommandAction implements ActionListener
{
public void actionPerformed(ActionEvent event)
{
String command = event.getActionCommand();//发出动作上的label

     if (start)  
     {  
        if (command.equals("-"))  
        {  
           display.setText(command);//setTest在display上显示“-”  
           start = false;  
        }  
        else lastCommand = command;  
     }  
     else  
     {  
        calculate(Double.parseDouble(display.getText()));//通过parseDouble转换成数字  
        lastCommand = command;  
        start = true;  
     }  
  }

}

/**
* Carries out the pending calculation.
* @param x the value to be accumulated with the prior result.
*/
public void calculate(double x)
{
if (lastCommand.equals("+")) result += x;
else if (lastCommand.equals("-")) result -= x;
else if (lastCommand.equals("*")) result *= x;
else if (lastCommand.equals("/")) result /= x;
else if (lastCommand.equals("=")) result = x;
display.setText("" + result);//进行字符串的转换
}
}

CalculatorPanel

测试程序2

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

l 掌握各种文本组件的用法；

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

package text;

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

/**
* @version 1.41 2015-06-12
* @author Cay Horstmann
*/
public class TextComponentTest
{
public static void main(String[] args)
{
EventQueue.invokeLater(() -> {
JFrame frame = new TextComponentFrame();//生成 TextComponentFrame类的GUI界面对象
frame.setTitle("TextComponentTest");
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);//关闭界面的按钮操作
frame.setVisible(true);//使结果可见
});
}
}

TextComponentTest

package text;

import java.awt.BorderLayout;
import java.awt.GridLayout;

import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JPanel;
import javax.swing.JPasswordField;
import javax.swing.JScrollPane;
import javax.swing.JTextArea;
import javax.swing.JTextField;
import javax.swing.SwingConstants;

/**
* A frame with sample text components.
*/
public class TextComponentFrame extends JFrame
{ //定义网格的行数、列数
public static final int TEXTAREA_ROWS = 8;
public static final int TEXTAREA_COLUMNS = 20;

public TextComponentFrame()
{
JTextField textField = new JTextField();//创建一个新的文本域
JPasswordField passwordField = new JPasswordField();

  JPanel northPanel = new JPanel();//构造一个JPanel组件  
  northPanel.setLayout(new GridLayout(2, 2));//设置布局管理器  
  northPanel.add(new JLabel("User name: ", SwingConstants.RIGHT));//指定右对齐标签  
  northPanel.add(textField);  
  northPanel.add(new JLabel("Password: ", SwingConstants.RIGHT));  
  northPanel.add(passwordField);

  add(northPanel, BorderLayout.NORTH);//add方法

  JTextArea textArea = new JTextArea(TEXTAREA\_ROWS, TEXTAREA\_COLUMNS);  
  JScrollPane scrollPane = new JScrollPane(textArea);

  add(scrollPane, BorderLayout.CENTER);

  // add button to append text into the text area

  JPanel southPanel = new JPanel();

  JButton insertButton = new JButton("Insert");  
  southPanel.add(insertButton);  
  insertButton.addActionListener(event ->  
     textArea.append("User name: " + textField.getText() + " Password: "  
        + new String(passwordField.getPassword()) + "\\n"));

  add(southPanel, BorderLayout.SOUTH);  
  pack();

}
}

TextComponentFrame

测试程序3

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

l 掌握复选框组件的用法；

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

package checkBox;

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

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

CheckBoxTest

package checkBox;

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

/**
* A frame with a sample text label and check boxes for selecting font attributes.
*/
public class CheckBoxFrame extends JFrame
{
private JLabel label;
private JCheckBox bold;
private JCheckBox italic;
private static final int FONTSIZE = 24;

public CheckBoxFrame()
{
// 添加示例文本标签

  label = new JLabel("The quick brown fox jumps over the lazy dog.");  
  label.setFont(new Font("Serif", Font.BOLD, FONTSIZE));  
  add(label, BorderLayout.CENTER);

  // 字体属性  
  // 复选框状态的标签

  ActionListener listener = event -> {  
     int mode = 0;  
     if (bold.isSelected()) mode += Font.BOLD;  
     if (italic.isSelected()) mode += Font.ITALIC;  
     label.setFont(new Font("Serif", mode, FONTSIZE));  
  };

  // 添加复选框

  JPanel buttonPanel = new JPanel();

  bold = new JCheckBox("Bold");  
  bold.addActionListener(listener);  
  bold.setSelected(true);  
  buttonPanel.add(bold);

  italic = new JCheckBox("Italic");  
  italic.addActionListener(listener);  
  buttonPanel.add(italic);

  add(buttonPanel, BorderLayout.SOUTH);  
  pack();

}
}

CheckBoxFrame

测试程序4

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

l 掌握单选按钮组件的用法；

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

package radioButton;

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

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

RadioButtonTest

package radioButton;

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

/**
* A frame with a sample text label and radio buttons for selecting font sizes.
*/
public class RadioButtonFrame extends JFrame//单选按钮
{ //定义四个私有属性
private JPanel buttonPanel;
private ButtonGroup group;
private JLabel label;
private static final int DEFAULT_SIZE = 36;

public RadioButtonFrame()
{
// add the sample text label

  label = new JLabel("The quick brown fox jumps over the lazy dog.");  
  label.setFont(new Font("Serif", Font.PLAIN, DEFAULT\_SIZE));//设置新字体  
  add(label, BorderLayout.CENTER);

  // add the radio buttons

  buttonPanel = new JPanel();  
  group = new ButtonGroup();  
 //添加单选框按钮  
  addRadioButton("Small", 8);  
  addRadioButton("Medium", 12);  
  addRadioButton("Large", 18);  
  addRadioButton("Extra large", 36);

  add(buttonPanel, BorderLayout.SOUTH);  
  pack();//调整窗口的大小

}

/**
* Adds a radio button that sets the font size of the sample text.
* @param name the string to appear on the button
* @param size the font size that this button sets
*/
public void addRadioButton(String name, int size)
{
boolean selected = size == DEFAULT_SIZE;//布尔类型，大小的定义
JRadioButton button = new JRadioButton(name, selected);
group.add(button);
buttonPanel.add(button);

  // this listener sets the label font size  
  //这个监听器设置标签字体大小

  ActionListener listener = event -> label.setFont(new Font("Serif", Font.PLAIN, size));//表明新的字体，大小

  button.addActionListener(listener);

}
}

RadioButtonFrame

测试程序5

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

l 掌握边框的用法；

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

package border;

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

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

BorderTest

package border;

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

/**
* A frame with radio buttons to pick a border style.
*/
public class BorderFrame extends JFrame
{
private JPanel demoPanel;
private JPanel buttonPanel;
private ButtonGroup group;

public BorderFrame()
{
demoPanel = new JPanel();
buttonPanel = new JPanel();
group = new ButtonGroup();

  //设置不同的边框类型按钮，共六种（提供标准 Border 对象的工厂类）  
  addRadioButton("Lowered bevel", BorderFactory.createLoweredBevelBorder());  
  addRadioButton("Raised bevel", BorderFactory.createRaisedBevelBorder());  
  addRadioButton("Etched", BorderFactory.createEtchedBorder());  
  addRadioButton("Line", BorderFactory.createLineBorder(Color.BLUE));  
  addRadioButton("Matte", BorderFactory.createMatteBorder(10, 10, 10, 10, Color.BLUE));  
  addRadioButton("Empty", BorderFactory.createEmptyBorder());

  Border etched = BorderFactory.createEtchedBorder();  
  Border titled = BorderFactory.createTitledBorder(etched, "Border types");  
  buttonPanel.setBorder(titled);

  setLayout(new GridLayout(2, 1));  
  add(buttonPanel);  
  add(demoPanel);  
  pack();

}

public void addRadioButton(String buttonName, Border b)
{
JRadioButton button = new JRadioButton(buttonName);
button.addActionListener(event -> demoPanel.setBorder(b));
group.add(button);
buttonPanel.add(button);
}
}

BorderFrame

测试程序6

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

l 掌握组合框组件的用法；

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

package comboBox;

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

/**
* @version 1.35 2015-06-12
* @author Cay Horstmann
*/
public class ComboBoxTest
{
public static void main(String[] args)
{

  EventQueue.invokeLater(() -> {

     JFrame frame = new ComboBoxFrame();

     frame.setTitle("ComboBoxTest");

    frame.setDefaultCloseOperation(JFrame.EXIT\_ON\_CLOSE);

     frame.setVisible(true);  
  });

}
}

ComboBoxTest

package comboBox;

import java.awt.BorderLayout;
import java.awt.Font;

import javax.swing.JComboBox;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JPanel;

/**
* A frame with a sample text label and a combo box for selecting font faces.
*/
public class ComboBoxFrame extends JFrame
{
private JComboBox faceCombo;//定义组合框面
private JLabel label;//定义标签
private static final int DEFAULT_SIZE = 24;

public ComboBoxFrame()
{
// add the sample text label

  label = new JLabel("The quick brown fox jumps over the lazy dog.");  
  label.setFont(new Font("Serif", Font.PLAIN, DEFAULT\_SIZE));//设置组件的字体  
  add(label, BorderLayout.CENTER);

  // make a combo box and add face names  
  //调用addItem方法添加选项  
  faceCombo = new JComboBox<>();  
  faceCombo.addItem("Serif");  
  faceCombo.addItem("SansSerif");  
  faceCombo.addItem("Monospaced");  
  faceCombo.addItem("Dialog");  
  faceCombo.addItem("DialogInput");

  // the combo box listener changes the label font to the selected face name

  faceCombo.addActionListener(event ->//组合框产生一个动作事件  
     label.setFont(  
        new Font(faceCombo.getItemAt(faceCombo.getSelectedIndex()),  
           Font.PLAIN, DEFAULT\_SIZE)));

  // add combo box to a panel at the frame's southern border

  JPanel comboPanel = new JPanel();  
  comboPanel.add(faceCombo);  
  add(comboPanel, BorderLayout.SOUTH);  
  pack();

}
}

ComboBoxFrame

测试程序7

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

l 掌握滑动条组件的用法；

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

package slider;

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

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

SliderTest

package slider;

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

/**
* A frame with many sliders and a text field to show slider values.
*/
public class SliderFrame extends JFrame {
private JPanel sliderPanel;
private JTextField textField;
private ChangeListener listener;

public SliderFrame() {  
    sliderPanel = new JPanel();  
    sliderPanel.setLayout(new GridBagLayout());

    // common listener for all sliders  
    listener = event -> {  
        // update text field when the slider value changes  
        JSlider source = (JSlider) event.getSource();  
        textField.setText("" + source.getValue());  
    };

    // add a plain slider

    JSlider slider = new JSlider();  
    addSlider(slider, "Plain");

    // add a slider with major and minor ticks

    slider = new JSlider();  
    slider.setPaintTicks(true);  
    slider.setMajorTickSpacing(20);  
    slider.setMinorTickSpacing(5);  
    addSlider(slider, "Ticks");

    // add a slider that snaps to ticks

    slider = new JSlider();  
    slider.setPaintTicks(true);  
    slider.setSnapToTicks(true);  
    slider.setMajorTickSpacing(20);  
    slider.setMinorTickSpacing(5);  
    addSlider(slider, "Snap to ticks");

    // add a slider with no track

    slider = new JSlider();  
    slider.setPaintTicks(true);  
    slider.setMajorTickSpacing(20);  
    slider.setMinorTickSpacing(5);  
    slider.setPaintTrack(false);  
    addSlider(slider, "No track");

    // add an inverted slider

    slider = new JSlider();  
    slider.setPaintTicks(true);  
    slider.setMajorTickSpacing(20);  
    slider.setMinorTickSpacing(5);  
    slider.setInverted(true);  
    addSlider(slider, "Inverted");

    // add a slider with numeric labels

    slider = new JSlider();  
    slider.setPaintTicks(true);  
    slider.setPaintLabels(true);  
    slider.setMajorTickSpacing(20);  
    slider.setMinorTickSpacing(5);  
    addSlider(slider, "Labels");

    // add a slider with alphabetic labels

    slider = new JSlider();  
    slider.setPaintLabels(true);  
    slider.setPaintTicks(true);  
    slider.setMajorTickSpacing(20);  
    slider.setMinorTickSpacing(5);

    Dictionary<Integer, Component> labelTable = new Hashtable<>();  
    labelTable.put(0, new JLabel("A"));  
    labelTable.put(20, new JLabel("B"));  
    labelTable.put(40, new JLabel("C"));  
    labelTable.put(60, new JLabel("D"));  
    labelTable.put(80, new JLabel("E"));  
    labelTable.put(100, new JLabel("F"));

    slider.setLabelTable(labelTable);  
    addSlider(slider, "Custom labels");

    // add a slider with icon labels

    slider = new JSlider();  
    slider.setPaintTicks(true);// 显示标记  
    slider.setPaintLabels(true);// 确定是否在滑块上绘制标签  
    slider.setSnapToTicks(true);// 最靠近用户放置滑块处的刻度标记的值  
    slider.setMajorTickSpacing(20);// 大标尺标记  
    slider.setMinorTickSpacing(20);// 小标尺标记

    labelTable = new Hashtable<Integer, Component>();

    // add card images

    labelTable.put(0, new JLabel(new ImageIcon("nine.gif")));  
    labelTable.put(20, new JLabel(new ImageIcon("ten.gif")));  
    labelTable.put(40, new JLabel(new ImageIcon("jack.gif")));  
    labelTable.put(60, new JLabel(new ImageIcon("queen.gif")));  
    labelTable.put(80, new JLabel(new ImageIcon("king.gif")));  
    labelTable.put(100, new JLabel(new ImageIcon("ace.gif")));

    slider.setLabelTable(labelTable);  
    addSlider(slider, "Icon labels");

    // add the text field that displays the slider value

    textField = new JTextField();  
    add(sliderPanel, BorderLayout.CENTER);  
    add(textField, BorderLayout.SOUTH);  
    pack();  
}

/\*\*  
 \* Adds a slider to the slider panel and hooks up the listener  
 \*  
 \* @param s           the slider  
 \* @param description the slider description  
 \*/  
public void addSlider(JSlider s, String description) {  
    s.addChangeListener(listener);  
    JPanel panel = new JPanel();  
    panel.add(s);  
    panel.add(new JLabel(description));  
    panel.setAlignmentX(Component.LEFT\_ALIGNMENT);  
    GridBagConstraints gbc = new GridBagConstraints();  
    gbc.gridy = sliderPanel.getComponentCount();  
    gbc.anchor = GridBagConstraints.WEST;  
    sliderPanel.add(panel, gbc);  
}

}

SliderFrame

测试程序8

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

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

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

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

MenuTest

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

}

MenuFrame

测试程序9

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

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

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

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

ToolBarTest

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

}
}

ToolBarFrame

测试程序10

l 在elipse IDE中调试运行教材524页程序12-10、12-11，结合运行结果理解程序，了解GridbagLayout的用法。

l 在elipse IDE中调试运行教材533页程序12-12，结合程序运行结果理解程序，了解GroupLayout的用法。

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

package gridbag;

import java.awt.EventQueue;

import javax.swing.JFrame;

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

GridBagLayoutTest

package gridbag;

import java.awt.Font;
import java.awt.GridBagLayout;
import java.awt.event.ActionListener;

import javax.swing.BorderFactory;
import javax.swing.JCheckBox;
import javax.swing.JComboBox;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JTextArea;

/**
* A frame that uses a grid bag layout to arrange font selection components.
*/
public class FontFrame extends JFrame
{
public static final int TEXT_ROWS = 10;
public static final int TEXT_COLUMNS = 20;

private JComboBox face;
private JComboBox size;
private JCheckBox bold;
private JCheckBox italic;
private JTextArea sample;

public FontFrame()
{
GridBagLayout layout = new GridBagLayout();
setLayout(layout);

  ActionListener listener = event -> updateSample();

  // 构建组件

  JLabel faceLabel = new JLabel("Face: ");

  face = new JComboBox<>(new String\[\] { "Serif", "SansSerif", "Monospaced",  
        "Dialog", "DialogInput" });

  face.addActionListener(listener);

  JLabel sizeLabel = new JLabel("Size: ");

  size = new JComboBox<>(new Integer\[\] { 8, 10, 12, 15, 18, 24, 36, 48 });

  size.addActionListener(listener);

  bold = new JCheckBox("Bold");  
  bold.addActionListener(listener);

  italic = new JCheckBox("Italic");  
  italic.addActionListener(listener);

  sample = new JTextArea(TEXT\_ROWS, TEXT\_COLUMNS);  
  sample.setText("The quick brown fox jumps over the lazy dog");  
  sample.setEditable(false);  
  sample.setLineWrap(true);  
  sample.setBorder(BorderFactory.createEtchedBorder());

  // 使用GBC便利类向网格添加组件

  add(faceLabel, new GBC(0, 0).setAnchor(GBC.EAST));  
  add(face, new GBC(1, 0).setFill(GBC.HORIZONTAL).setWeight(100, 0)  
        .setInsets(1));  
  add(sizeLabel, new GBC(0, 1).setAnchor(GBC.EAST));  
  add(size, new GBC(1, 1).setFill(GBC.HORIZONTAL).setWeight(100, 0)  
        .setInsets(1));  
  add(bold, new GBC(0, 2, 2, 1).setAnchor(GBC.CENTER).setWeight(100, 100));  
  add(italic, new GBC(0, 3, 2, 1).setAnchor(GBC.CENTER).setWeight(100, 100));  
  add(sample, new GBC(2, 0, 1, 4).setFill(GBC.BOTH).setWeight(100, 100));  
  pack();  
  updateSample();

}

public void updateSample()
{
String fontFace = (String) face.getSelectedItem();
int fontStyle = (bold.isSelected() ? Font.BOLD : 0)
+ (italic.isSelected() ? Font.ITALIC : 0);
int fontSize = size.getItemAt(size.getSelectedIndex());
Font font = new Font(fontFace, fontStyle, fontSize);
sample.setFont(font);
sample.repaint();
}

FontFrame

package gridbag;

import java.awt.*;

/**
* This class simplifies the use of the GridBagConstraints class.
*
* @version 1.01 2004-05-06
* @author Cay Horstmann
*/
public class GBC extends GridBagConstraints {
/**
* Constructs a GBC with a given gridx and gridy position and all other grid bag
* constraint values set to the default.
*
* @param gridx the gridx position
* @param gridy the gridy position
*/
public GBC(int gridx, int gridy) {
this.gridx = gridx;
this.gridy = gridy;
}

/\*\*  
 \* Constructs a GBC with given gridx, gridy, gridwidth, gridheight and all other  
 \* grid bag constraint values set to the default.  
 \*  
 \* @param gridx      the gridx position  
 \* @param gridy      the gridy position  
 \* @param gridwidth  the cell span in x-direction  
 \* @param gridheight the cell span in y-direction  
 \*/  
public GBC(int gridx, int gridy, int gridwidth, int gridheight) {  
    this.gridx = gridx;  
    this.gridy = gridy;  
    this.gridwidth = gridwidth;  
    this.gridheight = gridheight;  
}

/\*\*  
 \* Sets the anchor.  
 \*  
 \* @param anchor the anchor value  
 \* @return this object for further modification  
 \*/  
public GBC setAnchor(int anchor) {  
    this.anchor = anchor;  
    return this;  
}

/\*\*  
 \* Sets the fill direction.  
 \*  
 \* @param fill the fill direction  
 \* @return this object for further modification  
 \*/  
public GBC setFill(int fill) {  
    this.fill = fill;  
    return this;  
}

/\*\*  
 \* Sets the cell weights.  
 \*  
 \* @param weightx the cell weight in x-direction  
 \* @param weighty the cell weight in y-direction  
 \* @return this object for further modification  
 \*/  
public GBC setWeight(double weightx, double weighty) {  
    this.weightx = weightx;  
    this.weighty = weighty;  
    return this;  
}

/\*\*  
 \* Sets the insets of this cell.  
 \*  
 \* @param distance the spacing to use in all directions  
 \* @return this object for further modification  
 \*/  
public GBC setInsets(int distance) {  
    this.insets = new Insets(distance, distance, distance, distance);  
    return this;  
}

/\*\*  
 \* Sets the insets of this cell.  
 \*  
 \* @param top    the spacing to use on top  
 \* @param left   the spacing to use to the left  
 \* @param bottom the spacing to use on the bottom  
 \* @param right  the spacing to use to the right  
 \* @return this object for further modification  
 \*/  
public GBC setInsets(int top, int left, int bottom, int right) {  
    this.insets = new Insets(top, left, bottom, right);  
    return this;  
}

/\*\*  
 \* Sets the internal padding  
 \*  
 \* @param ipadx the internal padding in x-direction  
 \* @param ipady the internal padding in y-direction  
 \* @return this object for further modification  
 \*/  
public GBC setIpad(int ipadx, int ipady) {  
    this.ipadx = ipadx;  
    this.ipady = ipady;  
    return this;  
}

}

GBC

package groupLayout;

import java.awt.EventQueue;

import javax.swing.JFrame;

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

GroupLayoutTest

package groupLayout;

import java.awt.Font;
import java.awt.event.ActionListener;

import javax.swing.BorderFactory;
import javax.swing.GroupLayout;
import javax.swing.JCheckBox;
import javax.swing.JComboBox;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JScrollPane;
import javax.swing.JTextArea;
import javax.swing.LayoutStyle;
import javax.swing.SwingConstants;

/**
* A frame that uses a group layout to arrange font selection components.
*/
public class FontFrame extends JFrame {
public static final int TEXT_ROWS = 10;
public static final int TEXT_COLUMNS = 20;

private JComboBox<String> face;  
private JComboBox<Integer> size;  
private JCheckBox bold;  
private JCheckBox italic;  
private JScrollPane pane;  
private JTextArea sample;

public FontFrame() {  
    ActionListener listener = event -> updateSample();

    // construct components

    JLabel faceLabel = new JLabel("Face: ");

    face = new JComboBox<>(new String\[\] { "Serif", "SansSerif", "Monospaced", "Dialog", "DialogInput" });

    face.addActionListener(listener);

    JLabel sizeLabel = new JLabel("Size: ");

    size = new JComboBox<>(new Integer\[\] { 8, 10, 12, 15, 18, 24, 36, 48 });

    size.addActionListener(listener);

    bold = new JCheckBox("Bold");  
    bold.addActionListener(listener);

    italic = new JCheckBox("Italic");  
    italic.addActionListener(listener);

    sample = new JTextArea(TEXT\_ROWS, TEXT\_COLUMNS);  
    sample.setText("The quick brown fox jumps over the lazy dog");  
    sample.setEditable(false);  
    sample.setLineWrap(true);  
    sample.setBorder(BorderFactory.createEtchedBorder());

    pane = new JScrollPane(sample);

    GroupLayout layout = new GroupLayout(getContentPane());  
    setLayout(layout);  
    layout.setHorizontalGroup(layout.createParallelGroup(GroupLayout.Alignment.LEADING)  
            .addGroup(layout.createSequentialGroup().addContainerGap()  
                    .addGroup(layout.createParallelGroup(GroupLayout.Alignment.LEADING)  
                            .addGroup(GroupLayout.Alignment.TRAILING, layout.createSequentialGroup()  
                                    .addGroup(layout.createParallelGroup(GroupLayout.Alignment.TRAILING)  
                                            .addComponent(faceLabel).addComponent(sizeLabel))  
                                    .addPreferredGap(LayoutStyle.ComponentPlacement.RELATED)  
                                    .addGroup(layout.createParallelGroup(GroupLayout.Alignment.LEADING, false)  
                                            .addComponent(size).addComponent(face)))  
                            .addComponent(italic).addComponent(bold))  
                    .addPreferredGap(LayoutStyle.ComponentPlacement.RELATED).addComponent(pane).addContainerGap()));

    layout.linkSize(SwingConstants.HORIZONTAL, new java.awt.Component\[\] { face, size });

    layout.setVerticalGroup(layout.createParallelGroup(GroupLayout.Alignment.LEADING)  
            .addGroup(layout.createSequentialGroup().addContainerGap()  
                    .addGroup(layout.createParallelGroup(GroupLayout.Alignment.LEADING)  
                            .addComponent(pane, GroupLayout.Alignment.TRAILING)  
                            .addGroup(layout.createSequentialGroup()  
                                    .addGroup(layout.createParallelGroup(GroupLayout.Alignment.BASELINE)  
                                            .addComponent(face).addComponent(faceLabel))  
                                    .addPreferredGap(LayoutStyle.ComponentPlacement.RELATED)  
                                    .addGroup(layout.createParallelGroup(GroupLayout.Alignment.BASELINE)  
                                            .addComponent(size).addComponent(sizeLabel))  
                                    .addPreferredGap(LayoutStyle.ComponentPlacement.RELATED)  
                                    .addComponent(italic, GroupLayout.DEFAULT\_SIZE, GroupLayout.DEFAULT\_SIZE,  
                                            Short.MAX\_VALUE)  
                                    .addPreferredGap(LayoutStyle.ComponentPlacement.RELATED).addComponent(bold,  
                                            GroupLayout.DEFAULT\_SIZE, GroupLayout.DEFAULT\_SIZE, Short.MAX\_VALUE)))  
                    .addContainerGap()));  
    pack();  
}

public void updateSample() {  
    String fontFace = (String) face.getSelectedItem();  
    int fontStyle = (bold.isSelected() ? Font.BOLD : 0) + (italic.isSelected() ? Font.ITALIC : 0);  
    int fontSize = size.getItemAt(size.getSelectedIndex());  
    Font font = new Font(fontFace, fontStyle, fontSize);  
    sample.setFont(font);  
    sample.repaint();  
}

}

FontFrame

测试程序11

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

l 掌握定制布局管理器的用法。

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

package circleLayout;

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

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

CircleLayoutTest

package circleLayout;

import javax.swing.*;

/**
* A frame that shows buttons arranged along a circle.
*/
public class CircleLayoutFrame extends JFrame {
public CircleLayoutFrame() {
setLayout(new CircleLayout());
add(new JButton("Yellow"));
add(new JButton("Blue"));
add(new JButton("Red"));
add(new JButton("Green"));
add(new JButton("Orange"));
add(new JButton("Fuchsia"));
add(new JButton("Indigo"));
pack();
}
}

CircleLayoutFrame

package circleLayout;

import java.awt.*;

/**
* A layout manager that lays out components along a circle.
*/
public class CircleLayout implements LayoutManager {
private int minWidth = 0;
private int minHeight = 0;
private int preferredWidth = 0;
private int preferredHeight = 0;
private boolean sizesSet = false;
private int maxComponentWidth = 0;
private int maxComponentHeight = 0;

public void addLayoutComponent(String name, Component comp) {  
}

public void removeLayoutComponent(Component comp) {  
}

public void setSizes(Container parent) {  
    if (sizesSet)  
        return;  
    int n = parent.getComponentCount();

    preferredWidth = 0;  
    preferredHeight = 0;  
    minWidth = 0;  
    minHeight = 0;  
    maxComponentWidth = 0;  
    maxComponentHeight = 0;

    // compute the maximum component widths and heights  
    // and set the preferred size to the sum of the component sizes.  
    for (int i = 0; i < n; i++) {  
        Component c = parent.getComponent(i);  
        if (c.isVisible()) {  
            Dimension d = c.getPreferredSize();  
            maxComponentWidth = Math.max(maxComponentWidth, d.width);  
            maxComponentHeight = Math.max(maxComponentHeight, d.height);  
            preferredWidth += d.width;  
            preferredHeight += d.height;  
        }  
    }  
    minWidth = preferredWidth / 2;  
    minHeight = preferredHeight / 2;  
    sizesSet = true;  
}

public Dimension preferredLayoutSize(Container parent) {  
    setSizes(parent);  
    Insets insets = parent.getInsets();  
    int width = preferredWidth + insets.left + insets.right;  
    int height = preferredHeight + insets.top + insets.bottom;  
    return new Dimension(width, height);  
}

public Dimension minimumLayoutSize(Container parent) {  
    setSizes(parent);  
    Insets insets = parent.getInsets();  
    int width = minWidth + insets.left + insets.right;  
    int height = minHeight + insets.top + insets.bottom;  
    return new Dimension(width, height);  
}

public void layoutContainer(Container parent) {  
    setSizes(parent);

    // compute center of the circle

    Insets insets = parent.getInsets();  
    int containerWidth = parent.getSize().width - insets.left - insets.right;  
    int containerHeight = parent.getSize().height - insets.top - insets.bottom;

    int xcenter = insets.left + containerWidth / 2;  
    int ycenter = insets.top + containerHeight / 2;

    // compute radius of the circle

    int xradius = (containerWidth - maxComponentWidth) / 2;  
    int yradius = (containerHeight - maxComponentHeight) / 2;  
    int radius = Math.min(xradius, yradius);

    // lay out components along the circle

    int n = parent.getComponentCount();  
    for (int i = 0; i < n; i++) {  
        Component c = parent.getComponent(i);  
        if (c.isVisible()) {  
            double angle = 2 \* Math.PI \* i / n;

            // center point of component  
            int x = xcenter + (int) (Math.cos(angle) \* radius);  
            int y = ycenter + (int) (Math.sin(angle) \* radius);

            // move component so that its center is (x, y)  
            // and its size is its preferred size  
            Dimension d = c.getPreferredSize();  
            c.setBounds(x - d.width / 2, y - d.height / 2, d.width, d.height);  
        }  
    }  
}

}

CircleLayout

测试程序12

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

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

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

package optionDialog;

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

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

OptionDialogTest

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));//创建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");//创建一个带"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);//根据指定的 double 坐标构造和初始化 Rectangle2D
g2.setPaint(Color.YELLOW);
g2.fill(rect);
g2.setPaint(Color.BLUE);
g2.draw(rect);
}

public Dimension getPreferredSize() {  
    return new Dimension(10, 10);//构造一个 Dimension，并将其初始化为指定宽度和高度。  
}

}

OptionDialogFrame

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();//返回该按钮的动作命令字符串  
}

}

ButtonPanel

测试程序13

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

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

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

第十三小组负责的部分

package dialog;

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

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

DialogTest

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.

  JMenuBar menuBar = new JMenuBar();//菜单栏的实现  
  setJMenuBar(menuBar);//设置此窗体的菜单栏  
  JMenu fileMenu = new JMenu("File");//菜单的该实现是一个包含 JMenuItem 的弹出窗口，用户选择 JMenuBar 上的项时会显示该 JMenuItem。  
  menuBar.add(fileMenu);//将指定的菜单追加到菜单栏的末尾

  // Add About and Exit menu items.

  // The About item shows the About dialog.

  JMenuItem aboutItem = new JMenuItem("About");//菜单中的项的实现  
  aboutItem.addActionListener(event -> {  
     if (dialog == null) // first time  
        dialog = new AboutDialog(DialogFrame.this);  
     dialog.setVisible(true); // 设置是否可见  
  });  
  fileMenu.add(aboutItem);//将某个菜单项追加到此菜单的末尾。返回添加的菜单项

  // The Exit item exits the program.

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

}
}

DialogFrame

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
{
//创建一个具有指定标题、所有者 Frame 和模式的对话框。如果 owner 为 null，则一个共享的、隐藏的窗体将被设置为该对话框的所有者。
public AboutDialog(JFrame owner)
{
super(owner, "About DialogTest", true);

  // add HTML label to center

//将指定的组件添加到此容器的尾部
add(
new JLabel(
"

Core Java

By Cay Horstmann"),
BorderLayout.CENTER);

  // OK button closes the dialog

  JButton ok = new JButton("OK");//创建一个新的按钮  
  ok.addActionListener(event -> setVisible(false));

  // add OK button to southern border

  JPanel panel = new JPanel();  
  panel.add(ok);  
  add(panel, BorderLayout.SOUTH);//边框布局，显示在下边

  pack();

}
}

AboutDialog

点击File会出现About和Exit

点击About后出现如下界面

点击Exit后，程序退出

测试程序14

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

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

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

package dataExchange;

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

/**
* @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);
});
}
}

DataExchangeTest

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

}

User

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

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

    // add Connect and Exit menu items

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

}

DataExchangeFrame

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

}

PasswordChooser

测试程序15

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

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

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

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

FileChooserTest

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

}

FileIconView

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

}

ImagePreviewer

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

}

ImageViewerFrame

测试程序16

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

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

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

ColorChooserTest

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

}

ColorChooserFrame

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

}

ColorChooserPanel