package test11;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.KeyEvent;
import javax.swing.AbstractButton;
import javax.swing.ImageIcon;
import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JPanel;
/**
* Title: 按钮演示
* Description: 提供一个按钮的演示。如何实现按钮和是一个按钮失效
* Filename:
*/
public class ButtonDemo extends JPanel
implements ActionListener {
private static final long serialVersionUID = 1L;
protected JButton b1, b2, b3;
/**
*方法说明：构造器，初始图形界面构建
*/
public ButtonDemo() {
ImageIcon leftButtonIcon = createImageIcon("images/right.gif");
ImageIcon middleButtonIcon = createImageIcon("images/middle.gif");
ImageIcon rightButtonIcon = createImageIcon("images/left.gif");
b1 = new JButton("失效中间按钮(D)", leftButtonIcon);
b1.setVerticalTextPosition(AbstractButton.CENTER);//水平中间对齐
b1.setHorizontalTextPosition(AbstractButton.LEADING);//相当于LEFT
b1.setMnemonic(KeyEvent.VK_D);//将b1邦定alt+D键
b1.setActionCommand("disable");
b2 = new JButton("M中间按钮", middleButtonIcon);
b2.setVerticalTextPosition(AbstractButton.BOTTOM);
b2.setHorizontalTextPosition(AbstractButton.CENTER);
b2.setMnemonic(KeyEvent.VK_M);//将b2邦定alt+M键
b3 = new JButton("E激活中间按钮", rightButtonIcon);
b3.setMnemonic(KeyEvent.VK_E);//将b3邦定alt+E键
b3.setActionCommand("enable");
b3.setEnabled(false);
//给1和3添加事件监听
b1.addActionListener(this);
b3.addActionListener(this);
//设置按钮提示文本
b1.setToolTipText("点击这个按钮，将使中间的按钮失效！");
b2.setToolTipText("点击这个按钮，没有任何的事件发生！");
b3.setToolTipText("点击这个按钮，将使中间的按钮有效");
//将按钮添加到JPanel中
add(b1);
add(b2);
add(b3);
}
/**
*方法说明：事件处理
*/
public void actionPerformed(ActionEvent e) {
if ("disable".equals(e.getActionCommand())) {
b2.setEnabled(false);
b1.setEnabled(false);
b3.setEnabled(true);
} else {
b2.setEnabled(true);
b1.setEnabled(true);
b3.setEnabled(false);
}
}
/**
*方法说明：创建图标，
*输入参数：String path 图标所在的路径
*返回类型：ImageIcon 图标对象
*/
protected static ImageIcon createImageIcon(String path) {
java.net.URL imgURL = ButtonDemo.class.getResource(path);
if (imgURL != null) {
return new ImageIcon(imgURL);
} else {
System.err.println("Couldn't find file: " + path);
return null;
}
}
/**
*方法说明：主方法
*/
public static void main(String[] args) {
//设置使用新的swing界面
JFrame.setDefaultLookAndFeelDecorated(true);
//创建一个窗体
JFrame frame = new JFrame("ButtonDemo");
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
//创建一个面板
ButtonDemo newContentPane = new ButtonDemo();
newContentPane.setOpaque(true);
frame.setContentPane(newContentPane);
//显示窗体
frame.pack();
frame.setVisible(true);
}
}
package test12;
import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
/**
* Title: 检查盒演示
* Description: 选择不同的选择框显示不同的图片
* Filename: CheckBoxDemo.java<
*/
public class CheckBoxDemo extends JPanel
implements ItemListener {
private static final long serialVersionUID = 1L;
JCheckBox chinButton;
JCheckBox glassesButton;
JCheckBox hairButton;
JCheckBox teethButton;
/*
* 有四个检查盒，分别对应下巴、眼镜、头发和牙齿
* 图片不是拼出来的，而是根据检查盒选择拼写图片文件名
* 图片文件名的定义格式为"geek-XXXX.gif"
* 其中 XXXX 根据检查盒的不同选择，而不同。它的格式如下：
---- //没有选择
c--- //一个选择
-g--
--h-
---t
cg-- //两个选择
c-h-
c--t
-gh-
-g-t
--ht
-ght //三个选择
c-ht
cg-t
cgh-
cght //所有都选
*/
StringBuffer choices;
JLabel pictureLabel;
public CheckBoxDemo() {
super(new BorderLayout());
//创建检查盒
chinButton = new JCheckBox("下巴(c)");
chinButton.setMnemonic(KeyEvent.VK_C);
chinButton.setSelected(true);
glassesButton = new JCheckBox("眼镜(g)");
glassesButton.setMnemonic(KeyEvent.VK_G);
glassesButton.setSelected(true);
hairButton = new JCheckBox("头发(h)");
hairButton.setMnemonic(KeyEvent.VK_H);
hairButton.setSelected(true);
teethButton = new JCheckBox("牙齿(t)");
teethButton.setMnemonic(KeyEvent.VK_T);
teethButton.setSelected(true);
//给检查盒添加监听
chinButton.addItemListener(this);
glassesButton.addItemListener(this);
hairButton.addItemListener(this);
teethButton.addItemListener(this);
choices = new StringBuffer("cght");
//放置一个带图片的标签
pictureLabel = new JLabel();
pictureLabel.setFont(pictureLabel.getFont().deriveFont(Font.ITALIC));
updatePicture();
//将检查盒放置到面版中
JPanel checkPanel = new JPanel(new GridLayout(0, 1));
checkPanel.add(chinButton);
checkPanel.add(glassesButton);
checkPanel.add(hairButton);
checkPanel.add(teethButton);
add(checkPanel, BorderLayout.LINE_START);
add(pictureLabel, BorderLayout.CENTER);
setBorder(BorderFactory.createEmptyBorder(20,20,20,20));
}
/**
*<br>方法说明：监听检查盒事件，拼凑图片的文件名XXXX部分
*<br>输入参数：
*<br>返回类型：
*/
public void itemStateChanged(ItemEvent e) {
int index = 0;
char c = '-';
Object source = e.getItemSelectable();
if (source == chinButton) {
index = 0;
c = 'c';
} else if (source == glassesButton) {
index = 1;
c = 'g';
} else if (source == hairButton) {
index = 2;
c = 'h';
} else if (source == teethButton) {
index = 3;
c = 't';
}
//取消选择事件
if (e.getStateChange() == ItemEvent.DESELECTED) {
c = '-';
}
//改变文件名字XXXX
choices.setCharAt(index, c);
updatePicture();
}
/**
*<br>方法说明：绘制图片
*<br>输入参数：
*<br>返回类型：
*/
protected void updatePicture() {
//将得到的图片制成图标
ImageIcon icon = createImageIcon(
"images/geek/geek-"
+ choices.toString()
+ ".gif");
pictureLabel.setIcon(icon);
pictureLabel.setToolTipText(choices.toString());
if (icon == null) {
pictureLabel.setText("没有发现图片");
} else {
pictureLabel.setText(null);
}
}
/**
*<br>方法说明：获取图标
*<br>输入参数：String path 图片路径
*<br>返回类型：ImageIcon对象
*/
protected static ImageIcon createImageIcon(String path) {
java.net.URL imgURL = CheckBoxDemo.class.getResource(path);
if (imgURL != null) {
return new ImageIcon(imgURL);
} else {
System.err.println("Couldn't find file: " + path);
return null;
}
}
/**
*<br>方法说明：主方法
*<br>输入参数：
*<br>返回类型：
*/
public static void main(String s[]) {
JFrame.setDefaultLookAndFeelDecorated(true);
//创建一个窗体，
JFrame frame = new JFrame("CheckBoxDemo");
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
//创建一个面板
JComponent newContentPane = new CheckBoxDemo();
newContentPane.setOpaque(true);
frame.setContentPane(newContentPane);
//显示窗体
frame.pack();
frame.setVisible(true);
}
}
package test13;
import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
import java.util.*;
import java.text.SimpleDateFormat;
/**
* Title: ComboBox下拉域演示</p>
* Description: 通过选择或这输入一种日期格式来格式化今天的日期
* Filename: ComboBoxDemo.java
*/
public class ComboBoxDemo extends JPanel
implements ActionListener {
private static final long serialVersionUID = 1L;
static JFrame frame;
JLabel result;
String currentPattern;
/**
*方法说明：构造器。初始化窗体构件
*/
public ComboBoxDemo() {
setLayout(new BoxLayout(this, BoxLayout.PAGE_AXIS));
String[] patternExamples = {
"dd MMMMM yyyy",
"dd.MM.yy",
"MM/dd/yy",
"yyyy.MM.dd G 'at' hh:mm:ss z",
"EEE, MMM d, ''yy",
"h:mm a",
"H:mm:ss:SSS",
"K:mm a,z",
"yyyy.MMMMM.dd GGG hh:mm aaa"
};
currentPattern = patternExamples[0];
//设置一个规范的用户界面
JLabel patternLabel1 = new JLabel("输入一个字符格式或者");
JLabel patternLabel2 = new JLabel("从下拉列表中选择一种：");
JComboBox patternList = new JComboBox(patternExamples);
patternList.setEditable(true);//标注这里ComboBox可进行编辑
patternList.addActionListener(this);
//创建一个显示结果用户界面
JLabel resultLabel = new JLabel("当前 日期/时间",
JLabel.LEADING);//相当于LEFT
result = new JLabel(" ");
result.setForeground(Color.black);
result.setBorder(BorderFactory.createCompoundBorder(
BorderFactory.createLineBorder(Color.black),
BorderFactory.createEmptyBorder(5,5,5,5)
));
//布置构件
JPanel patternPanel = new JPanel();
patternPanel.setLayout(new BoxLayout(patternPanel,
BoxLayout.PAGE_AXIS));
patternPanel.add(patternLabel1);
patternPanel.add(patternLabel2);
patternList.setAlignmentX(Component.LEFT_ALIGNMENT);
patternPanel.add(patternList);
JPanel resultPanel = new JPanel(new GridLayout(0, 1));
resultPanel.add(resultLabel);
resultPanel.add(result);
patternPanel.setAlignmentX(Component.LEFT_ALIGNMENT);
resultPanel.setAlignmentX(Component.LEFT_ALIGNMENT);
add(patternPanel);
add(Box.createRigidArea(new Dimension(0, 10)));
add(resultPanel);
setBorder(BorderFactory.createEmptyBorder(10,10,10,10));
reformat();
}
/**
*方法说明：事件处理
*/
public void actionPerformed(ActionEvent e) {
JComboBox cb = (JComboBox)e.getSource();
String newSelection = (String)cb.getSelectedItem();
currentPattern = newSelection;
reformat();
}
/**
*方法说明：格式和显示今天的日期
*/
public void reformat() {
Date today = new Date();
SimpleDateFormat formatter =
new SimpleDateFormat(currentPattern);
try {
String dateString = formatter.format(today);
result.setForeground(Color.black);
result.setText(dateString);
} catch (IllegalArgumentException iae) {
result.setForeground(Color.red);
result.setText("Error: " + iae.getMessage());
}
}
/**
*方法说明：主方法
*/
public static void main(String[] args) {
JFrame.setDefaultLookAndFeelDecorated(true);
//创建一个窗体
frame = new JFrame("ComboBoxDemo");
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
//创建一个面版容器
JComponent newContentPane = new ComboBoxDemo();
newContentPane.setOpaque(true);
frame.setContentPane(newContentPane);
//显示窗体
frame.pack();
frame.setVisible(true);
}
}
package test14;
import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
import javax.swing.event.*;
/**
* Title: 列表框
* Description: 通过输入框添加元素和点击“删除”按钮删除列表元素
* Filename: ListDemo.java
*/
public class ListDemo extends JPanel
implements ListSelectionListener {
private static final long serialVersionUID = 1L;
private JList list;
private DefaultListModel listModel;
private static final String hireString = "添加";
private static final String fireString = "删除";
private JButton fireButton;
private JTextField employeeName;
public ListDemo() {
super(new BorderLayout());
//构建List的列表元素
listModel = new DefaultListModel();
listModel.addElement("Alan Sommerer");
listModel.addElement("Alison Huml");
listModel.addElement("Kathy Walrath");
listModel.addElement("Lisa Friendly");
listModel.addElement("Mary Campione");
listModel.addElement("Sharon Zakhour");
//创建一个List构件,并将列表元素添加到列表中
list = new JList(listModel);
//设置选择模式为单选
list.setSelectionMode(ListSelectionModel.SINGLE_SELECTION);
//初始化选择索引在0的位置，即第一个元素
list.setSelectedIndex(0);
list.addListSelectionListener(this);
//设置列表可以同时看5个元素
list.setVisibleRowCount(5);
//给列表添加一个滑动块
JScrollPane listScrollPane = new JScrollPane(list);
JButton hireButton = new JButton(hireString);
HireListener hireListener = new HireListener(hireButton);
hireButton.setActionCommand(hireString);
hireButton.addActionListener(hireListener);
hireButton.setEnabled(false);
fireButton = new JButton(fireString);
fireButton.setActionCommand(fireString);
fireButton.addActionListener(new FireListener());
employeeName = new JTextField(10);
employeeName.addActionListener(hireListener);
employeeName.getDocument().addDocumentListener(hireListener);
@SuppressWarnings("unused")
String name = listModel.getElementAt(
list.getSelectedIndex()).toString();
//创建一个面板
JPanel buttonPane = new JPanel();
buttonPane.setLayout(new BoxLayout(buttonPane,
BoxLayout.LINE_AXIS));
buttonPane.add(fireButton);
buttonPane.add(Box.createHorizontalStrut(5));
buttonPane.add(new JSeparator(SwingConstants.VERTICAL));
buttonPane.add(Box.createHorizontalStrut(5));
buttonPane.add(employeeName);
buttonPane.add(hireButton);
buttonPane.setBorder(BorderFactory.createEmptyBorder(5,5,5,5));
add(listScrollPane, BorderLayout.CENTER);
add(buttonPane, BorderLayout.PAGE_END);
}
/**
*类说明：“添加”按钮监听
*类描述：当点击“添加”按钮后，实现将元素添加到列表框中
*/
class FireListener implements ActionListener {
public void actionPerformed(ActionEvent e) {
int index = list.getSelectedIndex();
listModel.remove(index);
int size = listModel.getSize();
if (size == 0) { //如果没有了选择项，则是“删除”按钮实效
fireButton.setEnabled(false);
} else { //选择了一个
if (index == listModel.getSize()) {
//移除选项
index--;
}
list.setSelectedIndex(index);
list.ensureIndexIsVisible(index);
}
}
}
/**
*类说明：“删除”按钮监听事件
*类描述：实现删除列表元素
*/
class HireListener implements ActionListener, DocumentListener {
private boolean alreadyEnabled = false;
private JButton button;
public HireListener(JButton button) {
this.button = button;
}
//必须实现 ActionListener.
public void actionPerformed(ActionEvent e) {
String name = employeeName.getText();
//如果输入空或有同名
if (name.equals("") || alreadyInList(name)) {
Toolkit.getDefaultToolkit().beep();
employeeName.requestFocusInWindow();
employeeName.selectAll();
return;
}
int index = list.getSelectedIndex(); //获取选择项
if (index == -1) { //如果没有选择，就插入到第一个
index = 0;
} else { //如果有选择，那么插入到选择项的后面
index++;
}
listModel.insertElementAt(employeeName.getText(), index);
//重新设置文本
employeeName.requestFocusInWindow();
employeeName.setText("");
//选择新的元素，并显示出来
list.setSelectedIndex(index);
list.ensureIndexIsVisible(index);
}
/**
*方法说明：检测是否在LIST中有重名元素
*输入参数：String name 检测的名字
*返回类型：boolean 布尔值，如果存在返回true
*/
protected boolean alreadyInList(String name) {
return listModel.contains(name);
}
/**
*方法说明：实现DocumentListener接口，必需实现的方法：
*/
public void insertUpdate(DocumentEvent e) {
enableButton();
}
/**
*方法说明：实现DocumentListener接口，必需实现的方法
*/
public void removeUpdate(DocumentEvent e) {
handleEmptyTextField(e);
}
/**
*方法说明：实现DocumentListener接口，必需实现的方法
*/
public void changedUpdate(DocumentEvent e) {
if (!handleEmptyTextField(e)) {
enableButton();
}
}
/**
*方法说明：按钮使能
*/
private void enableButton() {
if (!alreadyEnabled) {
button.setEnabled(true);
}
}
/**
*方法说明：实现DocumentListener接口，必需实现的方法，修改按钮的状态
*/
private boolean handleEmptyTextField(DocumentEvent e) {
if (e.getDocument().getLength() <= 0) {
button.setEnabled(false);
alreadyEnabled = false;
return true;
}
return false;
}
}
/**
*方法说明：实现ListSelectionListener接口，必需实现的方法：
*/
public void valueChanged(ListSelectionEvent e) {
if (e.getValueIsAdjusting() == false) {
if (list.getSelectedIndex() == -1) {
fireButton.setEnabled(false);
} else {
fireButton.setEnabled(true);
}
}
}
/**
*方法说明：主方法
*/
public static void main(String[] args) {
JFrame.setDefaultLookAndFeelDecorated(true);
//创建一个窗体
JFrame frame = new JFrame("ListDemo");
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
//创建一个面版
JComponent newContentPane = new ListDemo();
newContentPane.setOpaque(true);
frame.setContentPane(newContentPane);
//显示窗体
frame.pack();
frame.setVisible(true);
}
}
package test15;
import javax.swing.JTabbedPane;
import javax.swing.ImageIcon;
import javax.swing.JLabel;
import javax.swing.JPanel;
import javax.swing.JFrame;
/**
* Title: 选项卡演示
* Description: 这里是一个选项卡演示，点击不同的卡片，显示的内容不同
* Filename: TabbedPaneDemo.java
*/
import java.awt.*;
public class TabbedPaneDemo extends JPanel {
/**
*
*/
private static final long serialVersionUID = 1L;
public TabbedPaneDemo() {
super(new GridLayout(1, 1));
ImageIcon icon = createImageIcon("images/middle.gif");
JTabbedPane tabbedPane = new JTabbedPane();
Component panel1 = makeTextPanel("#第一个卡片#");
tabbedPane.addTab("One", icon, panel1,
"第一个卡片提示信息！");
tabbedPane.setSelectedIndex(0);
Component panel2 = makeTextPanel("##第二个卡片##");
tabbedPane.addTab("Two", icon, panel2,
"第二个卡片提示信息！");
Component panel3 = makeTextPanel("###第三个卡片###");
tabbedPane.addTab("Three", icon, panel3,
"第三个卡片提示信息！");
Component panel4 = makeTextPanel("####第四个卡片####");
tabbedPane.addTab("Four", icon, panel4,
"第四个卡片提示信息！");
//将选项卡添加到panl中
add(tabbedPane);
}
/**
*方法说明：添加信息到选项卡中
*输入参数：String text 显示的信息内容
*返回类型：Component 成员对象
*/
protected Component makeTextPanel(String text) {
JPanel panel = new JPanel(false);
JLabel filler = new JLabel(text);
filler.setHorizontalAlignment(JLabel.CENTER);
panel.setLayout(new GridLayout(1, 1));
panel.add(filler);
return panel;
}
/**
*方法说明：获得图片
*输入参数：String path 图片的路径
*返回类型：ImageIcon 图片对象
*/
protected static ImageIcon createImageIcon(String path) {
java.net.URL imgURL = TabbedPaneDemo.class.getResource(path);
if (imgURL != null) {
return new ImageIcon(imgURL);
} else {
System.err.println("Couldn't find file: " + path);
return null;
}
}
public static void main(String[] args) {
//使用Swing窗体描述
JFrame.setDefaultLookAndFeelDecorated(true);
//创建窗体
JFrame frame = new JFrame("TabbedPaneDemo");
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
frame.getContentPane().add(new TabbedPaneDemo(),
BorderLayout.CENTER);
//显示窗体
frame.setSize(400, 200);
frame.setVisible(true);
}
}
package test16;
import javax.swing.JOptionPane;
import javax.swing.JDialog;
import javax.swing.JTextField;
import java.beans.*; //property change stuff
import java.awt.*;
import java.awt.event.*;
/**
* Title: 用户自定义对话框
* Description: 自己定义对话框的风格。这使得对话框的样式更加多样化
* Filename: CustomDialog.java
*/
class CustomDialog extends JDialog
implements ActionListener,
PropertyChangeListener {
private static final long serialVersionUID = 1L;
private String typedText = null;
private JTextField textField;
private DialogDemo dd;
private String magicWord;
private JOptionPane optionPane;
private String btnString1 = "确定";
private String btnString2 = "取消";
/**
*方法说明：返回文本输入字符
*/
public String getValidatedText() {
return typedText;
}
/**
*方法说明：创建一个结果对话框
*/
public CustomDialog(Frame aFrame, String aWord, DialogDemo parent) {
super(aFrame, true);
dd = parent;
magicWord = aWord.toUpperCase();
setTitle("测试");
textField = new JTextField(10);
//定义显示信息
String msgString1 = "李先生： jeck是你的英文名字吗？";
String msgString2 = "(这个答案是： \"" + magicWord
+ "\"。)";
Object[] array = {msgString1, msgString2, textField};
Object[] options = {btnString1, btnString2};
//创建对话框
optionPane = new JOptionPane(array,
JOptionPane.QUESTION_MESSAGE,
JOptionPane.YES_NO_OPTION,
null,
options,
options[0]);
//显示对话框
setContentPane(optionPane);
//设置当关闭窗体动作模式
setDefaultCloseOperation(DO_NOTHING_ON_CLOSE);
addWindowListener(new WindowAdapter() {
public void windowClosing(WindowEvent we) {
optionPane.setValue(new Integer(
JOptionPane.CLOSED_OPTION));
}
});
//使的文本输入域得到焦点
addComponentListener(new ComponentAdapter() {
public void componentShown(ComponentEvent ce) {
textField.requestFocusInWindow();
}
});
//给文本域添加监听事件
textField.addActionListener(this);
//监听输入改变
optionPane.addPropertyChangeListener(this);
}
/** 文本域监听处理 */
public void actionPerformed(ActionEvent e) {
optionPane.setValue(btnString1);
}
/** 监听输入的改变 */
public void propertyChange(PropertyChangeEvent e) {
String prop = e.getPropertyName();
if (isVisible()
&& (e.getSource() == optionPane)
&& (JOptionPane.VALUE_PROPERTY.equals(prop) ||
JOptionPane.INPUT_VALUE_PROPERTY.equals(prop))) {
Object value = optionPane.getValue();
if (value == JOptionPane.UNINITIALIZED_VALUE) {
return;
}
optionPane.setValue(
JOptionPane.UNINITIALIZED_VALUE);
if (btnString1.equals(value)) {
typedText = textField.getText();
String ucText = typedText.toUpperCase();
if (magicWord.equals(ucText)) {
//如果输入有效，则清楚文本域并隐藏对话框
clearAndHide();
} else {
//文本输入无效
textField.selectAll();
JOptionPane.showMessageDialog(
CustomDialog.this,
"对不起, \"" + typedText + "\" "
+ "是无效的输入。\n"
+ "请重新输入"
+ magicWord + ".",
"再试一次",
JOptionPane.ERROR_MESSAGE);
typedText = null;
textField.requestFocusInWindow();
}
} else { //用户关闭了对话框或点击了“cancel”
dd.setLabel("好吧！ "
+ "我们不能影响你的决定输入"
+ magicWord + "。");
typedText = null;
clearAndHide();
}
}
}
/**
*方法说明：清楚文本域并隐藏痘翱蝌
*/
public void clearAndHide() {
textField.setText(null);
setVisible(false);
}
}
package test16;
import javax.swing.JOptionPane;
import javax.swing.JDialog;
import javax.swing.JButton;
import javax.swing.JRadioButton;
import javax.swing.ButtonGroup;
import javax.swing.JLabel;
import javax.swing.ImageIcon;
import javax.swing.BoxLayout;
import javax.swing.Box;
import javax.swing.BorderFactory;
import javax.swing.border.Border;
import javax.swing.JTabbedPane;
import javax.swing.JPanel;
import javax.swing.JFrame;
import java.beans.*;
import java.awt.*;
import java.awt.event.*;
/**
*Title: 对话框演示
*Description: 全面的演示各种类型的对话框的使用
*Filename: DialogDemo.java
*/
public class DialogDemo extends JPanel {
private static final long serialVersionUID = 1L;
JLabel label;
ImageIcon icon = createImageIcon("images/middle.gif");
JFrame frame;
String simpleDialogDesc = "简单的信息提示对话窗";
String iconDesc = "带有图标的对话窗";
String moreDialogDesc = "复杂信息对话窗";
CustomDialog customDialog;
/**
*方法说明：构造器，生成一个面板添加到JFrame中
*输入参数：
*返回类型：
*/
public DialogDemo(JFrame frame) {
super(new BorderLayout());
this.frame = frame;
customDialog = new CustomDialog(frame, "tom", this);
customDialog.pack();
//创建成员
JPanel frequentPanel = createSimpleDialogBox();
JPanel featurePanel = createFeatureDialogBox();
JPanel iconPanel = createIconDialogBox();
label = new JLabel("点击\"显示\" 按钮"
+ " 显示一个选择的对话框",
JLabel.CENTER);
//放置对象
Border padding = BorderFactory.createEmptyBorder(20,20,5,20);
frequentPanel.setBorder(padding);
featurePanel.setBorder(padding);
iconPanel.setBorder(padding);
//创建选项卡
JTabbedPane tabbedPane = new JTabbedPane();
tabbedPane.addTab("简单对话窗", null,
frequentPanel,
simpleDialogDesc);
tabbedPane.addTab("复杂对话窗", null,
featurePanel,
moreDialogDesc);
tabbedPane.addTab("图标对话窗", null,
iconPanel,
iconDesc);
add(tabbedPane, BorderLayout.CENTER);
add(label, BorderLayout.PAGE_END);
label.setBorder(BorderFactory.createEmptyBorder(10,10,10,10));
}
/**
*方法说明：设置按钮上的文字
*输入参数：String newText 添加的文字
*返回类型：
*/
void setLabel(String newText) {
label.setText(newText);
}
/**
*方法说明：获取图片
*输入参数：String path 图片完整路径和名字
*返回类型：ImageIcon 图片对象
*/
protected static ImageIcon createImageIcon(String path) {
java.net.URL imgURL = DialogDemo.class.getResource(path);
if (imgURL != null) {
return new ImageIcon(imgURL);
} else {
System.err.println("Couldn't find file: " + path);
return null;
}
}
/**
*方法说明：创建一个JPanel，给第一个选项卡
*输入参数：
*返回类型：
*/
private JPanel createSimpleDialogBox() {
final int numButtons = 4;
JRadioButton[] radioButtons = new JRadioButton[numButtons];
final ButtonGroup group = new ButtonGroup();
JButton showItButton = null;
final String defaultMessageCommand = "default";
final String yesNoCommand = "yesno";
final String yeahNahCommand = "yeahnah";
final String yncCommand = "ync";
//添加单选到数字
radioButtons[0] = new JRadioButton("只有“OK”按钮");
radioButtons[0].setActionCommand(defaultMessageCommand);
radioButtons[1] = new JRadioButton("有“Yes/No”二个按钮");
radioButtons[1].setActionCommand(yesNoCommand);
radioButtons[2] = new JRadioButton("有“Yes/No”两个按钮 "
+ "(程序添加文字)");
radioButtons[2].setActionCommand(yeahNahCommand);
radioButtons[3] = new JRadioButton("有“Yes/No/Cancel”三个按钮 "
+ "(程序添加文字)");
radioButtons[3].setActionCommand(yncCommand);
//将四个单选组成一个群
for (int i = 0; i < numButtons; i++) {
group.add(radioButtons[i]);
}
//设置第一个为默认选择
radioButtons[0].setSelected(true);
//定义“显示”按钮
showItButton = new JButton("显示");
//给“显示”按钮添加监听
showItButton.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
String command = group.getSelection().getActionCommand();
//ok对话窗
if (command == defaultMessageCommand) {
JOptionPane.showMessageDialog(frame,
"鸡蛋不可能是绿色的！");
//yes/no 对话窗
} else if (command == yesNoCommand) {
int n = JOptionPane.showConfirmDialog(
frame, "你喜欢吃酸菜鱼吗?",
"一个很无聊的问题！！",
JOptionPane.YES_NO_OPTION);
if (n == JOptionPane.YES_OPTION) {//选择yes
setLabel("哇！我也是！");
} else if (n == JOptionPane.NO_OPTION) {//选择no
setLabel("唉！我喜欢吃！");
} else {
setLabel("快告诉我吧！");
}
//yes/no (自己输入选项)
} else if (command == yeahNahCommand) {
Object[] options = {"是的", "不喜欢"};
int n = JOptionPane.showOptionDialog(frame,
"你喜欢酸菜鱼吗?",
"又一个无聊的问题！",
JOptionPane.YES_NO_OPTION,
JOptionPane.QUESTION_MESSAGE,
null,
options,
options[0]);
if (n == JOptionPane.YES_OPTION) {
setLabel("你哄人的吧，我也喜欢。");
} else if (n == JOptionPane.NO_OPTION) {
setLabel("其实我也不喜欢！");
} else {
setLabel("这都不肯告诉我，小气鬼！");
}
//yes/no/cancel 对话框
} else if (command == yncCommand) {
Object[] options = {"是的，给我来一份。",
"不，谢谢！",
"不，我要水煮鱼！"};
//构造对话框
int n = JOptionPane.showOptionDialog(frame,
"先生！我们这里有鲜美的酸菜鱼，您需要吗？",
"服务生的问题。",
JOptionPane.YES_NO_CANCEL_OPTION,
JOptionPane.QUESTION_MESSAGE,
null,
options,
options[2]);
if (n == JOptionPane.YES_OPTION) {
setLabel("你要的酸菜鱼来了！");
} else if (n == JOptionPane.NO_OPTION) {
setLabel("好的，你需要其它的。");
} else if (n == JOptionPane.CANCEL_OPTION) {
setLabel("好的，我们给你做水煮鱼！");
} else {
setLabel("对不起！你还没有点菜呢！");
}
}
return;
}
});
return createPane(simpleDialogDesc + ":",
radioButtons,
showItButton);
}
/**
*方法说明：提供给createSimpleDialogBox和createFeatureDialogBox方法
*方法说明：创建带提示信息、一列单选框和“显示”按钮
*输入参数：String description 提示帮助信息
*输入参数：JRadioButton[] radioButtons 单选框组
*输入参数：JButton showButton “显示”按钮
*返回类型：JPanel 添加好的面板
*/
private JPanel createPane(String description,
JRadioButton[] radioButtons,
JButton showButton) {
int numChoices = radioButtons.length;
JPanel box = new JPanel();
JLabel label = new JLabel(description);
box.setLayout(new BoxLayout(box, BoxLayout.PAGE_AXIS));
box.add(label);
//添加radio
for (int i = 0; i < numChoices; i++) {
box.add(radioButtons[i]);
}
JPanel pane = new JPanel(new BorderLayout());
pane.add(box, BorderLayout.PAGE_START);
pane.add(showButton, BorderLayout.PAGE_END);
return pane;
}
/**
*方法说明：提供给createSimpleDialogBox和createFeatureDialogBox方法
*方法说明：创建带提示信息、二列单选框和“显示”按钮
*输入参数：String description 提示帮助信息
*输入参数：JRadioButton[] radioButtons 单选框组
*输入参数：JButton showButton “显示”按钮
*返回类型：JPanel 添加好的面板
*/
private JPanel create2ColPane(String description,
JRadioButton[] radioButtons,
JButton showButton) {
JLabel label = new JLabel(description);
int numPerColumn = radioButtons.length/2;
JPanel grid = new JPanel(new GridLayout(0, 2));
for (int i = 0; i < numPerColumn; i++) {
grid.add(radioButtons[i]);
grid.add(radioButtons[i + numPerColumn]);
}
JPanel box = new JPanel();
box.setLayout(new BoxLayout(box, BoxLayout.PAGE_AXIS));
box.add(label);
grid.setAlignmentX(0.0f);
box.add(grid);
JPanel pane = new JPanel(new BorderLayout());
pane.add(box, BorderLayout.PAGE_START);
pane.add(showButton, BorderLayout.PAGE_END);
return pane;
}
/**
*方法说明：创建第三个选项卡的面板
*方法说明：这里都是实现showMessageDialog类，但是也可以指定图标
*输入参数：
*返回类型：JPanel 构造好的面板
*/
private JPanel createIconDialogBox() {
JButton showItButton = null;
final int numButtons = 6;
JRadioButton[] radioButtons = new JRadioButton[numButtons];
final ButtonGroup group = new ButtonGroup();
final String plainCommand = "plain";
final String infoCommand = "info";
final String questionCommand = "question";
final String errorCommand = "error";
final String warningCommand = "warning";
final String customCommand = "custom";
radioButtons[0] = new JRadioButton("普通（没有图标）");
radioButtons[0].setActionCommand(plainCommand);
radioButtons[1] = new JRadioButton("信息图标");
radioButtons[1].setActionCommand(infoCommand);
radioButtons[2] = new JRadioButton("问题图标");
radioButtons[2].setActionCommand(questionCommand);
radioButtons[3] = new JRadioButton("错误图标");
radioButtons[3].setActionCommand(errorCommand);
radioButtons[4] = new JRadioButton("警告图标");
radioButtons[4].setActionCommand(warningCommand);
radioButtons[5] = new JRadioButton("自定义图标");
radioButtons[5].setActionCommand(customCommand);
for (int i = 0; i < numButtons; i++) {
group.add(radioButtons[i]);
}
radioButtons[0].setSelected(true);
showItButton = new JButton("显示");
showItButton.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
String command = group.getSelection().getActionCommand();
//没有图标
if (command == plainCommand) {
JOptionPane.showMessageDialog(frame,
"水煮鱼里不要放酸菜！",
"无图标",
JOptionPane.PLAIN_MESSAGE);
//信息图标
} else if (command == infoCommand) {
JOptionPane.showMessageDialog(frame,
"水煮鱼里不要放酸菜！",
"信息图标",
JOptionPane.INFORMATION_MESSAGE);
//问题图标
} else if (command == questionCommand) {
JOptionPane.showMessageDialog(frame,
"请你吃饭前洗手，好吗？",
"问题",
JOptionPane.QUESTION_MESSAGE);
//错误图标
} else if (command == errorCommand) {
JOptionPane.showMessageDialog(frame,
"对不起，你的信用卡没有资金了！",
"错误信息",
JOptionPane.ERROR_MESSAGE);
//警告图标
} else if (command == warningCommand) {
JOptionPane.showMessageDialog(frame,
"警告！你严重透支信用卡，请尽快补齐金额！",
"警告信息",
JOptionPane.WARNING_MESSAGE);
//自定义图标
} else if (command == customCommand) {
JOptionPane.showMessageDialog(frame,
"哈哈。我想用什么图标都可以！",
"自定义对话窗",
JOptionPane.INFORMATION_MESSAGE,
icon);
}
}
});
return create2ColPane(iconDesc + ":",
radioButtons,
showItButton);
}
/**
*方法说明：创建一个JPanel，放在第二个选项卡上
*输入参数：
*返回类型：
*/
private JPanel createFeatureDialogBox() {
final int numButtons = 5;
JRadioButton[] radioButtons = new JRadioButton[numButtons];
final ButtonGroup group = new ButtonGroup();
JButton showItButton = null;
//定义操作命令
final String pickOneCommand = "pickone";
final String textEnteredCommand = "textfield";
final String nonAutoCommand = "nonautooption";
final String customOptionCommand = "customoption";
final String nonModalCommand = "nonmodal";
//定义radio数组
radioButtons[0] = new JRadioButton("选择一个");
radioButtons[0].setActionCommand(pickOneCommand);
radioButtons[1] = new JRadioButton("输入信息");
radioButtons[1].setActionCommand(textEnteredCommand);
radioButtons[2] = new JRadioButton("关闭按钮无效");
radioButtons[2].setActionCommand(nonAutoCommand);
radioButtons[3] = new JRadioButton("输入校验"
+ "(用户输入信息)");
radioButtons[3].setActionCommand(customOptionCommand);
radioButtons[4] = new JRadioButton("没有模式");
radioButtons[4].setActionCommand(nonModalCommand);
//合成一个组群
for (int i = 0; i < numButtons; i++) {
group.add(radioButtons[i]);
}
//设置第一个为默认选择
radioButtons[0].setSelected(true);
showItButton = new JButton("显示");
showItButton.addActionListener(new ActionListener() {
@SuppressWarnings("static-access")
public void actionPerformed(ActionEvent e) {
String command = group.getSelection().getActionCommand();
//选择一个
if (command == pickOneCommand) {
Object[] possibilities = {"辣椒", "西红柿", "洋葱"};
//设置对话框
String s = (String)JOptionPane.showInputDialog(
frame, //所属窗体
"请选择项目：\n"
+ "\"鸡蛋炒\"", //输出信息
"客户选择",
JOptionPane.PLAIN_MESSAGE, //对话框模式
icon, //显示图标
possibilities, //选项内容
"辣椒"); //默认选项
//如果有选择
if ((s != null) && (s.length() > 0)) {
setLabel("鸡蛋炒" + s + "!");
return;
}
//如果客户没有选择
setLabel("快点！");
//文本输入
} else if (command == textEnteredCommand) {
String s = (String)JOptionPane.showInputDialog(
frame,
"选择一个配料\n"
+ "\"鸡蛋炒\"",
"客户输入",
JOptionPane.PLAIN_MESSAGE,
icon,
null,
"辣椒");
//如果用户有输入
if ((s != null) && (s.length() > 0)) {
setLabel("你要的是鸡蛋炒" + s + "！");
return;
}
//如果返回的是空或者是null。
setLabel("快些选择！");
//关闭按钮无效
} else if (command == nonAutoCommand) {
//构造一个对话框面板
final JOptionPane optionPane = new JOptionPane(
"关闭这个对话框\n"
+ "请点击下面的按钮\n"
+ "明白吗？",
JOptionPane.QUESTION_MESSAGE,
JOptionPane.YES_NO_OPTION);
JDialog.setDefaultLookAndFeelDecorated(false);
//构造一个对话框
final JDialog dialog = new JDialog(frame,
"点击一个按钮",
true);
//将对话框面板添加到对话框中
dialog.setContentPane(optionPane);
//设置对话框关闭时的操作模式
dialog.setDefaultCloseOperation(
JDialog.DO_NOTHING_ON_CLOSE);
dialog.addWindowListener(new WindowAdapter() {
public void windowClosing(WindowEvent we) { //当点击关闭按钮
setLabel("阻碍用户视图关闭窗体！");
}
});
JDialog.setDefaultLookAndFeelDecorated(true);
optionPane.addPropertyChangeListener(
new PropertyChangeListener() {
public void propertyChange(PropertyChangeEvent e) {
String prop = e.getPropertyName();
if (dialog.isVisible()
&& (e.getSource() == optionPane)
&& (JOptionPane.VALUE_PROPERTY.equals(prop))) {
//如果你要阻止关闭按钮，可以在这里进行处理。
dialog.setVisible(false);
}
}
});
dialog.pack();
dialog.setLocationRelativeTo(frame);
dialog.setVisible(true);
int value = ((Integer)optionPane.getValue()).intValue();
if (value == JOptionPane.YES_OPTION) {
setLabel("好的");
} else if (value == JOptionPane.NO_OPTION) {
setLabel("试图点击关闭按钮来关闭一个不能关闭的对话框！"
+ "你不能！");
} else {
setLabel("窗体可以使用ESC键关闭。");
}
//自己定义版面
} else if (command == customOptionCommand) {
customDialog.setLocationRelativeTo(frame);
customDialog.setVisible(true);
String s = customDialog.getValidatedText();
if (s != null) {
//The text is valid.
setLabel("欢迎你！"
+ "你已经进入了\""
+ s
+ "\"。");
}
//没有模式
} else if (command == nonModalCommand) {
//创建一个对话框
final JDialog dialog = new JDialog(frame,
"一个没有模式的对话框");
//使用html语言来显示信息
JLabel label = new JLabel("<html><p align=center>"
+ "这是一个没有模式的对话框"
+ "你可以使用更多的格式"
+ "甚至可以使用主窗体！");
label.setHorizontalAlignment(JLabel.CENTER);
Font font = label.getFont();
label.setFont(label.getFont().deriveFont(font.PLAIN,
14.0f));
JButton closeButton = new JButton("关闭");
closeButton.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
dialog.setVisible(false);
dialog.dispose();
}
});
JPanel closePanel = new JPanel();
closePanel.setLayout(new BoxLayout(closePanel,
BoxLayout.LINE_AXIS));
closePanel.add(Box.createHorizontalGlue());
closePanel.add(closeButton);
closePanel.setBorder(BorderFactory.
createEmptyBorder(0,0,5,5));
JPanel contentPane = new JPanel(new BorderLayout());
contentPane.add(label, BorderLayout.CENTER);
contentPane.add(closePanel, BorderLayout.PAGE_END);
contentPane.setOpaque(true);
dialog.setContentPane(contentPane);
//显示窗体
dialog.setSize(new Dimension(300, 150));
dialog.setLocationRelativeTo(frame);
dialog.setVisible(true);
}
}
});
return createPane(moreDialogDesc + ":",
radioButtons,
showItButton);
}
public static void main(String[] args) {
JFrame.setDefaultLookAndFeelDecorated(true);
JDialog.setDefaultLookAndFeelDecorated(true);
//创建和设置一个窗体
JFrame frame = new JFrame("DialogDemo");
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
//设置一个面板
Container contentPane = frame.getContentPane();
contentPane.setLayout(new GridLayout(1,1));
contentPane.add(new DialogDemo(frame));
//显示窗体
frame.pack();
frame.setVisible(true);
}
}
package test17;
import java.io.*;
import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
/**
* Title: 文件对话框演示
* Description: 演示打开文件对话框和保存文件对话框，使用了文件过滤。
* Filename: FileChooserDemo.java
*/
public class FileChooserDemo extends JPanel
implements ActionListener {
private static final long serialVersionUID = 1L;
static private final String newline = "\n";
JButton openButton, saveButton;
JTextArea log;
JFileChooser fc;
public FileChooserDemo() {
super(new BorderLayout());
log = new JTextArea(15,40);
log.setMargin(new Insets(10,10,10,10));
log.setEditable(false);
JScrollPane logScrollPane = new JScrollPane(log);
//创建一个文件过滤，使用当前目录
fc = new JFileChooser(".");
//过滤条件在MyFilter类中定义
fc.addChoosableFileFilter(new MyFilter());
openButton = new JButton("打开文件",
createImageIcon("images/Open16.gif"));
openButton.addActionListener(this);
saveButton = new JButton("保存文件",
createImageIcon("images/Save16.gif"));
saveButton.addActionListener(this);
//构建一个面板，添加“打开文件”和“保存文件”
JPanel buttonPanel = new JPanel();
buttonPanel.add(openButton);
buttonPanel.add(saveButton);
add(buttonPanel, BorderLayout.PAGE_START);
add(logScrollPane, BorderLayout.CENTER);
}
/**
*方法说明：事件处理
*输入参数：
*返回类型：
*/
public void actionPerformed(ActionEvent e) {
//当点击“打开文件”按钮
if (e.getSource() == openButton) {
int returnVal = fc.showOpenDialog(FileChooserDemo.this);
if (returnVal == JFileChooser.APPROVE_OPTION) {
File file = fc.getSelectedFile();
//在这里添加一些对文件的处理
log.append("打开文件: " + file.getName() + newline);
} else {
log.append("打开文件被用户取消！" + newline);
}
//点击“保存文件”按钮
} else if (e.getSource() == saveButton) {
int returnVal = fc.showSaveDialog(FileChooserDemo.this);
if (returnVal == JFileChooser.APPROVE_OPTION) {
File file = fc.getSelectedFile();
//在这里添加一些对文件的处理
log.append("保存文件: " + file.getName() + newline);
} else {
log.append("保存文件被用户取消！" + newline);
}
}
}
/**
*方法说明：获取图像对象
*输入参数：String path 图片路径
*返回类型：ImageIcon 图片对象
*/
protected static ImageIcon createImageIcon(String path) {
java.net.URL imgURL = FileChooserDemo.class.getResource(path);
if (imgURL != null) {
return new ImageIcon(imgURL);
} else {
System.err.println("Couldn't find file: " + path);
return null;
}
}
public static void main(String[] args) {
JFrame.setDefaultLookAndFeelDecorated(true);
JDialog.setDefaultLookAndFeelDecorated(true);
//创建窗体
JFrame frame = new JFrame("FileChooserDemo");
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
//创建一个面板
JComponent newContentPane = new FileChooserDemo();
newContentPane.setOpaque(true);
frame.setContentPane(newContentPane);
//显示窗体
frame.pack();
frame.setVisible(true);
}
}
package test17;
import java.io.File;
import javax.swing.filechooser.*;
/**
* Title: 文件过滤器演示
* Description: FileChooserDemo文件使用的文件过滤器
* Filename: MyFilter.java
*/
public class MyFilter extends FileFilter {
@SuppressWarnings("unused")
private String files;
public boolean accept(File f) {
if (f.isDirectory()) {
return true;
}
String extension = getExtension(f);
if (extension != null) {
if (extension.equals("java")) {//定义过滤Java文件
return true;
} else {
return false;
}
}
return false;
}
//过滤器描述
public String getDescription() {
return "Java";
}
/**
*方法说明：获取文件扩展名
*/
public static String getExtension(File f) {
String ext = null;
String s = f.getName();
int i = s.lastIndexOf('.');
if (i > 0 && i < s.length() - 1) {
ext = s.substring(i+1).toLowerCase();
}
return ext;
}
}
package test18;
import javax.swing.*;
import java.awt.*;
import java.awt.event.*;
/**
* Description: 这里演示使用html语言在swing面板上构造显示信息
* Filename: HtmlDemo.java
*/
public class HtmlDemo extends JPanel
implements ActionListener {
private static final long serialVersionUID = 1L;
JLabel theLabel;
JTextArea htmlTextArea;
/**
*方法说明：构造器，描述窗体中的成员
*输入参数：
*返回类型：
*/
public HtmlDemo() {
setLayout(new BoxLayout(this, BoxLayout.LINE_AXIS));
String initialText = "<html>\n" +
"颜色和字体测试:\n" +
"<ul>\n" +
"<li><font color=red>red</font>\n" +
"<li><font color=blue>blue</font>\n" +
"<li><font color=green>green</font>\n" +
"<li><font size=-2>small</font>\n" +
"<li><font size=+2>large</font>\n" +
"<li><i>italic</i>\n" +
"<li><b>bold</b>\n" +
"</ul>\n";
//定义一个文本框
htmlTextArea = new JTextArea(10, 20);
htmlTextArea.setText(initialText);
JScrollPane scrollPane = new JScrollPane(htmlTextArea);
//定义按钮
JButton changeTheLabel = new JButton("改变显示");
changeTheLabel.setMnemonic(KeyEvent.VK_C);
changeTheLabel.setAlignmentX(Component.CENTER_ALIGNMENT);
changeTheLabel.addActionListener(this);
//定义标签
theLabel = new JLabel(initialText) {
private static final long serialVersionUID = 1L;
public Dimension getPreferredSize() {
return new Dimension(200, 200);
}
public Dimension getMinimumSize() {
return new Dimension(200, 200);
}
public Dimension getMaximumSize() {
return new Dimension(200, 200);
}
};
//设置标签的对齐方式
theLabel.setVerticalAlignment(SwingConstants.CENTER);
theLabel.setHorizontalAlignment(SwingConstants.CENTER);
//构造一个带边框的左边的编辑面板
JPanel leftPanel = new JPanel();
leftPanel.setLayout(new BoxLayout(leftPanel, BoxLayout.PAGE_AXIS));
leftPanel.setBorder(BorderFactory.createCompoundBorder(
BorderFactory.createTitledBorder(
"编辑HTML，点击按钮显示结果。"),
BorderFactory.createEmptyBorder(10,10,10,10)));
leftPanel.add(scrollPane);
leftPanel.add(Box.createRigidArea(new Dimension(0,10)));
leftPanel.add(changeTheLabel);
//构造一个带边框的右边显示的面板
JPanel rightPanel = new JPanel();
rightPanel.setLayout(new BoxLayout(rightPanel, BoxLayout.PAGE_AXIS));
rightPanel.setBorder(BorderFactory.createCompoundBorder(
BorderFactory.createTitledBorder("这里使用标签显示HTML结果"),
BorderFactory.createEmptyBorder(10,10,10,10)));
rightPanel.add(theLabel);
setBorder(BorderFactory.createEmptyBorder(10,10,10,10));
add(leftPanel);
add(Box.createRigidArea(new Dimension(10,0)));
add(rightPanel);
}
/**
*方法说明：事件监听，当用户点击按钮触发
*输入参数：
*返回类型：
*/
public void actionPerformed(ActionEvent e) {
theLabel.setText(htmlTextArea.getText());
}
/**
*方法说明：主方法
*输入参数：
*返回类型：
*/
public static void main(String[] args) {
JFrame.setDefaultLookAndFeelDecorated(true);
//创建窗体
JFrame frame = new JFrame("HtmlDemo");
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
//创建面板
JComponent newContentPane = new HtmlDemo();
newContentPane.setOpaque(true);
frame.setContentPane(newContentPane);
//显示窗体
frame.pack();
frame.setVisible(true);
}
}
package test19;
import java.awt.*;
import java.awt.event.*;
import javax.swing.JPopupMenu;
import javax.swing.JMenu;
import javax.swing.JMenuItem;
import javax.swing.JCheckBoxMenuItem;
import javax.swing.JRadioButtonMenuItem;
import javax.swing.ButtonGroup;
import javax.swing.JMenuBar;
import javax.swing.KeyStroke;
import javax.swing.ImageIcon;
import javax.swing.JPanel;
import javax.swing.JTextArea;
import javax.swing.JScrollPane;
import javax.swing.JFrame;
/**
* Title: 菜单演示
* Description: 演示菜单的建立和快捷键的使用。
* Filename: MenuDemo.java
*/
public class MenuDemo implements ActionListener, ItemListener {
JTextArea output;
JScrollPane scrollPane;
String newline = "\n";
/**
*方法说明：组建菜单栏
*输入参数：
*返回类型：
*/
public JMenuBar createMenuBar() {
JMenuBar menuBar;
JMenu menu, submenu;
JMenuItem menuItem;
JRadioButtonMenuItem rbMenuItem;
JCheckBoxMenuItem cbMenuItem;
//定义菜单条
menuBar = new JMenuBar();
//定义第一个菜单
menu = new JMenu("(A)菜单");
menu.setMnemonic(KeyEvent.VK_A);
menuBar.add(menu);
//下面开始定义菜单项
//只有文字
menuItem = new JMenuItem("(O)只有文本的菜单",
KeyEvent.VK_O);
//设置快捷键
menuItem.setAccelerator(KeyStroke.getKeyStroke(
KeyEvent.VK_1, ActionEvent.ALT_MASK));
//添加监听
menuItem.addActionListener(this);
menu.add(menuItem);
//有图标还有文字
ImageIcon icon = createImageIcon("images/middle.gif");
menuItem = new JMenuItem("(B)有图标和文字的菜单", icon);
menuItem.setMnemonic(KeyEvent.VK_B);
menuItem.addActionListener(this);
menu.add(menuItem);
//只有图标
menuItem = new JMenuItem(icon);
menuItem.setMnemonic(KeyEvent.VK_D);
menuItem.addActionListener(this);
menu.add(menuItem);
//定义一组radio button（单选按钮）菜单
menu.addSeparator();
ButtonGroup group = new ButtonGroup();
rbMenuItem = new JRadioButtonMenuItem("(R)使用radio的菜单");
rbMenuItem.setSelected(true);
rbMenuItem.setMnemonic(KeyEvent.VK_R);
group.add(rbMenuItem);
rbMenuItem.addActionListener(this);
menu.add(rbMenuItem);
rbMenuItem = new JRadioButtonMenuItem("(d)另外一个radio菜单");
rbMenuItem.setMnemonic(KeyEvent.VK_D);
group.add(rbMenuItem);
rbMenuItem.addActionListener(this);
menu.add(rbMenuItem);
//定义一组check box（检查盒）菜单
menu.addSeparator();
cbMenuItem = new JCheckBoxMenuItem("(C)使用检查盒的菜单");
cbMenuItem.setMnemonic(KeyEvent.VK_C);
cbMenuItem.addItemListener(this);
menu.add(cbMenuItem);
cbMenuItem = new JCheckBoxMenuItem("(H)另外一个检查盒");
cbMenuItem.setMnemonic(KeyEvent.VK_H);
cbMenuItem.addItemListener(this);
menu.add(cbMenuItem);
//定义一个带子菜单
menu.addSeparator();
submenu = new JMenu("(S)带有子菜单");
submenu.setMnemonic(KeyEvent.VK_S);
//定义子菜单
menuItem = new JMenuItem("这是子菜单");
//定义快捷键
menuItem.setAccelerator(KeyStroke.getKeyStroke(
KeyEvent.VK_2, ActionEvent.ALT_MASK));
menuItem.addActionListener(this);
submenu.add(menuItem);
menuItem = new JMenuItem("子菜单项");
menuItem.addActionListener(this);
submenu.add(menuItem);
menu.add(submenu);
//定义第二个菜单
menu = new JMenu("(N)第二个菜单");
menu.setMnemonic(KeyEvent.VK_N);
menuBar.add(menu);
return menuBar;
}
/**
*方法说明：构建面板
*输入参数：
*返回类型：
*/
public Container createContentPane() {
//构造一个面板
JPanel contentPane = new JPanel(new BorderLayout());
contentPane.setOpaque(true);
//定义一个文本域
output = new JTextArea(5, 30);
output.setEditable(false);
scrollPane = new JScrollPane(output);
//将文本域添加到面板中
contentPane.add(scrollPane, BorderLayout.CENTER);
return contentPane;
}
/**
*方法说明：构建弹出菜单
*输入参数：
*返回类型：
*/
public void createPopupMenu() {
JMenuItem menuItem;
//构件弹出菜单
JPopupMenu popup = new JPopupMenu();
ImageIcon openicon = createImageIcon("images/Open16.gif");
menuItem = new JMenuItem("打开文件",openicon);
menuItem.addActionListener(this);
popup.add(menuItem);
ImageIcon saveicon = createImageIcon("images/Save16.gif");
menuItem = new JMenuItem("保存文件",saveicon);
menuItem.addActionListener(this);
popup.add(menuItem);
//添加一个监听给文本域，以便点击右键时响应
MouseListener popupListener = new PopupListener(popup);
output.addMouseListener(popupListener);
}
/**
*方法说明：监听普通的菜单选择
*输入参数：ActionEvent e 事件
*返回类型：
*/
public void actionPerformed(ActionEvent e) {
JMenuItem source = (JMenuItem)(e.getSource());
String s = "监测事件。"
+ newline
+ " 事件源: " + source.getText()
+ " (选择对象" + getClassName(source) + ")";
output.append(s + newline);
}
/**
*方法说明：监听检查盒菜单选择项
*输入参数：ItemEvent e 检查盒触发的事件
*返回类型：
*/
public void itemStateChanged(ItemEvent e) {
JMenuItem source = (JMenuItem)(e.getSource());
String s = "菜单项监听"
+ newline
+ " 事件源: " + source.getText()
+ " (选择对象 " + getClassName(source) + ")"
+ newline
+ " 新的状态: "
+ ((e.getStateChange() == ItemEvent.SELECTED) ?
"选择":"不选择");
output.append(s + newline);
}
/**
*方法说明：获得类的名字
*输入参数：
*返回类型：
*/
protected String getClassName(Object o) {
String classString = o.getClass().getName();
int dotIndex = classString.lastIndexOf(".");
return classString.substring(dotIndex+1);
}
/**
*方法说明：根据路径查找图片
*输入参数：String path 图片的路径
*返回类型：ImageIcon 图片对象
*/
protected static ImageIcon createImageIcon(String path) {
java.net.URL imgURL = MenuDemo.class.getResource(path);
if (imgURL != null) {
return new ImageIcon(imgURL);
} else {
System.err.println("Couldn't find file: " + path);
return null;
}
}
public static void main(String[] args) {
JFrame.setDefaultLookAndFeelDecorated(true);
//创建一个窗体
JFrame frame = new JFrame("MenuDemo");
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
//创建菜单，并添加到面板中
MenuDemo demo = new MenuDemo();
frame.setJMenuBar(demo.createMenuBar());
frame.setContentPane(demo.createContentPane());
//生成弹出菜单
demo.createPopupMenu();
//显示窗体
frame.setSize(450, 260);
frame.setVisible(true);
}
//弹出菜单监听类
class PopupListener extends MouseAdapter {
JPopupMenu popup;
PopupListener(JPopupMenu popupMenu) {
popup = popupMenu;
}
public void mousePressed(MouseEvent e) {
maybeShowPopup(e);
}
public void mouseReleased(MouseEvent e) {
maybeShowPopup(e);
}
private void maybeShowPopup(MouseEvent e) {
if (e.isPopupTrigger()) {
popup.show(e.getComponent(),
e.getX(), e.getY());
}
}
}
}
package test20;
import javax.swing.JToolBar;
import javax.swing.JButton;
import javax.swing.ImageIcon;
import javax.swing.JFrame;
import javax.swing.JTextArea;
import javax.swing.JScrollPane;
import javax.swing.JPanel;
import java.net.URL;
import java.awt.*;
import java.awt.event.*;
/**
* Title: 工具栏演示
* Description: 提供一个工具栏，包括“打开”、“保存”、“搜索”工具按钮
* Filename: ToolBarDemo.java
*/
public class ToolBarDemo extends JPanel
implements ActionListener {
private static final long serialVersionUID = 1L;
protected JTextArea textArea;
protected String newline = "\n";
static final private String OPEN = "OPEN";
static final private String SAVE = "SAVE";
static final private String SEARCH = "SEARCH";
/**
*方法说明：构造器
*输入参数：
*返回类型：
*/
public ToolBarDemo() {
super(new BorderLayout());
//创建工具栏
JToolBar toolBar = new JToolBar();
addButtons(toolBar);
//创建一个文本域，用来输出一些信息
textArea = new JTextArea(15, 30);
textArea.setEditable(false);
JScrollPane scrollPane = new JScrollPane(textArea);
//安放成员
setPreferredSize(new Dimension(450, 110));
add(toolBar, BorderLayout.PAGE_START);
add(scrollPane, BorderLayout.CENTER);
}
/**
*方法说明：构建工具栏
*输入参数：JToolBar toolBar 工具条
*返回类型：
*/
protected void addButtons(JToolBar toolBar) {
JButton button = null;
//第一个按钮，“打开”
button = makeNavigationButton("Open16", OPEN,
"打开一个文件！",
"打开");
toolBar.add(button);
//第二个按钮，“保存”
button = makeNavigationButton("Save16", SAVE,
"保存当前文件！",
"保存");
toolBar.add(button);
//第三个按钮，“搜索”
button = makeNavigationButton("Search16", SEARCH,
"搜索文件中的字符！",
"搜索");
toolBar.add(button);
}
/**
*方法说明：构造工具栏上的按钮
*输入参数：
*返回类型：
*/
protected JButton makeNavigationButton(String imageName,
String actionCommand,
String toolTipText,
String altText) {
//搜索图片
String imgLocation = "images/"
+ imageName
+ ".gif";
URL imageURL = ToolBarDemo.class.getResource(imgLocation);
//初始化工具按钮
JButton button = new JButton();
//设置按钮的命令
button.setActionCommand(actionCommand);
//设置提示信息
button.setToolTipText(toolTipText);
button.addActionListener(this);
if (imageURL != null) { //找到图像
button.setIcon(new ImageIcon(imageURL));
} else { //没有图像
button.setText(altText);
System.err.println("Resource not found: "
+ imgLocation);
}
return button;
}
/**
*方法说明：事件监听
*输入参数：
*返回类型：
*/
public void actionPerformed(ActionEvent e) {
String cmd = e.getActionCommand();
String description = null;
if (OPEN.equals(cmd)) { //点击第一个按钮
description = "打开一个文件操作！";
} else if (SAVE.equals(cmd)) { //点击第二个按钮
description = "保存文件操作";
} else if (SEARCH.equals(cmd)) { //点击第三个按钮
description = "搜索字符操作";
}
displayResult("如果这里是真正的程序，你将进入： "
+ description);
}
protected void displayResult(String actionDescription) {
textArea.append(actionDescription + newline);
}
public static void main(String[] args) {
JFrame.setDefaultLookAndFeelDecorated(true);
//定义窗体
JFrame frame = new JFrame("ToolBarDemo");
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
//定义面板
ToolBarDemo newContentPane = new ToolBarDemo();
newContentPane.setOpaque(true);
frame.setContentPane(newContentPane);
//显示窗体
frame.pack();
frame.setVisible(true);
}
}
900
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
