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监听器

焦点事件监听器
事件名称	事件源	监听借口	添加或删除相应类型监听器的方法

FocusEventComponent以及派生类FocusListeneraddFocusListener(); removeFocusListener();代码实现：

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

}

运行结果：

Java学习——复习第八天 Swing程序设计、AWT绘图、事件监听相关推荐

Java学习笔记第八天
Java学习笔记第八天第一章 API 1.1 概述: 1.2 API文档的使用步骤:** 第二章 Scanner类 2.1 概述 2.2 引用类型使用步骤 2.3 Scanner类练习1---求和 ...
Java语言学习--Swing中Button事件监听
1 前言今天在使用Java Swing中的JButton的事件触发机制时遇到了许多问题,简单的了解了一下. 2 事件监听机制事件监听的机制如下图所示分析. 3 代码分析 3.1 分步解析 1.事件 ...
java swing事件监听_Java swing（awt）：事件监听机制的实现原理+简单示例
(1)实现原理事件监听机制的实现: 参考图:事件模型_ActionEvent 为了节省资源,系统无法对某个事件进行实时的监听.故实现的机制是当发生某个事件后,处理代码将被自动运行,类似钩子一般.(回 ...
13、Java Swing事件监听：事件处理模型和事件监听器
事件表示程序和用户之间的交互,例如在文本框中输入,在列表框或组合框中选择,选中复选框和单选框,单击按钮等.事件处理表示程序对事件的响应,对用户的交互或者说对事件的处理是事件处理程序完成的. 当事件发生 ...
java swing(GUI图形化界面)基础教程3-添加事件监听1
学习此内容前建议先去学习java基础知识: 匿名内部类 (学的多的可以用lambda表达式,更加简便) 好, 我们先看一下之前的代码(即一个窗口和一个按钮) 如果想看详细内容,链接为: (23条消息) ...
Java Swing 键盘事件监听
Java Swing 键盘事件监听开发工具与关键技术:java. elipse2019.jdk1.8 作者:Amewin 撰写时间:2019年9月16日键盘事件的事件源一般丐组件相关,当一个组件处 ...
java 监听鼠标点击_java 事件监听 - 鼠标
java 事件监听 - 鼠标 //事件监听 //鼠标事件监听 //鼠标事件监听有两个实现接口 //1.MouseListener 普通的鼠标操作 //2.MouseMotionListener 鼠标的 ...
JAVA之旅（三十一）——JAVA的图形化界面，GUI布局，Frame，GUI事件监听机制，Action事件，鼠标事件
JAVA之旅(三十一)--JAVA的图形化界面,GUI布局,Frame,GUI事件监听机制,Action事件,鼠标事件有段时间没有更新JAVA了,我们今天来说一下JAVA中的图形化界面,也就是GUI ...
java中事件监听_Java中的事件监听机制
鼠标事件监听机制的三个方面: 1.事件源对象: 事件源对象就是能够产生动作的对象.在Java语言中所有的容器组件和元素组件都是事件监听中的事件源对象.Java中根据事件的动作来区分不同的事件源对象,动 ...

Java学习——复习第八天 Swing程序设计、AWT绘图、事件监听

Java学习——复习第八天 Swing程序设计、AWT绘图、事件监听相关推荐

最新文章

热门文章

Java学习——复习 第八天 Swing程序设计、AWT绘图、事件监听

Java学习——复习 第八天 Swing程序设计、AWT绘图、事件监听相关推荐

最新文章

热门文章

Java学习——复习第八天 Swing程序设计、AWT绘图、事件监听

Java学习——复习第八天 Swing程序设计、AWT绘图、事件监听相关推荐