Java学习——复习 第八天 Swing程序设计、AWT绘图、事件监听
16.Swing程序设计
1.Swing概述--Swing主要用来开发GUI程序，GUI即图形图像界面，他是应用程序提供给用户操作的图形界面，包括窗口、菜单、按钮等元素。
1.1Swing的特点--允许开发人员跨平台时指定统一的外观和风格，Swing不依赖操作系统，可以在多平台上使用，将Swing组件称为‘轻量级组件’AWT组件则相反比较依赖本地操作系统，所以被称为‘重量级组件’
1.2Swing包
1.3常用Swing组件
2常用窗体
2.1JFrame窗体--是一个容器，是Swing程序中各组件的载体
JFrame类的常用构造方法：
1）public JFrame():创建一个不可见、没有标题的新窗体。
2）public JFrame(String title):创建一个不可见但有标题的窗体
jJFrame常用方法
代码实现：
public classJFreamTest extends JFrame {
publicvoid CreateJFrame(String title) { // 定义一个CreateJFrame()方法
JFramejf = new JFrame(title); // 创建一个JFrame对象
Containercontainer = jf.getContentPane(); // 获取一个容器
JLabeljl = new JLabel("这是一个JFrame窗体"); // 创建一个JLabel标签
//使标签上的文字居中
jl.setHorizontalAlignment(SwingConstants.CENTER);
container.add(jl);// 将标签添加到容器中
container.setBackground(Color.white);// 设置容器的背景颜色
jf.setVisible(true);// 使窗体可视
jf.setSize(200,150); // 设置窗体大小
//设置窗体关闭方式
jf.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
}
publicstatic void main(String args[]) { // 在主方法中调用CreateJFrame()方法
newJFreamTest().CreateJFrame("创建一个JFrame窗体");
}
}
运行结果：
2.2JDialog对话框窗体--是Swing组件中的对话框，功能是从一个窗体中实例化。
常用Jdialog构造类
代码实现：
class MyJDialog extends JDialog { // 创建新类继承JDialog类
privatestatic final long serialVersionUID = 1L;
publicMyJDialog(MyFrame frame) {
//实例化一个JDialog类对象，指定对话框的父窗体、窗体标题和类型
super(frame,"第一个JDialog窗体", true);
Containercontainer = getContentPane(); // 创建一个容器
container.add(newJLabel("这是一个对话框")); // 在容器中添加标签
setBounds(120,120, 100, 100); // 设置对话框窗体大小
}
}
public class MyFrame extends JFrame { //创建新类
privatestatic final long serialVersionUID = 1L;
publicstatic void main(String args[]) {
newMyFrame(); // 实例化MyJDialog类对象
}
publicMyFrame() {
Containercontainer = getContentPane(); // 创建一个容器
container.setLayout(null);
JLabeljl = new JLabel("这是一个JFrame窗体"); // 在窗体中设置标签
//将标签的文字置于标签中间位置
jl.setHorizontalAlignment(SwingConstants.CENTER);
container.add(jl);
JButtonbl = new JButton("弹出对话框"); // 定义一个按钮
bl.setBounds(10,10, 100, 21);
bl.addActionListener(newActionListener() { // 为按钮添加鼠标单击事件
publicvoid actionPerformed(ActionEvent e) {
//使MyJDialog窗体可见
newMyJDialog(MyFrame.this).setVisible(true);
}
});
container.add(bl);// 将按钮添加到容器中
container.add(bl);
container.setBackground(Color.white);
setSize(200,200);
setDefaultCloseOperation(WindowConstants.DISPOSE_ON_CLOSE);
setVisible(true);
}
}
运行结果：
3常用布局管理器：
3.1绝对布局--硬性指定组件在容器中的位置和大小，可以使用绝对坐标来指定组件的位置。
代码实现：
public classAbsolutePosition extends JFrame {
/**
*
*/
privatestatic final long serialVersionUID = 1L;
publicAbsolutePosition() {
setTitle("本窗体使用绝对布局");// 设置该窗体的标题
setLayout(null);// 使该窗体取消布局管理器设置
setBounds(0,0, 200, 150); // 绝对定位窗体的位置与大小
Containerc = getContentPane(); // 创建容器对象
JButtonb1 = new JButton("按钮1"); // 创建按钮
JButtonb2 = new JButton("按钮2"); // 创建按钮
b1.setBounds(10,30, 80, 30); // 设置按钮的位置与大小
b2.setBounds(60,70, 100, 20);
c.add(b1);// 将按钮添加到容器中
c.add(b2);
setVisible(true);// 使窗体可见
//设置窗体关闭方式
setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
}
publicstatic void main(String[] args) {
newAbsolutePosition();
}
}
运行结果：
3.2流布局--最基本的布局管理器，在整个容器中的布局正如其名，像‘流’一样从左到右摆放组件，知道占据这一行的所有空间，在向下移动一行。
代码实现：
public classFlowLayoutPosition extends JFrame {
/**
*
*/
privatestatic final long serialVersionUID = 1L;
publicFlowLayoutPosition() {
setTitle("本窗体使用流布局管理器");// 设置窗体标题
Containerc = getContentPane();
//设置窗体使用流布局管理器，使组件右对齐，并且设置组件之间的水平间隔与垂直间隔
setLayout(newFlowLayout(2, 10, 10));
for(int i = 0; i < 10; i++) { // 在容器中循环添加10个按钮
c.add(newJButton("button" + i));
}
setSize(300,200); // 设置窗体大小
setVisible(true);// 设置窗体可见
//设置窗体关闭方式
setDefaultCloseOperation(WindowConstants.DISPOSE_ON_CLOSE);
}
publicstatic void main(String[] args) {
newFlowLayoutPosition();
}
}
运行结果：
3.3边界布局--默认不指定窗体布局时，Swing指定的布局模式是边界布局
代码实现：
public classBorderLayoutPosition extends JFrame {
publicBorderLayoutPosition() {
setTitle("这个窗体使用边界布局管理器");
Containerc = getContentPane(); // 定义一个容器
setLayout(newBorderLayout()); // 设置容器为边界布局管理器
JButtoncenterBtn = new JButton("中"),
northBtn= new JButton("北"),
southBtn= new JButton("南"),
westBtn= new JButton("西"),
eastBtn= new JButton("东");
c.add(centerBtn,BorderLayout.CENTER);// 中部添加按钮
c.add(northBtn,BorderLayout.NORTH);// 北添加按钮
c.add(southBtn,BorderLayout.SOUTH);// 南部添加按钮
c.add(westBtn,BorderLayout.WEST);// 西部添加按钮
c.add(eastBtn,BorderLayout.EAST);// 东部添加按钮
setSize(350,200); // 设置窗体大小
setVisible(true);// 设置窗体可见
//设置窗体关闭方式
setDefaultCloseOperation(WindowConstants.DISPOSE_ON_CLOSE);
}
publicstatic void main(String[] args) {
newBorderLayoutPosition();
}
}
运行结果：
3.4网格布局--将容器划分为网格，所有组件可以按行和列进行排列
网格布局主要有以下两个构造方法
1）public GridLayout（int rows，int columns）方法。
2）public GridLayout（int rows，int columns，int horizGap，int vertGap）方法。
代码实现：
public classGridLayoutPosition extends JFrame {
/**
*
*/
privatestatic final long serialVersionUID = 1L;
publicGridLayoutPosition() {
Containerc = getContentPane();
//设置容器使用网格布局管理器，设置7行3列的网格
setLayout(newGridLayout(7, 3, 5, 5));
for(int i = 0; i < 20; i++) {
c.add(newJButton("button" + i)); // 循环添加按钮
}
setSize(300,300);
setTitle("这是一个使用网格布局管理器的窗体");
setVisible(true);
setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
}
publicstatic void main(String[] args) {
newGridLayoutPosition();
}
}
运行结果
4常用面板
4.1JPanel面板--是一种容器，他继承java.awt.Container类。
代码实现：
public classJPanelTest extends JFrame {
/**
*
*/
privatestatic final long serialVersionUID = 1L;
publicJPanelTest() {
Containerc = getContentPane();
//将整个容器设置为2行1列的网格布局
c.setLayout(newGridLayout(2, 1, 10, 10));
//初始化一个面板，设置1行3列的网格布局
JPanelp1 = new JPanel(new GridLayout(1, 3, 10, 10));
JPanelp2 = new JPanel(new GridLayout(1, 2, 10, 10));
JPanelp3 = new JPanel(new GridLayout(1, 2, 10, 10));
JPanelp4 = new JPanel(new GridLayout(2, 1, 10, 10));
p1.setBorder(BorderFactory.createTitledBorder("面板1"));
p2.setBorder(BorderFactory.createTitledBorder("面板2"));
p3.setBorder(BorderFactory.createTitledBorder("面板3"));
p4.setBorder(BorderFactory.createTitledBorder("面板4"));
p1.add(newJButton("1")); // 在面板中添加按钮
p1.add(newJButton("1"));
p1.add(newJButton("2"));
p1.add(newJButton("3"));
p2.add(newJButton("4"));
p2.add(newJButton("5"));
p3.add(newJButton("6"));
p3.add(newJButton("7"));
p4.add(newJButton("8"));
p4.add(newJButton("9"));
c.add(p1);// 在容器中添加面板
c.add(p2);
c.add(p3);
c.add(p4);
setTitle("在这个窗体中使用了面板");
setSize(420,200);
setVisible(true);
setDefaultCloseOperation(WindowConstants.DISPOSE_ON_CLOSE);
}
publicstatic void main(String[] args) {
newJPanelTest();
}
}
运行结果：
4.2JScrollPane滚动面板--带滚动条的
代码实现：
public classJScrollPaneTest extends JFrame {
/**
*
*/
privatestatic final long serialVersionUID = 1L;
publicJScrollPaneTest() {
Containerc = getContentPane(); // 创建容器
JTextAreata = new JTextArea(20, 50); // 创建文本区域组件
JScrollPanesp = new JScrollPane(ta); // 创建JScrollPane面板对象
c.add(sp);// 将该面板添加到该容器中
setTitle("带滚动条的文字编译器");
setSize(200,200);
setVisible(true);
setDefaultCloseOperation(WindowConstants.DISPOSE_ON_CLOSE);
}
publicstatic void main(String[] args) {
newJScrollPaneTest();
}
}
运行结果：
5标签组件与图标
5.1JLabel标签组件--简单的显示文本和图片
JLabel的构造方法
5.2图标的使用
1）创建图标
代码实现：
public classDrawIcon implements Icon { // 实现Icon接口
privateint width; // 声明图标的宽
privateint height; // 声明图标的长
publicint getIconHeight() { // 实现getIconHeight()方法
returnthis.height;
}
publicint getIconWidth() { // 实现getIconWidth()方法
returnthis.width;
}
publicDrawIcon(int width, int height) { // 定义构造方法
this.width= width;
this.height= height;
}
//实现paintIcon()方法
publicvoid paintIcon(Component arg0, Graphics arg1, int x, int y){
arg1.fillOval(x,y, width, height); // 绘制一个圆形
}
publicstatic void main(String[] args) {
DrawIconicon = new DrawIcon(15, 15);
//创建一个标签，并设置标签上的文字在标签正中间
JLabelj = new JLabel("测试", icon, SwingConstants.CENTER);
JFramejf = new JFrame(); // 创建一个JFrame窗口
Containerc = jf.getContentPane();
c.add(j);
jf.setSize(100,100);
jf.setVisible(true);
jf.setDefaultCloseOperation(WindowConstants.DISPOSE_ON_CLOSE);
}
}
运行结果：
2）使用图片创建图标
代码实现：
public classMyImageIcon extends JFrame {
privatestatic final long serialVersionUID = 1L;
publicMyImageIcon() {
Containercontainer = getContentPane();
//创建一个标签
JLabeljl = new JLabel("这是一个JFrame窗体", JLabel.CENTER);
//获取图片所在的URL
URLurl = MyImageIcon.class.getResource("imageButton.jpg");
Iconicon = new ImageIcon(url); // 实例化Icon对象
jl.setIcon(icon);// 为标签设置图片
//设置文字放置在标签中间
jl.setHorizontalAlignment(SwingConstants.CENTER);
jl.setOpaque(true);// 设置标签为不透明状态
container.add(jl);// 将标签添加到容器中
setSize(250,100); // 设置窗体大小
setVisible(true);// 使窗体可见
//设置窗体关闭模式
setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
}
publicstatic void main(String args[]) {
newMyImageIcon(); // 实例化MyImageIcon对象
}
}
运行结果：
6文本组件
6.1JTextField文本框组件
代码实现：
public classJTextFieldTest extends JFrame{
/**
*
*/
privatestatic final long serialVersionUID = 1L;
publicJTextFieldTest(){
setSize(250,100);
setDefaultCloseOperation(WindowConstants.DISPOSE_ON_CLOSE);
Containercp=getContentPane();
getContentPane().setLayout(newFlowLayout());
finalJTextField jt=new JTextField("aaa",20);
finalJButton jb=new JButton("清除");
cp.add(jt);
cp.add(jb);
jt.addActionListener(newActionListener(){
publicvoid actionPerformed(ActionEvent arg0) {
//TODO 自动生成方法存根
jt.setText("触发事件");
}
});
jb.addActionListener(newActionListener(){
publicvoid actionPerformed(ActionEvent arg0) {
jt.setText("");
jt.requestFocus();
}
});
setVisible(true);
}
publicstatic void main(String[] args) {
newJTextFieldTest();
}
}
运行结果：
6.2JPasswordField密码框组件--会给里面的内容一个加密显示
JPasswordField常用构造方法：
6.3JTextArea文本域组件
代码实现：
public classJTextAreaTest extends JFrame{
/**
*
*/
privatestatic final long serialVersionUID = 1L;
publicJTextAreaTest(){
setSize(200,100);
setTitle("定义自动换行的文本域");
setDefaultCloseOperation(WindowConstants.DISPOSE_ON_CLOSE);
Containercp=getContentPane();
JTextAreajt=new JTextArea("文本域",6,6);
jt.setLineWrap(true);//可以自动换行
cp.add(jt);
setVisible(true);
}
publicstatic void main(String[] args) {
newJTextAreaTest();
}
}
运行结果
7按钮组件
7.1JButton按钮组件
代码实现：
public classJButtonTest extends JFrame {
/**
*
*/
privatestatic final long serialVersionUID = 1L;
publicJButtonTest() {
URLurl = JButtonTest.class.getResource("imageButtoo.jpg");
Iconicon = new ImageIcon(url);
setLayout(newGridLayout(3, 2, 5, 5)); // 设置网格布局管理器
Containerc = getContentPane(); // 创建容器
for(int i = 0; i < 5; i++) {
//创建按钮，同时设置按钮文字与图标
JButtonJ = new JButton("button" + i, icon);
c.add(J);// 在容器中添加按钮
if(i % 2 == 0) {
J.setEnabled(false);// 设置其中一些按钮不可用
}
}
JButtonjb = new JButton(); // 实例化一个没有文字与图片的按钮
jb.setMaximumSize(newDimension(90, 30)); // 设置按钮与图片相同大小
jb.setIcon(icon);// 为按钮设置图标
jb.setHideActionText(true);
jb.setToolTipText("图片按钮"); //设置按钮提示为文字
jb.setBorderPainted(false);// 设置按钮边界不显示
jb.addActionListener(newActionListener() { // 为按钮添加监听事件
publicvoid actionPerformed(ActionEvent e) {
//弹出确认对话框
JOptionPane.showMessageDialog(null,"弹出对话框");
}
});
c.add(jb);// 将按钮添加到容器中
setTitle("创建带文字与图片的按钮");
setSize(350,150);
setVisible(true);
setDefaultCloseOperation(WindowConstants.DISPOSE_ON_CLOSE);
}
publicstatic void main(String args[]) {
newJButtonTest();
}
}
运行结果：
7.2JRadioButton单选按钮组件
1）单选按钮
2）按钮组--ButtonGroup类表示按钮组，一个按钮组中只能单选一个按钮
代码实现：
public classRadioButtonTest extends JFrame {
publicRadioButtonTest() {
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
setTitle("单选按钮的使用");
setBounds(100,100, 220, 120);
getContentPane().setLayout(null);//设置绝对布局
JLabellblNewLabel = new JLabel("请选择发送方式：");
lblNewLabel.setBounds(5,5, 120, 15);
getContentPane().add(lblNewLabel);
JRadioButtonrbtnNormal = new JRadioButton("普通发送");
rbtnNormal.setSelected(true);
rbtnNormal.setFont(newFont("宋体", Font.PLAIN, 12));
rbtnNormal.setBounds(20,30, 75, 22);
rbtnNormal.addActionListener(newActionListener() {
@Override
publicvoid actionPerformed(ActionEvent arg0) {
//TODO Auto-generated method stub
if(rbtnNormal.isSelected())//判断普通发送单选按钮是否选中
JOptionPane.showMessageDialog(null,
"您选择的是：" + rbtnNormal.getText(),
"提醒",JOptionPane.INFORMATION_MESSAGE);
}
});
getContentPane().add(rbtnNormal);
JRadioButtonrbtnPwd = new JRadioButton("加密发送");
rbtnPwd.setFont(newFont("宋体", Font.PLAIN, 12));
rbtnPwd.setBounds(100,30, 75, 22);
rbtnPwd.addActionListener(newActionListener() {
@Override
publicvoid actionPerformed(ActionEvent arg0) {
//TODO Auto-generated method stub
if(rbtnPwd.isSelected())//判断加密发送单选按钮是否选中
JOptionPane.showMessageDialog(null,
"您选择的是：" + rbtnPwd.getText(),
"提醒",JOptionPane.INFORMATION_MESSAGE);
}
});
getContentPane().add(rbtnPwd);
/**
* 创建按钮组，把交互面板中的单选按钮添加到按钮组中
*/
ButtonGroupgroup = new ButtonGroup();
group.add(rbtnNormal);
group.add(rbtnPwd);
}
publicstatic void main(String[] args) {
RadioButtonTestframe = new RadioButtonTest();//创建窗体对象
frame.setVisible(true);//使窗体可见
}
}
运行结果：
7.3JCheckBox复选框组件--可以进行多选设置
JCheckBox的常用构造方法：
1）public JCheckBox（）：创建一个没有文本，没有图标并且最初未能被选中的复选框
2）public JCheckBox（Icon icon，Boolean checked）：创建一个带图标的复选框，并制定其最初是否处于选定状态
3）public JCheckBox（String text，Boolean checked）：创建一个带文本的复选框，并制定其最初是否处于选定状态
代码实现：
public class CheckBoxTest extends JFrame{
/**
*
*/
privatestatic final long serialVersionUID = 1L;
privateJPanel panel1 = new JPanel();
privateJPanel panel2 = new JPanel();
privateJTextArea jt=new JTextArea(3,10);
privateJCheckBox jc1=new JCheckBox("1");
privateJCheckBox jc2=new JCheckBox("2");
privateJCheckBox jc3=new JCheckBox("3");
publicCheckBoxTest(){
Containerc=getContentPane();
setSize(200,160);
setVisible(true);
setTitle("复选框的使用");
setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
c.setLayout(newBorderLayout());
c.add(panel1,BorderLayout.NORTH);
finalJScrollPane scrollPane = new JScrollPane(jt);
panel1.add(scrollPane);
c.add(panel2,BorderLayout.SOUTH);
panel2.add(jc1);
jc1.addActionListener(newActionListener(){
publicvoid actionPerformed(ActionEvent e){
if(jc1.isSelected())
jt.append("复选框1被选中\n");
}
});
panel2.add(jc2);
jc2.addActionListener(newActionListener(){
publicvoid actionPerformed(ActionEvent e){
if(jc2.isSelected())
jt.append("复选框2被选中\n");
}
});
panel2.add(jc3);
jc3.addActionListener(newActionListener(){
publicvoid actionPerformed(ActionEvent e){
if(jc3.isSelected())
jt.append("复选框3被选中\n");
}
});
}
publicstatic void main(String[] args) {
newCheckBoxTest();
}
运行结果：
8列表组件
8.1JComboBox下来列表组件
JComboBox的常用构造方法
1）public JComboBox（）：创建具有默认数据模型的JComboBox
2）public JComboBox（ComboBox dataModel）：创建一个JComBox，下拉列表中的数据使用ComboBoxModel中的数据，ComboBoxModel是一个用于组合框的数据模型，它具有选择项的概念。
3）public JComboBox（Object[]arrayData）：创建包含指定数组中元素的JComboBox。
4）public JComboBox（Vector vector）：创建包含指定Vector中元素JComboBox，Vector类是一个可增长的对象数组，和数组一样，他包含可以使用整数索引进行访问的组件，但是Vector的大小可以根据需要增大或缩小，以适应创建Vector后进行添加和移除项的操作。
JComboBox常用方法：
代码实现：
public class JComboBoxTest extends JFrame {
publicJComboBoxTest() {
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
setTitle("下拉列表框的使用");
setBounds(100,100, 317, 147);
getContentPane().setLayout(null);//设置绝对布局
JLabellblNewLabel = new JLabel("请选择证件：");
lblNewLabel.setBounds(28,14, 80, 15);
getContentPane().add(lblNewLabel);
JComboBox<String>comboBox = new JComboBox<String>();//创建一个下拉列表框
comboBox.setBounds(110,11, 80, 21);//设置坐标
comboBox.addItem("身份证");//为下拉列表中添加项
comboBox.addItem("军人证");
comboBox.addItem("学生证");
comboBox.addItem("工作证");
comboBox.setEditable(true);
getContentPane().add(comboBox);//将下拉列表添加到容器中
JLabellblResult = new JLabel("");
lblResult.setBounds(0,57, 146, 15);
getContentPane().add(lblResult);
JButtonbtnNewButton = new JButton("确定");
btnNewButton.setBounds(200,10, 67, 23);
getContentPane().add(btnNewButton);
btnNewButton.addActionListener(newActionListener() {//为按钮添加监听事件
@Override
publicvoid actionPerformed(ActionEvent arg0) {
lblResult.setText("您选择的是："+comboBox.getSelectedItem());//获取下拉列表中的选中项
}
});
}
publicstatic void main(String[] args) {
JComboBoxTestframe = new JComboBoxTest();//创建窗体对象
frame.setVisible(true);//使窗体可见
}
}
运行结果：
8.2JList列表框组件
代码实现：
public class JListTest extends JFrame {
publicJListTest() {
Containercp = getContentPane();
cp.setLayout(null);
JTextAreatValue=new JTextArea();
tValue.setLineWrap(true);
tValue.setBounds(115,10, 60, 90);
cp.add(tValue);
JList<String>jl = new JList<>(new MyListModel());
jl.addListSelectionListener(newListSelectionListener() {
@Override
publicvoid valueChanged(ListSelectionEvent arg0) {
//TODO Auto-generated method stub
Object[]values=jl.getSelectedValues();//获取所有选中项
StringstrValue="";
tValue.setText("");//清空文本域
for(inti=0;i<values.length;i++)
tValue.append(values[i]+"\n");//将选中内容显示在文本域中
}
});
JScrollPanejs = new JScrollPane(jl);
js.setBounds(10,10, 100, 100);
cp.add(js);
setTitle("在这个窗体中使用了列表框");
setSize(200,150);
setVisible(true);
setDefaultCloseOperation(WindowConstants.DISPOSE_ON_CLOSE);
}
publicstatic void main(String args[]) {
newJListTest();
}
}
class MyListModel extendsAbstractListModel<String> {// 继承抽象类AbstractListModel
//设置列表框内容
privateString[] contents = { "列表1", "列表2", "列表3", "列表4", "列表5", "列表6" };
publicString getElementAt(int x) {// 重写getElementAt()方法
if(x < contents.length)
returncontents[x++];
else
returnnull;
}
publicint getSize() {// 重写getSize()方法
returncontents.length;
}
}
运行结果：
9常用事件监听
9.1监听事件简介
9.2动作事件监听--动作事件（ActionEvent）监听器是Swing中比较常用的事件监听器，很多组件的动作都会使用它监听
| 事件名称 | 事件源 | 监听借口 | 添加或删除相应类型监听器的方法 |
| ActionEvent | JButton、JList、JTextField等 | ActionListener | addActionListener(); removeActionListener(); |
public class SimpleEvent extends JFrame{
/**
*
*/
privatestatic final long serialVersionUID = 1L;
privateJButton jb=new JButton("我是按钮，单击我");
publicSimpleEvent(){
setLayout(null);
setSize(200,100);
setDefaultCloseOperation(WindowConstants.DISPOSE_ON_CLOSE);
Containercp=getContentPane();
cp.add(jb);
jb.setBounds(10,10,100,30);
jb.addActionListener(newjbAction());
setVisible(true);
}
classjbAction implements ActionListener{
publicvoid actionPerformed(ActionEvent arg0) {
jb.setText("我被单击了");
}
}
publicstatic void main(String[] args) {
newSimpleEvent();
}
}
运行结果：
9.3焦点事件监听器--FocusEvent监听器
| 事件名称 | 事件源 | 监听借口 | 添加或删除相应类型监听器的方法 |
public class FocusEventTest extends JFrame{
private static final long serialVersionUID = 1L;
public FocusEventTest() {
setSize(250,100);
setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
Container cp=getContentPane();
getContentPane().setLayout(new FlowLayout());
final JLabel label = new JLabel();
getContentPane().add(label);
JTextField jt=new JTextField("请单击其他文本框",10);
JTextField jt2=new JTextField("请单击我",10);
cp.add(jt);
cp.add(jt2);
jt.addFocusListener(new FocusListener(){
//组件失去焦点时调用的方法
public void focusLost(FocusEvent arg0) {
JOptionPane.showMessageDialog(null, "文本框失去焦点");
}
//组件获取键盘焦点时调用的方法
public void focusGained(FocusEvent arg0) {
}
});
setVisible(true);
}
public static void main(String[] args) {
new FocusEventTest();
}
}
运行结果：
17.AWT绘图
1.Java绘图基础
1.1Graphics类
1.2Graphics2D类
1.3Canvas类
2.绘制几何图形—使用不同的方法绘制不同的图形
Java中绘制图形的基本步骤：
代码实现：
public classDrawTest extends JFrame {
publicDrawTest() {
super();
initialize();//调用初始化方法
}
//初始化方法
privatevoid initialize() {
this.setSize(300,200); // 设置窗体大小
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);// 设置窗体关闭模式
add(newCanvasTest ()); // 设置窗体面板为绘图面板对象
this.setTitle("绘制几何图形");// 设置窗体标题
}
publicstatic void main(String[] args) {
newDrawTest().setVisible(true);
}
classCanvasTest extends Canvas{// 创建画布
publicvoid paint(Graphics g) {
super.paint(g);
Graphics2Dg2 = (Graphics2D) g;// 创建Graphics2D对象，用于画图
g2.drawOval(5,5, 100, 100);// 调用从Graphics类继承的drawOval方法绘制圆形
g2.fillRect(15,15, 80, 80);// 调用从Graphics类继承的fillRect方法填充矩形
Shape[]shapes = new Shape[2]; // 声明图形数组
shapes[0]= new Rectangle2D.Double(110, 5, 100, 100); // 创建矩形对象
shapes[1]= new Ellipse2D.Double(120, 15, 80, 80); // 创建圆形对象
for(Shape shape : shapes) { // 遍历图形数组
Rectangle2Dbounds = shape.getBounds2D();
if(bounds.getWidth() == 80)
g2.fill(shape);// 填充图形
else
g2.draw(shape);// 绘制图形
}
}
}
}
运行结果：
3.设置颜色和画笔—Java中使用java.awt.Color类封装颜色的各种属性，并对颜色进行管理
3.1设置颜色—使用Color类可以创建任何颜色的对象，java以跨平台支持颜色管理
Color类定义常用色彩的常量值如下表
代码实现：
import java.awt.*;
import javax.swing.*;
public class ColorTest extends JFrame {
publicColorTest() {
super();
initialize();//调用初始化方法
}
privatevoid initialize() { // 初始化方法
this.setSize(300,200); // 设置窗体大小
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);// 设置窗体关闭模式
add(newCanvasTest()); // 设置窗体面板为绘图面板对象
this.setTitle("设置颜色");// 设置窗体标题
}
publicstatic void main(String[] args) {
newColorTest().setVisible(true);
}
classCanvasTest extends Canvas {// 创建画布
publicvoid paint(Graphics g) {
super.paint(g);
Graphics2Dg2 = (Graphics2D) g;// 创建Graphics2D对象，用于画图
g2.setColor(Color.RED);//设置颜色为红色
g2.drawLine(5,30, 100, 30);// 调用从Graphics类继承的drawLine方法绘制直线
}
}
}
运行结果
3.2设置画笔—调用Stroke接口设置画笔属性
常用构造方法
代码实现：
public class StrokeTest extendsJFrame {
publicStrokeTest() {
super();
initialize();//调用初始化方法
}
private voidinitialize() { // 初始化方法
this.setSize(300,200); // 设置窗体大小
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);// 设置窗体关闭模式
add(newCanvasTest()); // 设置窗体面板为绘图面板对象
this.setTitle("设置画笔");// 设置窗体标题
}
public staticvoid main(String[] args) {
newStrokeTest().setVisible(true);
}
class CanvasTestextends Canvas {// 创建画布
public voidpaint(Graphics g) {
super.paint(g);
Graphics2Dg2 = (Graphics2D) g;// 创建Graphics2D对象，用于画图
//创建画笔，宽度为8
Strokestroke=new BasicStroke(8);
g2.setStroke(stroke);//设置画笔
g2.drawLine(20,30, 120, 30);// 调用从Graphics类继承的drawLine方法绘制直线
//创建画笔，宽度为12，线端点的装饰为CAP_ROUND，应用在路径线段交汇处的装饰为JOIN_BEVEL
StrokeroundStroke=new BasicStroke(12,BasicStroke.CAP_ROUND,BasicStroke.JOIN_BEVEL);
g2.setStroke(roundStroke);
g2.drawLine(20,50, 120, 50);// 调用从Graphics类继承的drawLine方法绘制直线
}
}
}
运行结果：
4.绘制文本
4.1.设置字体—Font类中封装了字体的大小，样式等属性
语法：Font（String name，int style，int size），用来指定字体的名称、样式，大小
4.2绘制文字—使用drawString方法可以实现绘制文字的功能
代码实现：
import java.awt.*;
import javax.swing.*;
public class DrawStringTest extends JFrame {
public DrawStringTest(){
this.setSize(310,140); // 设置窗体大小
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);// 设置窗体关闭模式
add(newCanvasTest()); // 设置窗体面板为绘图面板对象
this.setTitle("绘制文本");// 设置窗体标题
}
public static voidmain(String[] args) {
newDrawStringTest().setVisible(true);
}
class CanvasTestextends Canvas {//创建画布
public voidpaint(Graphics g) {//重写paint方法
super.paint(g);
Graphics2Dg2 = (Graphics2D) g;//创建绘图对象
g2.setColor(Color.BLUE);// 设置当前绘图颜色
Fontfont = new Font("宋体", Font.BOLD, 16);// 字体对象
g2.setFont(font);// 设置字体
g2.drawString("Doneis better than perfect.", 20, 30); // 绘制文本
g2.drawString("——比完美更重要的是完成。",60, 60); // 绘制时间文本
}
}
}
运行结果
5.图像处理
5.1绘制图像—绘制图像是须使用drawImage()方法，该方法可以用来将图像资源显示到绘图的上下文中
drawImage(Image img，int x，int y，ImageObserver observe)；
代码实现：
import java.awt.*;
import javax.swing.*;
public class DrawImageTest extends JFrame {
public DrawImageTest(){
this.setSize(500,380); // 设置窗体大小
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);// 设置窗体关闭模式
add(newCanvasTest()); // 设置窗体面板为绘图面板对象
this.setTitle("绘制图像");// 设置窗体标题
}
public static voidmain(String[] args) {
newDrawImageTest().setVisible(true);//使窗体可见
}
class CanvasTestextends Canvas {// 创建画布
public voidpaint(Graphics g) {
super.paint(g);
Graphics2Dg2 = (Graphics2D) g;// 创建绘图对象
Imageimg = new ImageIcon("src/img.png").getImage(); // 获取图片资源
g2.drawImage(img,0, 0, this); // 显示图像
}
}
}
运行结果：
5.2图像缩放—需要重载drawImage()方法
drawImage(Image img，int x，int y，int width，int height，ImageObserver observe)；
代码实现：
public class ZoomImage extendsJFrame {
private intimgWidth, imgHeight;// 定义图像的宽和高
private doublenum;// 图片变化增量
private JPaneljPanImg = null;// 显示图像的面板
private JPaneljPanBtn = null;// 显示控制按钮的面板
private JButtonjBtnBig = null;// 放大按钮
private JButtonjBtnSmall = null;// 缩小按钮
privateCanvasTest canvas = null;// 绘图面板
publicZoomImage() {
initialize();// 调用初始化方法
}
private voidinitialize() {// 界面初始化方法
this.setBounds(100,100, 500, 420); // 设置窗体大小和位置
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);// 设置窗体关闭模式
this.setTitle("图像缩放");// 设置窗体标题
jPanImg = newJPanel();// 主容器面板
canvas = newCanvasTest();// 获取画布
jPanImg.setLayout(newBorderLayout());// 主容器面板
jPanImg.add(canvas,BorderLayout.CENTER);// 将画布放到面板中央
setContentPane(jPanImg);//将主容器面板作为窗体容器
jBtnBig = newJButton("放大(+)");// 放大按钮
jBtnBig.addActionListener(newjava.awt.event.ActionListener() {
publicvoid actionPerformed(java.awt.event.ActionEvent e) {
num+= 20;// 设置正整数增量，每次点击图片宽高加20
canvas.repaint();//重绘放大的图像
}
});
jBtnSmall = newJButton("缩小(-)");// 缩小按钮
jBtnSmall.addActionListener(newjava.awt.event.ActionListener() {
publicvoid actionPerformed(java.awt.event.ActionEvent e) {
num-= 20;// 设置负整数增量，每次点击图片宽高减20
canvas.repaint();//重绘缩小的图像
}
});
jPanBtn = newJPanel();// 按钮面板
jPanBtn.setLayout(newFlowLayout());// 采用刘布局
jPanBtn.add(jBtnBig);//添加按钮
jPanBtn.add(jBtnSmall);//添加按钮
jPanImg.add(jPanBtn,BorderLayout.SOUTH);// 放到容器底部
}
public staticvoid main(String[] args) {// 主方法
newZoomImage().setVisible(true);// 创建主类对象并显示窗体
}
class CanvasTestextends Canvas {// 创建画布
public voidpaint(Graphics g) {// 重写paint方法，用来重绘图像
Imageimg = new ImageIcon("src/img.png").getImage(); // 获取图片资源
imgWidth= img.getWidth(this); // 获取图像宽度
imgHeight= img.getHeight(this); // 获取图像高度
intnewW = (int) (imgWidth + num); // 计算图像放大后的宽度
intnewH = (int) (imgHeight + num); // 计算图像放大后的高度
g.drawImage(img,0, 0, newW, newH, this); // 绘制指定大小的图像
}
}
}
运行结果：
5.3图像翻转--需要另一种重载drawImage()方法
drawImage(Image img，int dx1，int dy1，int dx2，int dy2，int sx1，int sy1，int dx2，int sy2,ImageObserver observe)；
代码实现：
public class PartImage extendsJFrame {
private intdx1, dy1, dx2, dy2;// 目标矩形两个角的x、y坐标
private intsx1, sy1, sx2, sy2;// 源矩形两个角的x、y坐标
private finalint origin, width, high;// 分别记录原点、图片宽、高的三个常量
private Imageimg;// 图片
private JPaneljPanImg = null;// 显示图像的面板
private JPaneljPanBtn = null;// 显示控制按钮的面板
private JButtonjBtnHor = null;// 水平翻转按钮
private JButtonjBtnVer = null;// 垂直翻转按钮
privateCanvasTest canvas = null;
publicPartImage() {
img = newImageIcon("src/img.png").getImage();// 获取图像资源
origin = 0;// 原点坐标为0
width =img.getWidth(this);// 获取图片宽度，输入任意参数
high =img.getHeight(this);// 获取图片高度，输入任意参数
dx1 = sx1 =origin;// 初始化目标矩形和源矩形的左上角的x坐标都为0
dy1 = sy1 =origin;// 初始化目标矩形和源矩形的左上角的y坐标都为0
dx2 = sx2 =width; // 初始化目标矩形和源矩形的右下角的x坐标都为图像宽度
dy2 = sy2 =high; // 初始化目标矩形和源矩形的右下角的y坐标都为图像高度
initialize();// 调用初始化方法
}
private voidinitialize() {// 界面初始化方法
this.setBounds(100,100, 550, 480); // 设置窗体大小和位置
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);// 设置窗体关闭模式
this.setTitle("图像翻转");// 设置窗体标题
jPanImg = newJPanel();// 获取内容面板的方法
canvas = newCanvasTest();// 获取画布
jPanImg.setLayout(newBorderLayout());// 设为边界布局
jPanImg.add(canvas,BorderLayout.CENTER);// 将画布添加到内容面板中
this.setContentPane(jPanImg);//内容面板作为窗体容器
jBtnHor = newJButton();// 获取水平翻转按钮
jBtnHor.setText("水平翻转");
jBtnHor.addActionListener(newjava.awt.event.ActionListener() {
publicvoid actionPerformed(java.awt.event.ActionEvent e) {
dx1= Math.abs(dx1 - width);// 第一个点的目标位置横坐标与图片宽度相减，取绝对值
dx2= Math.abs(dx2 - width);// 第二个点的目标位置横坐标与图片宽度相减，取绝对值
canvas.repaint();//重绘图像
}
});
jBtnVer = newJButton();// 获取垂直翻转按钮
jBtnVer.setText("垂直翻转");
jBtnVer.addActionListener(newjava.awt.event.ActionListener() {
publicvoid actionPerformed(java.awt.event.ActionEvent e) {
dy1= Math.abs(dy1 - high);// 第一个点的目标位置纵坐标与图片高度相减，取绝对值
dy2= Math.abs(dy2 - high);// 第二个点的目标位置纵坐标与图片高度相减，取绝对值
canvas.repaint();//重绘图像
}
});
jPanBtn = newJPanel();// 获取按钮控制面板的方法
jPanBtn.setLayout(newFlowLayout());// 设为边流布局
jPanBtn.add(jBtnHor);//添加按钮
jPanBtn.add(jBtnVer);
jPanImg.add(jPanBtn,BorderLayout.SOUTH);// 按钮面板放到主面板最下端
}
public staticvoid main(String[] args) {// 主方法
newPartImage().setVisible(true);// 使窗体可见
}
class CanvasTestextends Canvas {// 创建画布
public voidpaint(Graphics g) {// 重写paint方法，以便重绘图像
g.drawImage(img,dx1, dy1, dx2, dy2, sx1, sy1, sx2, sy2, this);// 绘制指定大小的图像
}
}
}
运行结果：
5.4图像旋转—调用Graphics2D类的rotate()方法，根据指定的弧度旋转对象
语法：rotate（double theta）theta：旋转的弧度。
代码实现：
public class RotateImage extendsJFrame {
publicRotateImage() {
initialize();// 调用初始化方法
}
// 界面初始化方法
private voidinitialize() {
CanvasTestcanvasl = new CanvasTest();// 创建画布对象
this.setBounds(100,100, 400, 350); // 设置窗体大小和位置
add(canvasl);//将画布对象显示在窗体中
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);// 设置窗体关闭模式
this.setTitle("图像旋转");// 设置窗体标题
}
public staticvoid main(String[] args) {
newRotateImage().setVisible(true);// 使窗体可见
}
class CanvasTestextends Canvas {// 创建画布
public voidpaint(Graphics g) {// 重写方法，以便重绘图像
Graphics2Dg2 = (Graphics2D) g;// 创建绘图对象
Imageimg = new ImageIcon("src/img.png").getImage(); // 获取图像资源
g2.rotate(Math.toRadians(5));//设置旋转弧度
g2.drawImage(img,70, 10, 300, 200, this);// 绘制指定大小的图像
g2.rotate(Math.toRadians(5));//设置旋转弧度
g2.drawImage(img,70, 10, 300, 200, this);// 绘制指定大小的图像
g2.rotate(Math.toRadians(5));//设置旋转弧度
g2.drawImage(img,70, 10, 300, 200, this);// 绘制指定大小的图像
}
}
}
运行结果：
5.5图像倾斜--调用Graphics2D类的shear()方法，可以设置绘图的倾斜方向
语法：publicabstract void shear（double shx，double shy）shx：水平方向的倾斜量，shy：垂直方向的倾斜量
代码实现：
public class TiltImage extendsJFrame {
publicTiltImage() {
initialize(); //调用初始化方法
}
private voidinitialize() {// 界面初始化方法
CanvasTest canvas= new CanvasTest();// 创建画布对象
this.setBounds(100,100, 380, 260); // 设置窗体大小和位置
add(canvas);//将画布对象显示在窗体中
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);// 设置窗体关闭模式
this.setTitle("图像倾斜"); //设置窗体标题
}
public staticvoid main(String[] args) {
newTiltImage().setVisible(true);// 使窗体可见
}
class CanvasTestextends Canvas {// 创建画布
public voidpaint(Graphics g) {// 重写方法，以便重绘图像
Graphics2Dg2 = (Graphics2D) g;// 创建绘图对象
Image img= new ImageIcon("src/img.png").getImage(); // 获取图像资源
g2.shear(0.3,0);// 设置倾斜量
g2.drawImage(img,0, 0, 300, 200, this);// 绘制指定大小的图像
}
}
}
运行结果：
18.事件监听
1键盘事件
代码实现：
/**
* 虚拟键盘(键盘的按下与释放)
*/
public classKeyBoard extends JFrame { //创建“键盘”类继承JFrame
//声明窗体中的成员组件
privateJPanel contentPane;
privateJTextField textField;
privateJButton btnQ;
privateJButton btnW;
privateJButton btnE;
privateJButton btnR;
privateJButton btnT;
privateJButton btnY;
privateJButton btnU;
privateJButton btnI;
privateJButton btnO;
privateJButton btnP;
privateJButton btnA;
privateJButton btnS;
privateJButton btnD;
privateJButton btnF;
privateJButton btnG;
privateJButton btnH;
privateJButton btnJ;
privateJButton btnK;
privateJButton btnL;
privateJButton btnZ;
privateJButton btnX;
privateJButton btnC;
privateJButton btnV;
privateJButton btnB;
privateJButton btnN;
privateJButton btnM;
Colorgreen=Color.GREEN;//定义Color对象，用来表示按下键的颜色
Colorwhite=Color.WHITE;//定义Color对象，用来表示释放键的颜色
ArrayList<JButton>btns=new ArrayList<JButton>();//定义一个集合，用来存储所有的按键ID
//自定义一个方法，用来将容器中的所有JButton组件添加到集合中
privatevoid addButtons(){
for(Componentcmp :contentPane.getComponents()){//遍历面板中的所有组件
if(cmpinstanceof JButton){//判断组件的类型是否为JButton类型
btns.add((JButton)cmp);//将JButton组件添加到集合中
}
}
}
/**
* 主方法
*/
publicstatic void main(String[] args) {
EventQueue.invokeLater(newRunnable() { //使得Runnable中的的run()方法在the system EventQueue的指派线程中被调用
publicvoid run() {
try{
KeyBoardframe = new KeyBoard(); //创建KeyBoard对象
frame.setVisible(true);//使frame可视
frame.addButtons();//初始化存储所有按键的集合
}catch (Exception e) {
e.printStackTrace();
}
}
});
}
/**
* 创建JFrame窗体
*/
publicKeyBoard() { //KeyBoard的构造方法
setTitle("\u865A\u62DF\u952E\u76D8\uFF08\u6A21\u62DF\u952E\u76D8\u7684\u6309\u4E0B\u4E0E\u91CA\u653E\uFF09");//设置窗体题目
setResizable(false);//不可改变窗体宽高
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);//设置窗体关闭的方式
setBounds(100,100, 548, 280); //设置窗体的位置和宽高
/**
* 创建JPanel面板contentPane置于JFrame窗体中，并设置面板的背景色、边距和布局
*/
contentPane= new JPanel();
contentPane.setBackground(Color.WHITE);
contentPane.setBorder(newEmptyBorder(5, 5, 5, 5));
setContentPane(contentPane);
contentPane.setLayout(null);
/**
* 创建按钮button置于面板contentPane中，设置按钮的背景色、位置、宽高以及按钮中的字体位置、内容、样式
*/
btnQ= new JButton("Q");
btnQ.setBackground(white);
btnQ.setVerticalAlignment(SwingConstants.TOP);
btnQ.setHorizontalAlignment(SwingConstants.LEADING);
btnQ.setFont(newFont("Times New Roman", Font.PLAIN, 16));
btnQ.setBounds(0,60, 47, 45);
contentPane.add(btnQ);
/**
* 创建按钮button_2置于面板contentPane中，设置按钮的背景色、位置、宽高以及按钮中的字体位置、内容、样式
*/
btnW= new JButton("W");
btnW.setBackground(white);
btnW.setVerticalAlignment(SwingConstants.TOP);
btnW.setHorizontalAlignment(SwingConstants.LEADING);
btnW.setFont(newFont("Times New Roman", Font.PLAIN, 16));
btnW.setBounds(55,60, 49, 45);
contentPane.add(btnW);
/**
* 创建按钮button_3置于面板contentPane中，设置按钮的背景色、位置、宽高以及按钮中的字体位置、内容、样式
*/
btnE= new JButton("E");
btnE.setBackground(white);
btnE.setVerticalAlignment(SwingConstants.TOP);
btnE.setHorizontalAlignment(SwingConstants.LEADING);
btnE.setFont(newFont("Times New Roman", Font.PLAIN, 16));
btnE.setBounds(110,60, 45, 45);
contentPane.add(btnE);
/**
* 创建按钮button_4置于面板contentPane中，设置按钮的背景色、位置、宽高以及按钮中的字体位置、内容、样式
*/
btnR= new JButton("R");
btnR.setBackground(white);
btnR.setVerticalAlignment(SwingConstants.TOP);
btnR.setHorizontalAlignment(SwingConstants.LEADING);
btnR.setFont(newFont("Times New Roman", Font.PLAIN, 16));
btnR.setBounds(165,60, 45, 45);
contentPane.add(btnR);
/**
* 创建按钮button_5置于面板contentPane中，设置按钮的背景色、位置、宽高以及按钮中的字体位置、内容、样式
*/
btnF= new JButton("F");
btnF.setBackground(white);
btnF.setVerticalAlignment(SwingConstants.TOP);
btnF.setHorizontalAlignment(SwingConstants.LEADING);
btnF.setFont(newFont("Times New Roman", Font.PLAIN, 16));
btnF.setBounds(195,125, 45, 45);
contentPane.add(btnF);
/**
* 创建按钮button_6置于面板contentPane中，设置按钮的背景色、位置、宽高以及按钮中的字体位置、内容、样式
*/
btnD= new JButton("D");
btnD.setBackground(white);
btnD.setVerticalAlignment(SwingConstants.TOP);
btnD.setHorizontalAlignment(SwingConstants.LEADING);
btnD.setFont(newFont("Times New Roman", Font.PLAIN, 16));
btnD.setBounds(137,125, 45, 45);
contentPane.add(btnD);
btnT= new JButton("T");
btnT.setVerticalAlignment(SwingConstants.TOP);
btnT.setHorizontalAlignment(SwingConstants.LEADING);
btnT.setFont(newFont("Times New Roman", Font.PLAIN, 16));
btnT.setBackground(white);
btnT.setBounds(220,60, 45, 45);
contentPane.add(btnT);
btnY= new JButton("Y");
btnY.setVerticalAlignment(SwingConstants.TOP);
btnY.setHorizontalAlignment(SwingConstants.LEADING);
btnY.setFont(newFont("Times New Roman", Font.PLAIN, 16));
btnY.setBackground(white);
btnY.setBounds(275,60, 45, 45);
contentPane.add(btnY);
btnU= new JButton("U");
btnU.setVerticalAlignment(SwingConstants.TOP);
btnU.setHorizontalAlignment(SwingConstants.LEADING);
btnU.setFont(newFont("Times New Roman", Font.PLAIN, 16));
btnU.setBackground(white);
btnU.setBounds(330,60, 45, 45);
contentPane.add(btnU);
btnI= new JButton("I");
btnI.setVerticalAlignment(SwingConstants.TOP);
btnI.setHorizontalAlignment(SwingConstants.LEADING);
btnI.setFont(newFont("Times New Roman", Font.PLAIN, 16));
btnI.setBackground(white);
btnI.setBounds(385,60, 45, 45);
contentPane.add(btnI);
btnO= new JButton("O");
btnO.setVerticalAlignment(SwingConstants.TOP);
btnO.setHorizontalAlignment(SwingConstants.LEADING);
btnO.setFont(newFont("Times New Roman", Font.PLAIN, 16));
btnO.setBackground(white);
btnO.setBounds(440,60, 46, 45);
contentPane.add(btnO);
btnP= new JButton("P");
btnP.setVerticalAlignment(SwingConstants.TOP);
btnP.setHorizontalAlignment(SwingConstants.LEADING);
btnP.setFont(newFont("Times New Roman", Font.PLAIN, 16));
btnP.setBackground(white);
btnP.setBounds(495,60, 45, 45);
contentPane.add(btnP);
btnA= new JButton("A");
btnA.setVerticalAlignment(SwingConstants.TOP);
btnA.setHorizontalAlignment(SwingConstants.LEADING);
btnA.setFont(newFont("Times New Roman", Font.PLAIN, 16));
btnA.setBackground(white);
btnA.setBounds(23,125, 45, 45);
contentPane.add(btnA);
btnS= new JButton("S");
btnS.setVerticalAlignment(SwingConstants.TOP);
btnS.setHorizontalAlignment(SwingConstants.LEADING);
btnS.setFont(newFont("Times New Roman", Font.PLAIN, 16));
btnS.setBackground(white);
btnS.setBounds(82,125, 45, 45);
contentPane.add(btnS);
btnG= new JButton("G");
btnG.setVerticalAlignment(SwingConstants.TOP);
btnG.setHorizontalAlignment(SwingConstants.LEADING);
btnG.setFont(newFont("Times New Roman", Font.PLAIN, 16));
btnG.setBackground(white);
btnG.setBounds(251,125, 45, 45);
contentPane.add(btnG);
btnH= new JButton("H");
btnH.setVerticalAlignment(SwingConstants.TOP);
btnH.setHorizontalAlignment(SwingConstants.LEADING);
btnH.setFont(newFont("Times New Roman", Font.PLAIN, 16));
btnH.setBackground(white);
btnH.setBounds(306,125, 45, 45);
contentPane.add(btnH);
btnJ= new JButton("J");
btnJ.setVerticalAlignment(SwingConstants.TOP);
btnJ.setHorizontalAlignment(SwingConstants.LEADING);
btnJ.setFont(newFont("Times New Roman", Font.PLAIN, 16));
btnJ.setBackground(white);
btnJ.setBounds(361,125, 45, 45);
contentPane.add(btnJ);
btnK= new JButton("K");
btnK.setVerticalAlignment(SwingConstants.TOP);
btnK.setHorizontalAlignment(SwingConstants.LEADING);
btnK.setFont(newFont("Times New Roman", Font.PLAIN, 16));
btnK.setBackground(white);
btnK.setBounds(416,125, 47, 45);
contentPane.add(btnK);
btnL= new JButton("L");
btnL.setVerticalAlignment(SwingConstants.TOP);
btnL.setHorizontalAlignment(SwingConstants.LEADING);
btnL.setFont(newFont("Times New Roman", Font.PLAIN, 16));
btnL.setBackground(white);
btnL.setBounds(471,125, 45, 45);
contentPane.add(btnL);
btnZ= new JButton("Z");
btnZ.setVerticalAlignment(SwingConstants.TOP);
btnZ.setHorizontalAlignment(SwingConstants.LEADING);
btnZ.setFont(newFont("Times New Roman", Font.PLAIN, 16));
btnZ.setBackground(white);
btnZ.setBounds(39,190, 45, 45);
contentPane.add(btnZ);
btnX= new JButton("X");
btnX.setVerticalAlignment(SwingConstants.TOP);
btnX.setHorizontalAlignment(SwingConstants.LEADING);
btnX.setFont(newFont("Times New Roman", Font.PLAIN, 16));
btnX.setBackground(white);
btnX.setBounds(107,190, 45, 45);
contentPane.add(btnX);
btnC= new JButton("C");
btnC.setVerticalAlignment(SwingConstants.TOP);
btnC.setHorizontalAlignment(SwingConstants.LEADING);
btnC.setFont(newFont("Times New Roman", Font.PLAIN, 16));
btnC.setBackground(white);
btnC.setBounds(178,190, 45, 45);
contentPane.add(btnC);
btnV= new JButton("V");
btnV.setVerticalAlignment(SwingConstants.TOP);
btnV.setHorizontalAlignment(SwingConstants.LEADING);
btnV.setFont(newFont("Times New Roman", Font.PLAIN, 16));
btnV.setBackground(white);
btnV.setBounds(250,190, 45, 45);
contentPane.add(btnV);
btnB= new JButton("B");
btnB.setVerticalAlignment(SwingConstants.TOP);
btnB.setHorizontalAlignment(SwingConstants.LEADING);
btnB.setFont(newFont("Times New Roman", Font.PLAIN, 16));
btnB.setBackground(white);
btnB.setBounds(315,190, 45, 45);
contentPane.add(btnB);
btnN= new JButton("N");
btnN.setVerticalAlignment(SwingConstants.TOP);
btnN.setHorizontalAlignment(SwingConstants.LEADING);
btnN.setFont(newFont("Times New Roman", Font.PLAIN, 16));
btnN.setBackground(white);
btnN.setBounds(382,190, 47, 45);
contentPane.add(btnN);
btnM= new JButton("M");
btnM.setVerticalAlignment(SwingConstants.TOP);
btnM.setHorizontalAlignment(SwingConstants.LEADING);
btnM.setFont(newFont("Times New Roman", Font.PLAIN, 16));
btnM.setBackground(white);
btnM.setBounds(449,190, 48, 45);
contentPane.add(btnM);
/**
* 创建面板panel置于面板contentPane中，设置面板panel的位置、宽高、TitledBorder、背景色以及布局方式（边界布局）
*/
JPanelpanel = new JPanel();
panel.setBorder(newTitledBorder(null, "文本显示区", TitledBorder.LEADING, TitledBorder.TOP, null, null));
panel.setBackground(Color.WHITE);
panel.setBounds(0,0, 540, 45);
contentPane.add(panel);
panel.setLayout(newBorderLayout(0, 0));
/**
* 创建文本框textField置于面板panel的中间
*/
textField= new JTextField();
textField.addKeyListener(newKeyAdapter() { //文本框添加键盘事件的监听
charword;
@Override
publicvoid keyPressed(KeyEvent e) { //按键被按下时被触发
word=e.getKeyChar();//获取按下键表示的字符
for(inti=0;i<btns.size();i++){//遍历存储按键ID的ArrayList集合
//判断按键是否与遍历到的按键的文本相同
if(String.valueOf(word).equalsIgnoreCase(btns.get(i).getText())){
btns.get(i).setBackground(green);//将指定按键颜色设置为绿色
}
}
}
@Override
publicvoid keyReleased(KeyEvent e) { //按键被释放时被触发
word=e.getKeyChar();//获取释放键表示的字符
for(inti=0;i<btns.size();i++){//遍历存储按键ID的ArrayList集合
//判断按键是否与遍历到的按键的文本相同
if(String.valueOf(word).equalsIgnoreCase(btns.get(i).getText())){
btns.get(i).setBackground(white);//将指定按键颜色设置为白色
}
}
}
});
panel.add(textField,BorderLayout.CENTER);
textField.setColumns(10);
}
}
运行结果：
2鼠标事件
代码实现：
public classMouseEvent_Example extends JFrame { // 继承窗体类JFrame
/**
*
*/
privatestatic final long serialVersionUID = 1L;
publicstatic void main(String args[]) {
MouseEvent_Exampleframe = new MouseEvent_Example();
frame.setVisible(true);// 设置窗体可见，默认为不可见
}
/**
* 判断按下的鼠标键，并输出相应提示
* @param e 鼠标事件
*/
privatevoid mouseOper(MouseEvent e){
inti = e.getButton(); // 通过该值可以判断按下的是哪个键
if(i == MouseEvent.BUTTON1)
System.out.println("按下的是鼠标左键");
elseif (i == MouseEvent.BUTTON2)
System.out.println("按下的是鼠标滚轮");
elseif (i == MouseEvent.BUTTON3)
System.out.println("按下的是鼠标右键");
}
publicMouseEvent_Example() {
super();// 继承父类的构造方法
setTitle("鼠标事件示例");// 设置窗体的标题
setBounds(100,100, 500, 375); // 设置窗体的显示位置及大小
//设置窗体关闭按钮的动作为退出
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
finalJLabel label = new JLabel();
label.addMouseListener(newMouseListener() {
publicvoid mouseEntered(MouseEvent e) {// 光标移入组件时被触发
System.out.println("光标移入组件");
}
publicvoid mousePressed(MouseEvent e) {// 鼠标按键被按下时被触发
System.out.print("鼠标按键被按下，");
mouseOper(e);
}
publicvoid mouseReleased(MouseEvent e) {// 鼠标按键被释放时被触发
System.out.print("鼠标按键被释放，");
mouseOper(e);
}
publicvoid mouseClicked(MouseEvent e) {// 发生单击事件时被触发
System.out.print("单击了鼠标按键，");
mouseOper(e);
intclickCount = e.getClickCount();//获取鼠标单击次数
System.out.println("单击次数为" +clickCount + "下");
}
publicvoid mouseExited(MouseEvent e) {// 光标移出组件时被触发
System.out.println("光标移出组件");
}
});
getContentPane().add(label,BorderLayout.CENTER);
//
}
}
运行结果：
3窗体事件
3.1捕获窗体焦点变化事件
代码实现：
/**
* 焦点事件的监听： 使用焦点事件的监听模拟点亮灯泡的过程。
*/
public classFocus extends JFrame { // 创建一个“焦点”类，并继承JFrame
//声明窗体中的组件
privateJPanel contentPane;
privateJLabel lblTip;
privateJLabel lblLight;
/**
* 主方法
*/
publicstatic void main(String[] args) {
EventQueue.invokeLater(newRunnable() { // 使得Runnable中的的run()方法在the
//system EventQueue的指派线程中被调用
publicvoid run() {
try{
Focusframe = new Focus(); // 创建Flags对象
frame.setVisible(true);// 使frame可视
}catch (Exception e) {
e.printStackTrace();
}
}
});
}
privateclass myWindowFocusListener implements WindowFocusListener{
@Override
publicvoid windowGainedFocus(WindowEvent arg0) {
lblLight.setIcon(newImageIcon(Focus.class.getResource("light.png"))); // 设置标签中的图标，显示灯亮
lblTip.setText("JFrame窗体获得焦点后，灯亮了...");// 设置标签中的文本
}
@Override
publicvoid windowLostFocus(WindowEvent arg0) {
lblLight.setIcon(newImageIcon(Focus.class.getResource("dark.png"))); // 设置标签中的图标，显示灯灭
lblTip.setText("JFrame窗体失去焦点后，灯灭了...");// 设置标签中的文本
}
}
/**
* 创建JFrame窗体
*/
publicFocus() { // Focus的构造方法
addWindowFocusListener(newmyWindowFocusListener());//为窗体添加焦点事件监听器
setAutoRequestFocus(false);// JFrame窗体失去焦点
setResizable(false);// 不可改变窗体大小
setTitle("焦点事件的监听");// 设置窗体题目
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);// 设置窗体关闭的方式
setBounds(100,100, 300, 300); // 设置窗体大小
/**
* 创建JPanel面板contentPane置于JFrame窗体中，并设置面板的背景色、边距和布局
*/
contentPane= new JPanel();
contentPane.setBackground(Color.BLACK);
contentPane.setBorder(newEmptyBorder(5, 5, 5, 5));
contentPane.setLayout(newBorderLayout(0, 0));
setContentPane(contentPane);
/**
* 创建标签lblTip置于JFrame窗体中的南侧，设置标签label_1中字体的颜色、样式以及水平居中
*/
lblTip= new JLabel("JFrame窗体失去焦点时，灯没亮！");
lblTip.setForeground(Color.CYAN);
lblTip.setFont(newFont("微软雅黑", Font.PLAIN, 14));
lblTip.setHorizontalAlignment(SwingConstants.CENTER);
contentPane.add(lblTip,BorderLayout.SOUTH);
/**
* 创建标签lblLight置于JFrame窗体中的中间，设置标签label_2中的图标位置和样式
*/
lblLight= new JLabel("");
lblLight.setHorizontalAlignment(SwingConstants.CENTER);
lblLight.setIcon(newImageIcon(Focus.class.getResource("dark.png")));
contentPane.add(lblLight,BorderLayout.CENTER);
}
}
运行结果：
3.2捕获窗体状态变化事件
代码实现：
public classWindowStateListener_Example extends JFrame {
/**
*
*/
privatestatic final long serialVersionUID = 1L;
publicstatic void main(String args[]) {
WindowStateListener_Exampleframe = new WindowStateListener_Example();
frame.setVisible(true);
}
publicWindowStateListener_Example() {
super();
//为窗体添加状态事件监听器
addWindowStateListener(newMyWindowStateListener());
setTitle("捕获窗体状态事件");
setBounds(100,100, 500, 375);
setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);
}
privateclass MyWindowStateListener implements WindowStateListener {
publicvoid windowStateChanged(WindowEvent e) {
intoldState = e.getOldState();// 获得窗体以前的状态
intnewState = e.getNewState();// 获得窗体现在的状态
Stringfrom = "";// 标识窗体以前状态的中文字符串
Stringto = "";// 标识窗体现在状态的中文字符串
switch(oldState) {// 判断窗台以前的状态
caseFrame.NORMAL:// 窗体处于正常化
from= "正常化";
break;
caseFrame.MAXIMIZED_BOTH:// 窗体处于最大化
from= "最大化";
break;
default://窗体处于最小化
from= "最小化";
}
switch(newState) {// 判断窗台现在的状态
caseFrame.NORMAL:// 窗体处于正常化
to= "正常化";
break;
caseFrame.MAXIMIZED_BOTH:// 窗体处于最大化
to= "最大化";
break;
default://窗体处于最小化
to= "最小化";
}
System.out.println(from+ "——>" + to);
}
}
}
运行结果：
3.3捕获其他窗体事件
代码实现：
public class WindowListener_Example extendsJFrame {
/**
*
*/
privatestatic final long serialVersionUID = 1L;
publicstatic void main(String args[]) {
WindowListener_Exampleframe = new WindowListener_Example();
frame.setVisible(true);
}
publicWindowListener_Example() {
super();
addWindowListener(newMyWindowListener());// 为窗体添加其他事件监听器
setTitle("捕获其他窗体事件");
setBounds(100,100, 500, 375);
setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);
}
privateclass MyWindowListener implements WindowListener {
publicvoid windowActivated(WindowEvent e) {// 窗体被**时触发
System.out.println("窗口被**！");
}
publicvoid windowOpened(WindowEvent e) {// 窗体被打开时触发
System.out.println("窗口被打开！");
}
publicvoid windowIconified(WindowEvent e) {// 窗体被最小化时触发
System.out.println("窗口被最小化！");
}
publicvoid windowDeiconified(WindowEvent e) {// 窗体被非最小化时触发
System.out.println("窗口被非最小化！");
}
publicvoid windowClosing(WindowEvent e) {// 窗体将要被关闭时触发
System.out.println("窗口将要被关闭！");
}
//窗体不再处于**状态时触发
publicvoid windowDeactivated(WindowEvent e) {
System.out.println("窗口不再处于**状态！");
}
publicvoid windowClosed(WindowEvent e) {// 窗体已经被关闭时触发
System.out.println("窗口已经被关闭！");
}
}
}
运行结果：
4选项事件
代码实现：
/**
* 省市联动菜单（下拉列表）之户口本（局部）
*/
public classHouseRegister extends JFrame { // 创建一个“户口本”类继承JFrame
//声明“户口本”类中的成员组件
privateJComboBox<String> cboxProvince;
privateJComboBox<String> cboxCity;
privateJComboBox<String> cboxNProvince;
privateJComboBox<String> cboxNCity;
String[]strProvinces={ "黑龙江省", "吉林省", "辽宁省" };//存储省份
//存储黑龙江省的所有地级市
String[]strHLJ={ "哈尔滨", "齐齐哈尔", "牡丹江", "大庆", "伊春", "双鸭山","鹤岗", "鸡西", "佳木斯", "七台河", "黑河", "绥化", "大兴安岭" };
//存储吉林省的所有地级市
String[]strJL={ "长春", "延边", "吉林", "白山", "白城", "四平", "松原", "辽源", "大安", "通化" };
//存储辽宁省的所有地级市
String[]strLN={ "沈阳", "大连", "葫芦岛", "旅顺", "本溪", "抚顺","铁岭", "辽阳", "营口", "阜新", "朝阳", "锦州", "丹东", "鞍山" };
/**
* 根据选择的省显示其所有地级市
* @param item ItemEvent类型，表示下拉列表中的选择项
* @param cbox JComboBox类型，表示JComboBox组件
*/
privatevoid getCity(ItemEvent item, JComboBox<String> cbox){
StringstrProvince=String.valueOf(item.getItem());//获取选中项
if(strProvince.equals("黑龙江省")) {
cbox.setModel(newDefaultComboBoxModel<String>(strHLJ));
}else if (strProvince.equals("吉林省")) {
cbox.setModel(newDefaultComboBoxModel<String>(strJL));
}else if (strProvince.equals("辽宁省")) {
cbox.setModel(newDefaultComboBoxModel<String>(strLN));
}
}
/**
* 主方法
*/
publicstatic void main(String[] args) {
newHouseRegister().setVisible(true); // 创建HouseRegister对象frame
}
/**
* 创建JFrame窗体
*/
publicHouseRegister() { // HouseRegister的构造方法
setTitle("户口本（局部）");// 设置窗体题目
NPanelcontentPanel = new NPanel();// 创建一个面板对象
contentPanel.setLayout(null);//设置面板为绝对布局
getContentPane().add(contentPanel);//将面板添加到窗体上
setResizable(false);// 不可改变窗体大小
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);// 设置窗体关闭的方式
setBounds(100,100, 592, 190);
/**
* 创建下拉列表cboxProvince置于面板contentPane中，设置复选框里的Model值、复选框的大小
*/
cboxProvince= new JComboBox<String>();
cboxProvince.setModel(newDefaultComboBoxModel<String>(strProvinces));
cboxProvince.addItemListener(newItemListener() {//添加选项事件监听器
@Override
publicvoid itemStateChanged(ItemEvent arg0) {//重写选项发生变化时的方法
getCity(arg0,cboxCity);//调用自定义方法实现省市联动
}
});
cboxProvince.setBounds(69,97, 85, 21);
contentPanel.add(cboxProvince);
/**
* 创建下拉列表“市”，设置该下拉列表中的选项值，横坐标、纵坐标、宽高，把下拉列表“市”放到面板contentPane中
*/
cboxCity= new JComboBox<String>(); // 创建下拉列表cboxCity
cboxCity.setModel(newDefaultComboBoxModel<String>(strHLJ));
cboxCity.setBounds(158,97, 85, 21); // 设置下拉列表的大小
contentPanel.add(cboxCity);// 将下拉列表cboxCity置于面板panel中
/**
* 创建下拉列表cboxNProvince置于面板contentPane中，设置复选框里的Model值、复选框的大小
*/
cboxNProvince= new JComboBox<String>();
cboxNProvince.setModel(newDefaultComboBoxModel<String>(strProvinces));
cboxNProvince.addItemListener(newItemListener() {//添加选项事件监听器
@Override
publicvoid itemStateChanged(ItemEvent arg0) {//重写选项发生变化时的方法
getCity(arg0,cboxNCity);//调用自定义方法实现省市联动
}
});
cboxNProvince.setBounds(69,131, 85, 21);
contentPanel.add(cboxNProvince);
/**
* 创建下拉列表“市”，设置该下拉列表中的选项值，横坐标、纵坐标、宽高，把下拉列表“市”放到面板contentPane中
*/
cboxNCity= new JComboBox<String>(); // 创建下拉列表cboxNProvince
cboxNCity.setModel(newDefaultComboBoxModel<String>(strHLJ));
cboxNCity.setBounds(158,131, 85, 21); // 设置下拉列表的大小
contentPanel.add(cboxNCity);// 将下拉列表cboxNProvince置于面板panel中
}
classNPanel extends JPanel {// 重绘面板
@Override
protectedvoid paintComponent(Graphics arg0) {// 重写事件，用来重绘面板背景
intx = 0, y = 0;// 定义重绘的起始点坐标
//使用指定图片创建ImageIcon对象
ImageIconimgBack = new ImageIcon(getClass().getResource("back.png"));
//按面板大小重绘图片
arg0.drawImage(imgBack.getImage(),x, y, getSize().width, getSize().height, this);
while(true) {
arg0.drawImage(imgBack.getImage(),x, y, this);// 按原始大小重绘图片
if(x > getSize().width && y > getSize().height)
break;
//保证窗口大于图片时，图片仍能够覆盖整个窗口
if(x > getSize().width) {
x= 0;
y+= imgBack.getIconHeight();
}else
x+= imgBack.getIconWidth();
}
}
}
}
运行结果：