事件驱动程序设计学习笔记

        如果希望可以编写一个GUI程序提示用户输入贷款总额，年利率，年数，然后点击OK按钮获取月偿还额和总偿还额。则必须使用时间驱动程序设计来编写代码。

事件和事件源

        能创建一个事件并能触发该事件的组件成为源对象或是源组件。如按钮是按钮点击动作事件的源对象。一个事件是一个事件类的实例化。事件的根类是java.util.EventObject。

        除了ListSelectionEvent和ChangeEvent之外所有的事件类都包括在java.awt.event包中，ListSelectionEvent和ChangeEvent在java.swing.event包中。AWT事件本来就是为了AWT组件设计的，但是很多Swing组件都会用到它们。

监听器，注册，处理事件

Java使用一种基于委托的模型来处理事件：源对象触发一个事件，对此事件感兴趣的对象会处理它。对此事件感兴趣的对象成为监听器（listener）。一个对象要成为源对象的监听器需要具备两个条件：

1.    监听器对象的类必须是相应的事件监听器接口的实例，以确保监听器有处理这个时间的正确方法。

2.    监听器对象必须有源对象注册。

        现在我们可以编写一个程序，使用两个按钮控制一个圆的大小。代码如下

import java.util.*;
import javax.swing.*;
import javax.swing.border.Border;
import java.io.*;
import java.awt.*;
import java.awt.event.*;

class ArcPanel extends JPanel {
	private int radius = 5;

	protected void paintComponent(Graphics g) {
		super.paintComponent(g);
		g.drawOval(getWidth() / 2 - radius, getHeight() / 2 - radius, 2 * radius, 2 * radius);
	}

	public void enlarge() {
		radius += 5;
		repaint();
	}

	public void shrink() {
		radius -= 5;
		repaint();
	}
}

public class Main extends JFrame {

	private JButton jbtEnlarge = new JButton("Enlarge");
	private JButton jbtShrink = new JButton("Shrink");
	private ArcPanel canvas = new ArcPanel();

	public Main() {
		JPanel panel = new JPanel();
		panel.add(jbtEnlarge);
		panel.add(jbtShrink);
		this.add(canvas, BorderLayout.CENTER);
		this.add(panel, BorderLayout.SOUTH);

		jbtEnlarge.addActionListener(new EnlargeListener());
		jbtShrink.addActionListener(new ShrinkListener());
	}

	class EnlargeListener implements ActionListener {
		public void actionPerformed(ActionEvent e) {
			canvas.enlarge();
		}
	}

	class ShrinkListener implements ActionListener {
		public void actionPerformed(ActionEvent e) {
			canvas.shrink();
		}
	}

	public static void main(String[] args) {
		Main frame = new Main();
		frame.setTitle("Main");
		frame.setSize(250, 300);
		frame.setLocationRelativeTo(null);
		frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
		frame.setVisible(true);
	}
}

        由上面的代码显示，我将EnlargeListener和ShrinListener定义成了内部类，通常，如果一个类只是被外部类使用，就将该类定义为内部类。一个内部类有如下特征：

1.    一个内部类被编译成一个名为OutClass$InnerClass.class的类。

2.    内部类可以引用定义在它嵌套外部类中的数据和方法，所以，不需要将外部类对象的引用传递给内部类的构造方法，因此，内部类可以使程序更加简单和简洁。

3.    使用可见修饰符定义内部类时，遵从应用与在类成员上一样的可见性原则。

4.    可以讲内部类定义为static。一个static内部类可以使用外部类的名字访问。一个static类是不能访问外部类的非静态成员的。

5.    内部类对象经常在外部类中创建。但是也可以从另一个类中创建一个内部类的对象，如果该内部类是非静态的，必须先创建一个外部类的实例，然后使用下面的语法创建以一个内部类对象：

OutClass.InnerClassinnerObject = outObject.new InnerClass();

6.    如果内部类是静态的，那么使用下面的语法为它创建一个对象：

OutClass.InnerClassinnObject = new OutClass.InnerClass();

匿名内部类：

我们可以把上面的监听器重新写，代码如下：

jbtEnlarge.addActionListener(new ActionListener()
{
   public void actionPerformed(ActionListen e)
{
        canvas.enlarge();
}
})

匿名内部类:

1.    匿名内部类必须总是扩展父类或实现接口，但是它不能有显示的extends或者implements子句。

2.    匿名类必须实现父类或者接口内的所有方法。

3.    匿名内部类总是使用它的父类的无参构造方法来创建实例，如果匿名内部类实现了接口，构造方法就是Object（）；

4.    匿名内部类被编译为一个名为OuterClassName$n.class的类。

定义监听器的另外一种方式

话不多说，贴上代码：

import java.util.*;
import javax.swing.*;
import javax.swing.border.Border;
import java.io.*;
import java.awt.*;
import java.awt.event.*;

public class Main extends JFrame {

	private JButton jbtEnlarge = new JButton("Enlarge");
	private JButton jbtShrink = new JButton("Shrink");
	private ArcPanel canvas = new ArcPanel();
	private ButtonListener listener = new ButtonListener();
	public Main() {
		JPanel panel = new JPanel();
		panel.add(jbtEnlarge);
		panel.add(jbtShrink);
		this.add(canvas, BorderLayout.CENTER);
		this.add(panel, BorderLayout.SOUTH);

		jbtEnlarge.addActionListener(listener);
		jbtShrink.addActionListener(listener);
	}

	class ButtonListener implements ActionListener
	{
		public void actionPerformed(ActionEvent e)
		{
			if(e.getSource() == jbtEnlarge)
				canvas.enlarge();
			else if(e.getSource() == jbtShrink)
				canvas.shrink();
		}
	}

	class ArcPanel extends JPanel {
		private int radius = 5;

		protected void paintComponent(Graphics g) {
			super.paintComponent(g);
			g.drawOval(getWidth() / 2 - radius, getHeight() / 2 - radius, 2 * radius, 2 * radius);
		}

		public void enlarge() {
			radius += 5;
			repaint();
		}

		public void shrink() {
			radius -= 5;
			repaint();
		}
	}

	public static void main(String[] args) {
		Main frame = new Main();
		frame.setTitle("Main");
		frame.setSize(250, 300);
		frame.setLocationRelativeTo(null);
		frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
		frame.setVisible(true);
	}
}

        如上代码所示，我们只定义了一个监听器 listener。我们可以通过getSource()方法获取我们鼠标点击的按钮，这样可以减少类的定义从而简化代码。

实例：贷款计算器

要求：

(1)  创建一个如图所示的用户接口

(2)  创建一个5行2列的GridLayout面板，添加文本和标签

(3)  创建一个FlowLayout面板，并添加一个按钮

(4)  将两个面板添加到框架中

(5)  处理事件

代码如下：

import java.util.*;
import javax.swing.*;
import javax.swing.border.Border;
import javax.swing.border.TitledBorder;

import java.io.*;
import java.awt.*;
import java.awt.event.*;

public class Main extends JFrame {
	private JTextField jtfAnnualInterestRate = new JTextField("please type rate here");
	private JTextField jtfNumberOfYears = new JTextField("please type year here");
	private JTextField jtfLoanAmount = new JTextField("please type loanAmount here");
	private JTextField jtfMonthlyPayment = new JTextField("output");
	private JTextField jtfTotalPayment = new JTextField("output");
	
	private JButton jbtComputeLoan = new JButton("Compute Payment");
	public class ButtonListener implements ActionListener
	{

		
		public void actionPerformed(ActionEvent e) {
			double interest = Double.parseDouble(jtfAnnualInterestRate.getText());
			int year = Integer.parseInt(jtfNumberOfYears.getText());
			double loanAmount = Double.parseDouble(jtfLoanAmount.getText());
            //     loan(interest,year,loanAmount);
			jtfMonthlyPayment.setText(String.format("%.2f", loanAmount));//这里只是一个替代。。。。。
			jtfTotalPayment.setText(String.format("%.2f", loanAmount));// 这里只是一个替代。。。。。

		}
		
	}
	public Main()
	{
		JPanel p1 = new JPanel(new GridLayout(5,2));
		p1.add(new JLabel("Annual Interest Rate"));
		p1.add(jtfAnnualInterestRate);
		p1.add(new JLabel("Number of Years"));
		p1.add(jtfNumberOfYears);
		p1.add(new JLabel("Loan Amount"));
		p1.add(jtfLoanAmount);
		p1.add(new JLabel("Monthly Payment"));
		p1.add(jtfMonthlyPayment);
		p1.add(new JLabel("Total Payment"));
		p1.add(jtfTotalPayment);
		p1.setBorder(new TitledBorder("Enter loan amount,interest rate,and year"));
		JPanel p2 = new JPanel(new FlowLayout(FlowLayout.RIGHT));
		p2.add(jbtComputeLoan);
		add(p1,BorderLayout.CENTER);
		add(p2,BorderLayout.SOUTH);
		jbtComputeLoan.addActionListener(new ButtonListener());
		
	}
	public static void main(String[] args) {
		Main frame = new Main();
		frame.pack();
		frame.setTitle("LoanCalculator");
		frame.setLocationRelativeTo(null);
		frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
		frame.setVisible(true);
	}
}

        Loan类的实现我已经实现过了，可是文件丢失了，然后我又不想再写一遍。。。。。

实例学习：使用鼠标在面板上拖动消息（用到方便适配器）

上代码：

import java.util.*;
import java.util.Timer;

import javax.swing.*;
import javax.swing.border.Border;
import javax.swing.border.TitledBorder;

import java.io.*;
import java.awt.*;
import java.awt.event.*;

public class Main extends JFrame {
	static class MovableMessagePanel extends JPanel {
		private String s = "Welcomea To Java!";
		private int x = 20;
		private int y = 20;

		public MovableMessagePanel(String s) {
			this.s = s;
			addMouseMotionListener(new MouseAdapter() {
				public void mouseDragged(MouseEvent e) {
					x = e.getX();
					y = e.getY();
					repaint();
				}
			});
		}
		protected void paintComponent(Graphics g)
		{
			super.paintComponent(g);
			g.drawString(s, x, y);
		}
	}

	public Main() {
		MovableMessagePanel p =new MovableMessagePanel("Hello Java!");
		setLayout(new BorderLayout());
		add(p);
	}

	public static void main(String[] args) {
		Main frame = new Main();
		frame.setTitle("MoveMessageDemo");
		frame.setSize(200,100);
		frame.setLocationRelativeTo(null);
		frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
		frame.setVisible(true);
	}
}

        使用MouseMotionAdapter覆盖mouseDragged方法，如果内部类实现了MouseMotionListener接口，即使监听器并不关心某些事件，也必须要实现所有的处理器。

本章小结：

1.    事件类的根类是java.util.EventObject。EventObject的子类处理各种特殊类型的时间，例如动作事件，窗口时间，组件事件，鼠标事件和按键事件。可以使用EventObject类中的getSource()实例方法判断事件的源对象。如果一个组件能够触发整个事件，那么它的所有子类都能触发同类型的事件。

2.    监听器对象的类必须时间相应的时间监听器接口。Java语言为每种事件类提供监听器接口。XEvent的监听器接口通常命名为XListener，但是MouseMotionListener除外。例如，ActionEvent对应的监听器接口是ActionListener，每个ActionEvent的监听器都应该实现ActionListener接口，监听器接口包含成为处理器的处理事件的方法。

3.    监听器对象必须由源对象注册。注册方法依赖于事件的类型。对ActionEvent来讲，注册方法是addActionListener。一般来说XEvent的方法命名为addXListener。

4.    内部类或者是嵌套类是定义在另一个类中的类。内部类可以应用定义在它嵌套的外部类中的数据和方法。所以，不需要将外部类的引用传递给内部类的构造方法。

5.    方便适配器能够提供监听器接口中所有方法的默认实现类的支持类。Java为每一个AWT监听器接口提供多个处理器的方便监听器适配器，XListenerde 方便监听器适配器命名为Xadapter。。

6.    一个源对象可以触发几种类型的事件。对每种事件，源对象维护一个注册的监听器列表，通过调用监听器对象的处理器，通知所有已经注册的监听器取处理事件。

7.    在一个组件上点击，释放，移动或拖动鼠标就会触发鼠标事件。鼠标事件对象捕获事件，例如和事件相关的点击次数和鼠标点的位置（x，y坐标）

8.    Java提供两个处理鼠标事件的监听器接口，MouseListener和MouseMotionListner来处理事件，实现MouseListener接口来监听注入按下，释放，点击，输入或退出鼠标等动作，实现MouseMotionListener接口来监听注入移动或拖动鼠标的动作。

9.    KeyEvent对象描述事件的性质(即按下，释放或敲击一个键)以及相对应的键值

10.  当按下按键是就会调用keyPressed处理器，当释放按键时会调用keyReleased处理器，而当敲入一个统一码字符键是，就会调用keyTyped处理器。如果某个按键没有统一码（如功能键，修改键，动作键和控制键），则不会调用keyTyped处理器。

可以使用Timer类控制Java的动画。定时器以固定频率触发ActionEvent。监听器通过更新画面来模拟动画。