| 项目 |
内容 |
| 这个作业属于哪个课程 |
<任课教师博客主页链接>https://www.cnblogs.com/nwnu-daizh/ |
| 这个作业的要求在哪里 |
<作业链接地址>https://www.cnblogs.com/nwnu-daizh/p/11995615.htmll |
| 作业学习目标 |
（1）掌握GUI布局管理器用法； （2）掌握Java Swing文本输入组件用途及常用API； （3）掌握Java Swing选择输入组件用途及常用API。
|
第一部分：总结菜单、对话框两类组件用途及常用API
菜单：
1.JMenuBar 菜单栏
菜单栏是窗口中用于容纳菜单JMenu的容器。 JFrame对象可以调用setJMenuBar()方法将一个菜单栏实例menubar添加到容器中，作为整个菜单树的根基。菜单栏被添加到窗口的上方，不受布局管理器控制。
注意：只能向窗口中添加一个菜单栏。
|
1
2
3
4
5
6
|
public
JMenuBar(){
//默认构造方法,创建新的菜单栏
}
public
JMenu add(JMenu c){
//将菜单追加到菜单栏末尾
}
|
2.JMenu 菜单
菜单是若干个菜单项(JMenuItem)或子菜单的容器，它能被添加到JMenuBar或其他JMenu中。
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
|
public
JMenu(){
//默认构造方法,创建没有文本的新菜单
}
public
JMenu(String s){
//构造方法,用提供的字符串作为文本构造一个新菜单
}
public
Component add(Component c){
//将某个组件追加到此菜单的末尾
}
public
JMenuItem add(JMenuItem c){
//将某个菜单项追加到此菜单的末尾
}
public
void
addSeparator(){
//将新分隔符追加到菜单的末尾
}
|
3.JMenuItem 菜单项
菜单项是组成菜单或快捷键的最小单位，用于完成特定功能。
|
1
2
3
4
5
6
7
8
9
|
public
JMenuItem(){
//默认构造方法,创建不带文本或图标的菜单项
}
public
JMenuItem(String text){
//构造方法
}
public
void
setAccelerator(KeyStroke keystroke){
//为菜单项设置快捷键
}
|
4.选择菜单项
Java除了提供JMenuItem，还提供了两种可选择的菜单项：复选菜单项(JCheckBoxMenuItem)和单选菜单项(JRadioButtonMenuItem)。
5.JPopupMenu 快捷菜单项
菜单除了可以放置在窗口，也可以依附于一个组件，当用户右击鼠标时弹出
|
1
2
3
4
5
6
7
8
9
10
11
12
|
public
JPopupMenu(){
//默认构造方法
}
public
JPopupMenu(String s)
//构造方法,具有指定标题
}
public
JMenuItem add(JMenuItem jm){
//将指定菜单项添加到此菜单的末尾
}
public
void
addSeparator(){
//将新分隔符追加到菜单的末尾
}
|
对话框：
1、对话框模式
对话框分为无模式和有模式两种。
如果一个对话框是有模式的，那么当这个对话框处于激活状态时，只让程序响应对话框内部的事件，而且将堵塞其它线程的执行，用户不能再激活对话框所在程序中的其它窗口，直到该对话框消失不可见。
无模式对话框处于激活状态时，能再激活其它窗口，也不堵塞其它线程执行。
3、文件对话框(FileDialog)
文件对话框是一个从文件中选择文件的界面，文件对话框事实上并不能打开或保存文件，它只能得到要打开或保存的文件的名字或所在的目录，要想真正实现打开或保存文件，还必须使用输入、输出流。
javax.swing包中的JFileChooser类可以创建文件对话框，使用该类的构造方法JFileChooser()创建初始不可见的有模式的文件对话框。showSaveDialog(Component a), showOpenDialog(Component a)都可使得对话框可见，但外观有所不同。showSaveDialog(Component a)方法提供保存文件的界面，showOpenDialog(Component a)方法提供打开文件的界面。参数a指定对话框可见时的位置。
当用户单击文件对话框上的“确定”、“取消”按键或关闭图标，文件对话框将消失，方法返回：JFileChooser.APPROVE_OPTION和JFileChooser.CANCEL_OPTION之一。当返回值是JFileChooser.APPROVE_OPTION时，可以使用JFileChooser类的getSelectedFile()得到文件对话框所选择的文件。
FileDialog是Dialog的子类，主要方法有：
1、FileDialog(Frame f,String s,int mode)：构造方法，f为所依赖的窗口对象，s是对话框的名字，mode取值为FileDialog.LOAD或FileDialog.SAVE。
2、public String getDirwctory()：获取当前对话框中所显示的文件目录。
3、public String getFile()：获取对话框中显示的文件的字符串表示，如不存在则为null。
4、消息对话框
消息对话框是有模式对话框，进行一个重要的操作动作之前，弹出一个消息对话框。可以用javax.swing包中的JOptionPane类的静态方法。
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
|
public
static
void
showMessageDialog(Component parentComponent,String message, String title,
int
messageType);
Component parentComponent：
//消息对话框依赖的组件
String message：
// 要显示的消息
String title：
//对话框的标题
int
messageType)：
//对话框的外观，取值如下：
JOptionPane.INFORMATION_MESSAGE
JOptionPane.WARNING_MESSAGE
JOptionPane.ERROR_MESSAGE
JOptionPane.QUESTION_MESSAGE
JOptionPane.PLAIN_MESSAGE
|
5、输入对话框
输入对话框含有供用户输入文本的文本框、一个“确定”和“取消”按钮，是有模式对话框。当输入对话框可见时，要求用户输入一个字符串。javax.swing包中的JOptionPane类静态方法：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
|
public
static
String showInputDialog(Component parentComponent, Object message, String title,
int
messageType);
Component parentComponent
//指定输入对话框所依赖的组件。
Object message
//指定对话框上的提示信息。
String title
//对话框上的标题。
int
messageType
//确定对话框的外观，取值如下：
ERROR_MESSAGE
INFORMATION_MESSAGE
WARNING_MESSAGE
QUESTION_MESSAGE
PLAIN_MESSAGE
|
6、确认对话框
确认对话框是有模式对话框，可以用javax.swing包中的JOptionPane类的静态方法创建：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
|
public
static
int
showConfirmDialog(Component parentComponent, Object message, String title,
int
optionType);
Component parentComponent
//对话框所依赖的组件。
Object messag
//对话框上显示的消息
String titl
//对话框的标题
int
optionType
//对话框的外观，取值如下：
JOptionPane.YES_NO_OPTION
JOptionPane.YES_NO_CANCEL_OPTION
JOptionPane.OK_CANCEL_OPTION
|
当对话框消失后，showConfirmDialog方法会返回下列整数之一：
JOptionPane.YES_OPTION
JOptionPane.NO_OPTION
JOptionPane.CANCEL_OPTION
JOptionPane.OK_OPTION
JOptionPane.CLOSED_OPTION
7、颜色对话框
使用java.swing包中的JColorChooser类表静态方法创建：
|
1
2
3
4
5
6
7
|
public
static
Color showDialog(Component component,String title,Color initialColor);
Component component
//对话框所依赖的组件。
String title
//对话框的标题。
Color initialColor)
//对话框消失后返回的默认颜色
|
第二部分：实验部分
1、实验目的与要求
(1) 掌握菜单组件用途及常用API；
(2) 掌握对话框组件用途及常用API；
(3) 学习设计简单应用程序的GUI。
2、实验内容和步骤
实验1： 导入第12章示例程序，测试程序并进行组内讨论。
测试程序1
l 在elipse IDE中调试运行教材512页程序12-8，结合运行结果理解程序；
l 掌握菜单的创建、菜单事件监听器、复选框和单选按钮菜单项、弹出菜单以及快捷键和加速器的用法。
l 记录示例代码阅读理解中存在的问题与疑惑。
代码如下：
MenuTest.java:
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
|
package
menu;
import
java.awt.*;
import
javax.swing.*;
/**
* @version 1.25 2018-04-10
* @author Cay Horstmann
*/
public
class
MenuTest
{
public
static
void
main(String[] args)
{
EventQueue.invokeLater(() -> {
var frame =
new
MenuFrame();
frame.setTitle(
"MenuTest"
);
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
frame.setVisible(
true
);
});
}
}
|
MenuFrame.java:
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
|
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);
var fileMenu =
new
JMenu(
"File"
);
//构建菜单
fileMenu.add(
new
TestAction(
"New"
));
// demonstrate accelerators
var openItem = fileMenu.add(
new
TestAction(
"Open"
));
//添加菜单项
openItem.setAccelerator(KeyStroke.getKeyStroke(
"ctrl O"
));
fileMenu.addSeparator();
//添加分隔符
saveAction =
new
TestAction(
"Save"
);
JMenuItem saveItem = fileMenu.add(saveAction);
saveItem.setAccelerator(KeyStroke.getKeyStroke(
"ctrl S"
));
saveAsAction =
new
TestAction(
"Save As"
);
fileMenu.add(saveAsAction);
fileMenu.addSeparator();
//采用扩展抽象类AbstractAction来定义一个实现Action接口的类
fileMenu.add(
new
AbstractAction(
"Exit"
)
{
/**
*
*/
private
static
final
long
serialVersionUID = 1L;
//指定菜单项标签并且覆盖actionPerformed方法来获得菜单动作处理器
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);
}
});
/*
* 复选框和单选按钮菜单项
*/
var group =
new
ButtonGroup();
var insertItem =
new
JRadioButtonMenuItem(
"Insert"
);
//构造单选钮菜单项
insertItem.setSelected(
true
);
var overtypeItem =
new
JRadioButtonMenuItem(
"Overtype"
);
group.add(insertItem);
group.add(overtypeItem);
// demonstrate icons
var cutAction =
new
TestAction(
"Cut"
);
cutAction.putValue(Action.SMALL_ICON,
new
ImageIcon(
"cut.gif"
));
var copyAction =
new
TestAction(
"Copy"
);
copyAction.putValue(Action.SMALL_ICON,
new
ImageIcon(
"copy.gif"
));
var pasteAction =
new
TestAction(
"Paste"
);
pasteAction.putValue(Action.SMALL_ICON,
new
ImageIcon(
"paste.gif"
));
var editMenu =
new
JMenu(
"Edit"
);
editMenu.add(cutAction);
editMenu.add(copyAction);
editMenu.add(pasteAction);
// demonstrate nested menus
var optionMenu =
new
JMenu(
"Options"
);
optionMenu.add(readonlyItem);
optionMenu.addSeparator();
optionMenu.add(insertItem);
optionMenu.add(overtypeItem);
editMenu.addSeparator();
editMenu.add(optionMenu);
// demonstrate mnemonics
//调用setMnemonic方法，为菜单设置快捷键
var helpMenu =
new
JMenu(
"Help"
);
helpMenu.setMnemonic(
'H'
);
var indexItem =
new
JMenuItem(
"Index"
);
indexItem.setMnemonic(
'I'
);
helpMenu.add(indexItem);
// you can also add the mnemonic key to an action
var aboutAction =
new
TestAction(
"About"
);
aboutAction.putValue(Action.MNEMONIC_KEY,
new
Integer(
'A'
));
helpMenu.add(aboutAction);
// add all top-level menus to menu bar
//创建菜单栏
var 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);
var panel =
new
JPanel();
panel.setComponentPopupMenu(popup);
add(panel);
}
}
|
运行结果如图：
小结：位于窗口顶部的菜单栏包括了下拉菜单的名字。点击一个名字就可以打开包含菜单项和子菜单的菜单。当用户点击菜单项时，所有的菜单都会被关闭并且将一条消息发送给程序。
测试程序2
l 在elipse IDE中调试运行教材517页程序12-9，结合运行结果理解程序；
l 掌握工具栏和工具提示的用法；
l 记录示例代码阅读理解中存在的问题与疑惑。
程序代码如下：
ToolBarTest.java:
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
|
package
toolBar;
import
java.awt.*;
import
javax.swing.*;
/**
* @version 1.15 2018-04-10
* @author Cay Horstmann
*/
public
class
ToolBarTest
{
public
static
void
main(String[] args)
{
EventQueue.invokeLater(() -> {
var frame =
new
ToolBarFrame();
frame.setTitle(
"ToolBarTest"
);
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
frame.setVisible(
true
);
});
}
}
|
ToolBarFrame.java:
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
|
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
var blueAction =
new
ColorAction(
"Blue"
,
new
ImageIcon(
"blue-ball.gif"
), Color.BLUE);
var yellowAction =
new
ColorAction(
"Yellow"
,
new
ImageIcon(
"yellow-ball.gif"
),Color.YELLOW);
var redAction =
new
ColorAction(
"Red"
,
new
ImageIcon(
"red-ball.gif"
), Color.RED);
var exitAction =
new
AbstractAction(
"Exit"
,
new
ImageIcon(
"exit.gif"
))
{
public
void
actionPerformed(ActionEvent event)
{
System.exit(
0
);
}
};
exitAction.putValue(Action.SHORT_DESCRIPTION,
"Exit"
);
// populate toolbar
//创建工具栏
var bar =
new
JToolBar();
bar.add(blueAction);
bar.add(yellowAction);
bar.add(redAction);
bar.addSeparator();
//添加分隔符
bar.add(exitAction);
add(bar, BorderLayout.NORTH);
//将工具栏添加到框架中
// populate menu
var menu =
new
JMenu(
"Color"
);
menu.add(yellowAction);
menu.add(blueAction);
menu.add(redAction);
menu.add(exitAction);
var menuBar =
new
JMenuBar();
menuBar.add(menu);
setJMenuBar(menuBar);
}
/**
* 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 记录示例代码阅读理解中存在的问题与疑惑。
程序代码如下：
OptionDialogTest.Java:
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
|
package
optionDialog;
import
java.awt.*;
import
javax.swing.*;
/**
* @version 1.35 2018-04-10
* @author Cay Horstmann
*/
public
class
OptionDialogTest
{
public
static
void
main(String[] args)
{
EventQueue.invokeLater(() -> {
var frame =
new
OptionDialogFrame();
frame.setTitle(
"OptionDialogTest"
);
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
frame.setVisible(
true
);
});
}
}
|
OptionDialogFrame.java:
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
|
package
optionDialog;
import
java.awt.*;
import
java.awt.event.*;
import
java.awt.geom.*;
import
java.util.*;
import
javax.swing.*;
/**
* A frame that contains settings for selecting various option dialogs.
*/
public
class
OptionDialogFrame
extends
JFrame
{
private
ButtonPanel typePanel;
private
ButtonPanel messagePanel;
private
ButtonPanel messageTypePanel;
private
ButtonPanel optionTypePanel;
private
ButtonPanel optionsPanel;
private
ButtonPanel inputPanel;
private
String messageString =
"Message"
;
private
Icon messageIcon =
new
ImageIcon(
"blue-ball.gif"
);
private
Object messageObject =
new
Date();
private
Component messageComponent =
new
SampleComponent();
public
OptionDialogFrame()
{
//创建一个面板，设置为两行三列的网格，每个网格中定义一个单选的面板
var gridPanel =
new
JPanel();
gridPanel.setLayout(
new
GridLayout(
2
,
3
));
typePanel =
new
ButtonPanel(
"Type"
,
"Message"
,
"Confirm"
,
"Option"
,
"Input"
);
messageTypePanel =
new
ButtonPanel(
"Message Type"
,
"ERROR_MESSAGE"
,
"INFORMATION_MESSAGE"
,
"WARNING_MESSAGE"
,
"QUESTION_MESSAGE"
,
"PLAIN_MESSAGE"
);
messagePanel =
new
ButtonPanel(
"Message"
,
"String"
,
"Icon"
,
"Component"
,
"Other"
,
"Object[]"
);
optionTypePanel =
new
ButtonPanel(
"Confirm"
,
"DEFAULT_OPTION"
,
"YES_NO_OPTION"
,
"YES_NO_CANCEL_OPTION"
,
"OK_CANCEL_OPTION"
);
optionsPanel =
new
ButtonPanel(
"Option"
,
"String[]"
,
"Icon[]"
,
"Object[]"
);
inputPanel =
new
ButtonPanel(
"Input"
,
"Text field"
,
"Combo box"
);
gridPanel.add(typePanel);
gridPanel.add(messageTypePanel);
gridPanel.add(messagePanel);
gridPanel.add(optionTypePanel);
gridPanel.add(optionsPanel);
gridPanel.add(inputPanel);
// add a panel with a Show button
//创建一个按钮组件，设置监听事件
var showPanel =
new
JPanel();
var showButton =
new
JButton(
"Show"
);
showButton.addActionListener(
new
ShowAction());
showPanel.add(showButton);
add(gridPanel, BorderLayout.CENTER);
add(showPanel, BorderLayout.SOUTH);
pack();
}
/**
* 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)
{
var g2 = (Graphics2D) g;
var rect =
new
Rectangle2D.Double(
0
,
0
, getWidth() -
1
, getHeight() -
1
);
g2.setPaint(Color.YELLOW);
g2.fill(rect);
g2.setPaint(Color.BLUE);
g2.draw(rect);
}
public
Dimension getPreferredSize()
{
return
new
Dimension(
10
,
10
);
}
}
|
ButtonPanel.java:
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
|
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)
{
var 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();
}
}
|
运行结果如图：
小结：简单的对话框，用于获取用户的一些简单信息。输入对话框用于接受用户输入的额外组件。选项包括：1：选择对话框的类型，2：选择图标，3;选择消息，4：对于确认对话框，选择选项类型，5;对于选项对话框，选择选项，6：调用JOptionPane API中的相应方法。
测试程序4
l 在elipse IDE中调试运行教材552页程序12-17、12-18，结合运行结果理解程序；
l 掌握对话框的创建方法；
l 记录示例代码阅读理解中存在的问题与疑惑。
程序代码如下：
DialogTest.java:
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
|
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
);
});
}
}
|
DialogFrame.java:
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
|
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"
);
//lambda表达式
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
var exitItem =
new
JMenuItem(
"Exit"
);
exitItem.addActionListener(event -> System.exit(
0
));
fileMenu.add(exitItem);
}
}
|
AboutDialog.java:
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
|
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
{
//调用超类JDialog的构造器
public
AboutDialog(JFrame owner)
{
super
(owner,
"About DialogTest"
,
true
);
//添加对话框的用户界面组件
add(
new
JLabel(
"
),
BorderLayout.CENTER);
// OK button closes the dialog
//点击OK按钮时，对话框被关闭
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();
}
}
|
运行结果如图：
小结：实现一个对话框，需要从JDialog派生一个类。具体过程如下：1：在对话框构造器中调用超类JDialog的构造器，2：添加对话框的用户界面组件，3：添加事件处理器，4;设置对话框的大小。
测试程序5
l 在elipse IDE中调试运行教材556页程序12-19、12-20，结合运行结果理解程序；
l 掌握对话框的数据交换用法;
l 记录示例代码阅读理解中存在的问题与疑惑。
程序代码如下：
DataExchangeTest.java:
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
|
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
);
});
}
}
|
DataExchangeFrame.java:
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
|
package
dataExchange;
import
java.awt.*;
import
java.awt.event.*;
import
javax.swing.*;
/**
* A frame with a menu whose File->Connect action shows a password dialog.
*/
public
class
DataExchangeFrame
extends
JFrame
{
public
static
final
int
TEXT_ROWS =
20
;
public
static
final
int
TEXT_COLUMNS =
40
;
private
PasswordChooser dialog =
null
;
private
JTextArea textArea;
public
DataExchangeFrame()
{
//创建一个菜单
var mbar =
new
JMenuBar();
setJMenuBar(mbar);
var fileMenu =
new
JMenu(
"File"
);
mbar.add(fileMenu);
//添加菜单项
var connectItem =
new
JMenuItem(
"Connect"
);
connectItem.addActionListener(
new
ConnectAction());
fileMenu.add(connectItem);
// 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"
);
}
}
}
}
PasswordChooser.java:
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
*/
//PasswordChooser类提供的setUser方法
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
*/
//在showDialog方法中动态建立JDialog对象
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;
}
}
|
User.java:
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
|
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-22、12-23，结合程序运行结果理解程序； l 掌握文件对话框的用法; l 记录示例代码阅读理解中存在的问题与疑惑。 程序代码如下： FileChooserTest.java:
FileIconView.java:
运行结果如图：
小结：文件对话框，调用showOpenDialog。接受文件的按钮被自动的标签为Open或者Save，也可以调用showDialog方法为按钮设定标签。 测试程序7 l 在elipse IDE中调试运行教材570页程序12-24，结合运行结果理解程序； l 了解颜色选择器的用法。 l 记录示例代码阅读理解中存在的问题与疑惑。 程序代码如下： ColorChooserTest.java:
ColorChooserPane.java:
ColorChooserFrame.java:
运行结果如图：
小结：颜色选择器是一个组件，包含了用于创建包含颜色选择器组件的对话框方法。有三种对话框类型。如果点击Model按钮，则需要选择一个颜色才能继续后面的操作。如果点击Modaless按钮，则会得到一个无模式对话框。只有点击OK按钮时，颜色才会发生改变。如果点击Immediate按钮，会得到一个没有按钮的无模式对话框。 3、实验总结: 1）FlowLayout: 流布局(Applet和Panel的默认布局管理器） |
