事件处理：
事件：用户的一个操作(例如：点击一下鼠标，或者敲击一下键盘)
事件源：被操作的组件(例如：在一个窗体中的一个按钮，那个按钮就属于被操作的组件，按钮就是事件源)
监听器：一个自定义的对象，实现了监听接口，包含事件处理方式，把监听器添加在事件源上，当事件发生的时候，虚拟机就会自动调用监听器中的事件处理方法package com.yy.gui;
//GUI功能简单运用
import java.awt.Button;
import java.awt.FlowLayout;
import java.awt.Frame;
import java.awt.Toolkit;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.KeyAdapter;
import java.awt.event.KeyEvent;
import java.awt.event.MouseAdapter;
import java.awt.event.MouseEvent;
import java.awt.event.WindowAdapter;
import java.awt.event.WindowEvent;
public class Demo1_Frame {
public static void main(String[] args) {
Frame f = new Frame("琪老师好！");
f.setSize(400,600); //设置窗体大小(宽和高)
f.setLocation(500, 50); //设置窗体初始的位置
f.setIconImage(Toolkit.getDefaultToolkit().createImage("beyond.jpg"));
Button b1 = new Button("我就不~不滚咋滴！！！"); //设置按钮1，按钮名称：我就不~不滚咋滴！！！
Button b2 = new Button("略略略"); //设置按钮2，按钮名称：略略略
f.add(b1);
f.add(b2);
f.setLayout(new FlowLayout()); //设置布局管理器
//f.addWindowListener(new MyWindowAdapter());//WindowListenter是一个接口，不能直接new一个接口，但是我们可以传这个接口的子类对象
/*
//窗体监听
//优化2，匿名内部类
//public void windowClosing(WindowEvent e)窗口正处在关闭过程中时调用。此时可重写关闭操作
f.addWindowListener(new WindowAdapter(){ //WindowListener是一个接口，找个类去实现这个接口，重写接口中的所有方法，然后去调用自己想要的方法，继承WindowAdapter这个类
//不能new接口，但是可以new这个接口的子类对象
public void windowClosing(WindowEvent e){ //重写所需要的方法
System.exit(0);
}
});
//new WindowAdapter(){}
//new 类 (){} 表示去继承这个类
*/
/*
//鼠标监听，鼠标点击进行指定操作
//public void mouseClicked(MouseEvent e)鼠标按键在组件上单击（按下并释放）时调用
//public void mouseReleased(MouseEvent e)鼠标按钮在组件上释放时调用
b1.addMouseListener(new MouseAdapter(){ //匿名内部类，添加一个鼠标监听，鼠标适配器
public void mouseClicked(MouseEvent e){//单击Clicked
System.exit(0); //退出
}
public void mouseReleased(MouseEvent e){//释放Released
System.exit(0);
}
});
*/
/*
//键盘监听以及键盘事件(满足某种条件就去执行对应的方法)
//public int getKeyCode()返回与此事件中的键关联的整数 keyCode
//返回： 键盘上实际键的整数代码
b1.addKeyListener(new KeyAdapter(){ //匿名内部类，添加一个键盘监听器
public void keyReleased(KeyEvent e){ //KeyEvent 键盘事件
//System.out.println(e.getKeyCode()); //打印键盘上的键所对应的整数值
第一种形式
if(e.getKeyCode() == 32){ //32对应的键是空格键
System.exit(0); //如果是空格键，退出程序
}
//第二种形式
if(e.getKeyCode() == KeyEvent.VK_SPACE){ //类名. 去调用这个静态常量就可以
//KeyEvent.VK_SPACE
//类名 . VK_SPACE代表空格 VK_ENTER代表回车 ...
System.exit(0); //退出程序
}
}
}); //KeyListener也是一个接口，
*/
/*
//动作监听
b2.addActionListener(new ActionListener() { //添加动作监听，应用场景就是暂停视频和播放视频
@Override
public void actionPerformed(ActionEvent e) { //无论是敲空格键还是鼠标左键单击，都会退出java虚拟机，因为空格键还是鼠标左键单击是系统默认的
System.exit(0);
}
});
*/
f.setVisible(true); //设置窗体可见
}
}
//WindowAdapter：适配器，也是一个抽象类，定义为抽象类是为了，不想让你去创建这个类的对象，因为，就算创建了这个类的对象，调用这个类的空方法也是没有任何意义的。
//该抽象类实现了WindowListener这个接口，并且重写了WindowListener这个接口中的所有的出抽象方法
//方便在于：如果以后你想用WindowListener这个接口，只需要继承WindowAdapter这个类就可以了，想用那个方法，就重写那个方法即可
//WindowAdapter该类中的方法都是空方法；
//目的在于：就是为了提供给子类去使用这些方法，而不是自己用的，然后，WindowAdapter这个类把这些方法都给重写了，当子类去使用的时候，想用哪个方法，就直接重写哪个方法即可
/*class MyWindowListener implements WindowListener{ //创建WindowListener这个抽象类的子类对象
//如果一个抽象类中，没有定义任何的抽象方法，那这个抽象类的作用只有一个，不允许其他的类来创建这个抽象类的对象
@Override
public void windowOpened(WindowEvent e) { //重写WindowListener这个接口里面的所有方法
}
@Override
public void windowClosing(WindowEvent e) {
System.out.println("Closing");
System.exit(0);
}
@Override
public void windowClosed(WindowEvent e) {
System.out.println("Closed");
}
@Override
public void windowIconified(WindowEvent e) {
}
@Override
public void windowDeiconified(WindowEvent e) {
}
@Override
public void windowActivated(WindowEvent e) {
}
@Override
public void windowDeactivated(WindowEvent e) {
}
}
*/
/*
优化1
class MyWindowAdapter extends WindowAdapter{ //创建一个类MyWindowAdapter去继承WindowAdapter(适配器)这个抽象类
//该抽象类实现了WindowListener这个接口，并且重写了WindowListener这个接口中的所有的出抽象方法，方便在于：如果以后你想用WindowListener这个接口，只需要继承WindowAdapter这个类就可以了，想用那个方法，就重写那个方法即可
//这里就不会去强制重写任何方法，用哪个重写哪个方法就可以
public void WindowClosing(WindowEvent e){
System.exit(0);
}
}
*/ * A:什么是适配器
* 在使用监听器的时候，需要定义一个类事件监听器接口
* 通常接口中有多个方法，而程序中不一定所有的都能用到，但有必须重写所有的方法，这很繁琐
* 适配器简化了这些操作，我们定义监听器时只要继承适配器，然后重写需要的方法即可
* B：适配器原理(Adapter就是一个适配器)
* 适配器就是一个类，实现了监听器接口，所有的抽象方法都重写了，但是方法全是空的
* 适配器类需要定义成抽象的，因为创建该类对象，调用空方法都是没有意义的
* 目的就是为了简化程序员的操作，定义监听器时继承适配器，只重写需要的方法就可以了 * 适配器设计模式
* 例如：鲁智深(花和尚)。是个和尚(假如，和尚每天要做的事情为打坐、念经、撞钟、习武)，现在有一个 和尚 接口，该接口有打坐、念经、撞钟、习武这四个方法，
* 但是鲁智深只喜欢习武，所以，让鲁智深去实现 和尚 这个接口是不合适的
* 首先有个接口 和尚 ，和尚 这个接口里面有一些方法打坐、念经、撞钟、习武
* 而鲁智深只喜欢习武，所以，这时候，我们就可以创建一个中间类 天罡星 ，这个 天罡星 这个类实现了这个 和尚 接口，实现 和尚 这个接口之后，重写了 和尚 这个接口里面的所有抽象方法
* 天罡星 这个类重写了 和尚 里面的所有抽象方法，这些抽象方法都是空的，为了防止别人拿这个 天罡星 这个类去创建对象，于是就把 天罡星 这个类给声明成抽象类
* 把 天罡星 这个类声明成抽象类的原因：不想让其他类去创建本类对象，因为创建也是没有意义的，天罡星 这个类里面的方法都是空的，这里的 天罡星 这个类就起到一个过渡的作用
* 然后，创建一个 鲁智深 类，让 鲁智深 这个类去继承 天罡星 这个抽象类，于是，鲁智深 这个类 想重写哪个方法就重写哪个方法就行了，由于鲁智深只想习武，于是只需要重写 习武 这个方法就行了
* 然后，重写 习武 这个方法，输出倒拔垂杨柳，拳打镇关西，大闹野猪林...即可
* 这时候，唐三藏来了，而他只喜欢打坐，念经，撞钟，但是他不喜欢习武，于是，就可以定义一个 唐三藏 类去继承 天罡星 这个抽象类 然后重写他需要的方法即可；代码如下
package com.yy.适配器;
public class Demo1_Adapter {
public static void main(String[] args) {
鲁智深 yy = new 鲁智深(); //创建 鲁智深 这个类对象
唐三藏 wsq = new 唐三藏(); //创建 唐三藏 这个类对象
yy.习武(); //调用 鲁智深 这个类中的 习武 方法
wsq.念经(); //调用 唐三藏 这个类中的 念经 方法
wsq.打坐(); //调用 唐三藏 这个类中的 打坐 方法
wsq.撞钟(); //调用 唐三藏 这个类中的 撞钟 方法
}
}
interface 和尚{ //定义一个 和尚 接口
public void 打坐(); //这些是 和尚 这个接口的所有抽象方法
public void 念经();
public void 撞钟();
public void 习武();
}
//适配器设计模式
abstract class 天罡星 implements 和尚{ //声明成抽象类的原因是：不想让其他类去创建本类对象，因为创建也是没有意义的，方法都是空的
//这里的 天罡星 这个类就充当着适配器的作用，作为中间类
@Override
public void 打坐() { //重写 和尚 这个接口里面的所有抽象方法，但是都是空方法，调用空方法是没有任何意义的
}
@Override
public void 念经() {
}
@Override
public void 撞钟() {
}
@Override
public void 习武() {
}
}
class 鲁智深 extends 天罡星{ //鲁智深 这个类去继承 天罡星 这个抽象类
public void 习武() {
System.out.println("倒拔垂杨柳");
System.out.println("拳打镇关西");
System.out.println("大闹野猪林");
System.out.println("......");
}
//这里并没有重写toString方法，而是采用 类名. 的方法调用类中的每个方法
}
class 唐三藏 extends 天罡星{
public void 打坐(){
System.out.println("我佛慈悲");
}
public void 念经() {
System.out.println("阿弥陀佛");
}
public void 撞钟() {
System.out.println("duangduangduang");
}
}