接口和事件机制的总结-CSDN博客

本文链接：https://blog.csdn.net/happy_zhourong/article/details/84410336

一、抽象类的定义格式

1、概念：包含抽象方法的类叫做抽象类。

2、定义抽象类的关键字:abstract class

格式：

public abstract class抽象类名 extends 抽象类或类{

访问修饰符（public,protected,private）数据类型属性名;

访问修饰符抽象类名(数据类型参数名,…){

//方法体

}

访问修饰符返回值数据类型方法名(数据类型参数名,…){

//方法体

}

访问修饰符 abstract 返回值数据类型方法名(数据类型参数名,…);

//注意：抽象方法没有方法体

}

2、抽象类和类的区别：

1）抽象类可以比类多定义一种抽象方法，而一般的类不能定义抽象方法。

2）抽象类不能实例化对象，而类可以实例化对象。（因为抽象类中可能含有抽象方法，抽象方法是不能被调用的，故实例化抽象类对象也没有意义，故抽象类不能实例化对象。）

3、一般类继承抽象类与抽象类继承抽象类的区别：

一般的类继承抽象类后，必须实现抽象类中所有的抽象方法；

抽象类继承抽象类后，可以不用实现抽象类中所有的抽象方法，只要实现需要的方法即可。

Eg:

public abstract class Student {

   private String name;

   //定义构造方法

   public Student(String name) {

      this.name = name;

   }

   //定义一般方法

   public String getName() {

      return name;

   }


   public void setName(String name) {

      this.name = name;

   }

   //定义抽象方法

   public abstract void study();//定义了一个学习的抽象方法study()

   public abstract void exam();//定义了一个考试的抽象方法exam()

}

 

//定义一个一般的类UNStudent继承抽象类Student

public class UNStudent extends Student{

   public UNStudent(String name) {

      super(name);

   }

   //实现抽象类中所有的抽象方法

   @Override

   public void exam() {

      setName("张三");

      System.out.println(getName()+"在考试。");     

   }

 

   public void study(){

      setName("张三");

      System.out.println(getName()+"在学习。");

   }

 

}

 

//定义一个抽象类ComStudent继承抽象类Student

public abstract class ComStudent extends Student{

 

   public ComStudent(String name) {

      super(name);

   }

   //可以选择性的去实现抽象类中的抽象方法

   public void study(){

      setName("张三");

      System.out.println(getName()+"在学习。");

   }

}

二、接口的定义格式

1、定义接口的关键字是：interface

格式：

public interface 接口名{

//常量

public static final 常量名 = 值;

//抽象方法

public abstract 返回值数据类型方法名(数据类型参数名,…);

}

接口中默认的访问修饰符是public

2、接口的实现

关键字：implements

格式：

public class 类名 implements 接口名,…{

}

注意：当类实现接口后，类必须实现接口中的所有抽象方法。接口不能实例化对象。

当继承和实现接口同时存在时，要先继承，再实现接口。

public class 类名 extends 父类名 implement 接口名,...{

//实现接口的抽象方法

}

接口是告诉我们要做什么事情，接口的实现则是告诉我们怎么做这些事情。

接口的实现相当于类中的继承，所以接口的实现中也存在自动转型。

3、接口和类的区别：

	接口	类
1	关键字：interface	关键字：class
2	接口只能定义常量和抽象方法	类可以定义任意访问修饰符的方法、属性、常量
3	接口的默认访问修饰符是public	类的默认访问修饰符就是默认的（public,protected,private和默认的）。
4	接口可以实现多重继承	类只能实现单继承
5	接口不能用来实例化对象	类可以用来实例化对象

Eg:

//定义一个父类Sport：运动类

public class Sport {

   //定义普通方法jump(),run()

   public void jump(){

      System.out.println("动作：跳跃");

   }
}

 

//定义了一个接口Dance()

public interface Dance {

   //定义抽象方法gyrate():旋转

   public void gyrate();

}

 

//定义一个接口Music(音乐)

public interface Music {

   //定义一个抽象方法play()

   public void play();

}

 

//定义一个子类Eurythmics(艺术体操类)继承父类Sport,并实现了两个接口Dance,Music,当继承和实现接口同时存在时，要先继承，再实现接口

public class Eurythmics extends Sport implements Dance,Music{

   //实现Dance接口中的抽象方法

   public void gyrate() {

      System.out.println("舞蹈动作：旋转");

   }

   //实现Music接口中的抽象方法

   public void play() {

      System.out.println("配乐：天空之城");

   }

 }

 

//定义一个比赛类Match

public class Match {

   public static void main(String[] args) {

      Eurythmics e=new Eurythmics();//实例化一个艺术体操对象

      e.gyrate();//子类实现了Dance接口，子类的对象调用Dance接口中的gyrate()方法

      e.play();//子类实现了Music接口，子类的对象调用Music接口中的play()方法

      e.jump();//子类继承了父类中的jump()方法，子类的对象调用了jump()方法

      System.out.println();

      dancePart(e);//e被看作一个Dance对象,相当于e自动转型，作为参数传入dancePart()

      musicPart(e);//e被看作一个Music对象,相当于e自动转型，作为参数传入musicPart()

      sportPart(e);//e被看作一个Sport对象,相当于e自动转型，作为参数传入sportPart()

   }

   //定义舞蹈部分的方法

   public static void dancePart(Dance dance){

      dance.gyrate();

   }

   //定义音乐部分的方法

   public static void musicPart(Music music){

      music.play();

   }

   //定义运动部分的方法

   public static void sportPart(Sport sport){

      sport.jump();

   }

}

结果：

舞蹈动作：旋转

配乐：天空之城

动作：跳跃

舞蹈动作：旋转

配乐：天空之城

动作：跳跃

4、使用接口的原因：

1）核心原因：为了能够自动转型为多个基类，这样给程序带来了灵活性。（如上例）

2）将代码完全与接口的实现分离，不同的子类可以对接口中定义的抽象方法有不同的实现，这也是一种规范，在团队合作中，接口可以是分工变得明确，接口确定下来后，就可以同时进行开发，提高开发效率。

3）使用接口还有使用方便，可读性强，结构清晰等优点。

三、事件原理

1、事件处理源：

1）概念Java中所有的组件对象都是可以作为事件源。包括容器和元素组件。

容器布局不是事件源。

2）如何判断哪个对象是事件源对象？

根据所操作的方法，看操作时反应在哪个组件上，那么该组件就是事件源。

如图：

当用鼠标点击登录按钮的时候，按钮是事件源；当在输入框输入一个账号，按回车时，输入框是事件源；当用鼠标点击“账号”这个标签的时候，标签是事件源；当鼠标点击窗体是，窗体是事件源……

2、事件类型（监听器方法）

监听器方法：在组件上发生动作后，要捕获动作的方法。

分局发生的动作以及所要使用的值来决定使用不同的事件类型。

常用的事件接口	事件类型（监听器方法）
ActionListener 动作监听器接口	AddActionListener(对象名);
MouseListener 鼠标监听器接口	addMouseListener(对象名);
MouseMotionListener 鼠标移动监听器接口	addMouseMotionListener(对象名);
KeyListener 按键处理监听器接口	addKeyListener(对象名);

3、事件处理对象

事件处理对象的作用：当监听器方法捕获到动作后，那么就要交给事件处理对象来处理；事件处理对象会实现对应的监听器接口，来完成最后的处理。

4、事件的执行流程

1）确定事件源对象

2）确定要发生的是什么类型的事件

3）给事件源添加监听器方法

4）实例化事件处理类的对象（定义类实现事件接口，并且实现接口中的方法）

5）给监听器方法绑定事件处理类对象

只要事件源发生监听器方法能捕获到的动作，那么方法就会捕获动作信息以及事件源的相关信息，然后激活事件处理对象，将收集的信息和动作一并交给事件处理对象，事件处理对象会根据信息自动调用事件处理方法。

Eg1:实现QQ登录界面登录的过程，做账号和密码验证。

QQ界面上的关键代码如下：

JButton jb=new JButton("登 录");

      jp2.add(jb);
	//jcb为下拉框对象，jpf为密码输入框对象，jf为登录窗口对象
      LoginListener ll=new LoginListener(jcb,jpf,jf);

      jb.addActionListener(ll);

定义事件处理类：

//定义LoginListener类实现了事件接口ActionListener
public class LoginListener implements ActionListener {
	
	private JComboBox jcb;
	private JPasswordField jpf;
	private JFrame jf1;
	//定义构造方法，便于在实例化事件处理类对象时，将qq界面上将下拉框、密码输入框、登录窗口的对象的地址传过来，进行事件处理
	public LoginListener(JComboBox jcb,JPasswordField jpf,JFrame jf1){
		this.jcb=jcb;
		this.jpf=jpf;
		this.jf1=jf1;
	}
	
/**
 * 事件处理方法
 */
	public void actionPerformed(ActionEvent arg0) {
		String jcbStr=(String)jcb.getSelectedItem();//获取下拉列表中选中项，并把其转成String类型
		String jpfStr=new String(jpf.getPassword());
		//当账号和密码匹配时，出现新的QQ界面（窗口），同时登录窗口关闭
		if(jcbStr.equals("12345678")&&jpfStr.equals("123")){
			JFrame jf=new JFrame("QQ2013");
			jf.setSize(260,600);
			jf.setResizable(true);
			jf.setLocationRelativeTo(null);
			jf.setDefaultCloseOperation(3);
			jf.setVisible(true);
			jf1.setVisible(false);//将登录窗口隐藏起来
		}else{
			//当账号和密码不匹配时，弹出提示信息
			JOptionPane.showMessageDialog(null, "请输入正确的账号和密码!");
		}
				
	}
	
}

1、点击“登录”按钮后，事件发生，事件源为“登录”按钮。

2、即将发生的事件为：当账号和密码匹配时，出现新的QQ界面（窗口），同时登录窗口关闭；当账号和密码不匹配时，弹出提示信息。

3、添加监听器方法addActionListener()

4、定义LoginListener类实现了事件接口ActionListener,实例化事件处理类的对象ll。

5、给监听器绑定事件处理对象ll。