四种监听器（自身类，外部类，内部类，匿名类）

  1. import javax.swing.*;
  2. import java.awt.*;
  3. import java.awt.event.*;
  4. public class ThisClassEvent extends JFrame implements ActionListener{
  5. public ThisClassEvent(){
  6. setLayout(new FlowLayout());
  7. JButton btn=new JButton("ok");
  8. add(btn);
  9. btn.addActionListener(this);
  10. }
  11. public void actionPerformed (ActionEvent e){
  12. System.out.println("The OK button is clicked");
  13. }
  14. public static void main(String args[]){
  15. ThisClassEvent frame = new ThisClassEvent();
  16. frame.setTitle("自身类作为事件监听器");
  17. frame.setLocationRelativeTo(null); // Center the frame
  18. frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
  19. frame.setSize(280, 100);
  20. frame.setVisible(true);
  21. new ThisClassEvent();
  22. }
  23. }
  24. import java.awt.*;
  25. import java.awt.event.*;
  26. import javax.swing.*;
  27. public class OuterClassEvent extends JFrame{
  28. public OuterClassEvent(){
  29. setLayout(new FlowLayout());
  30. JButton btn=new JButton("ok");
  31. add(btn);
  32. OuterClass btListener=new OuterClass();
  33. btn.addActionListener(btListener);
  34. }
  35. public static void main(String args[]){
  36. OuterClassEvent frame = new OuterClassEvent();
  37. frame.setTitle("外部类作为事件监听器");
  38. frame.setLocationRelativeTo(null); // Center the frame
  39. frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
  40. frame.setSize(280, 100);
  41. frame.setVisible(true);
  42. new ThisClassEvent();
  43. }
  44. }
  45. class OuterClass implements ActionListener{
  46. public void actionPerformed(ActionEvent e){
  47. System.out.println("The OK button is clicked");
  48. }
  49. }
  50. import java.awt.*;
  51. import java.awt.event.*;
  52. import javax.swing.*;
  53. class InnerClassEvent extends JFrame{
  54. public InnerClassEvent(){
  55. setLayout(new FlowLayout());
  56. JButton btn=new JButton("ok");
  57. add(btn);
  58. OuterClass btListener=new OuterClass();
  59. btn.addActionListener(btListener);
  60. }
  61. class InnerClass implements ActionListener{
  62. public void actionPerformed (ActionEvent e){
  63. System.out.println("The OK button is clicked");
  64. }
  65. }
  66. public static void main(String args[]){
  67. InnerClassEvent frame = new InnerClassEvent();
  68. frame.setTitle("内部类作为事件监听器");
  69. frame.setLocationRelativeTo(null); // Center the frame
  70. frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
  71. frame.setSize(280, 100);
  72. frame.setVisible(true);
  73. new ThisClassEvent();
  74. }
  75. }
  76. import java.awt.*;
  77. import java.awt.event.*;
  78. import javax.swing.*;
  79. class AnonymousEvent extends JFrame{
  80. public AnonymousEvent(){
  81. setLayout(new FlowLayout());
  82. JButton btn=new JButton("ok");
  83. add(btn);
  84. btn.addActionListener(
  85. new ActionListener(){   //匿名内部类作为参数，new 一个lisenter实际上是创建了一个实现了这个listener的类
  86. public void actionPerformed(ActionEvent e){
  87. System.out.println("The OK button is clicked");
  88. }
  89. }
  90. );
  91. }
  92. public static void main(String args[]){
  93. AnonymousEvent frame = new AnonymousEvent();
  94. frame.setTitle("匿名内部类作为事件监听器");
  95. frame.setLocationRelativeTo(null); // Center the frame
  96. frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
  97. frame.setSize(280, 100);
  98. frame.setVisible(true);
  99. new ThisClassEvent();
  100. }
  101. }
时间： 2024-12-13 08:31:22

四种监听器（自身类，外部类，内部类，匿名类）的相关文章

使用模板方法模式+私有内部类+匿名类解决各个方法间代码结构类似的问题。

package org.hibernate.dao; import java.io.Serializable; import org.hibernate.*; import org.hibernate.entity.*; //使用模板方法模式+私有内部类+匿名类解决各个方法间代码结构类似的问题. public class UserDAOImpl implements UserDAO { private abstract class UserDAOTemplate{ abstract protec

Java 嵌套类（Nested Class）：静态嵌套类，内部类，局部类，匿名类

 将一个人比作类,人由大脑.肢体.器官等组成,而嵌套类相当于其中的某个器官,例如心脏:它也有自己的属性和行为(血液.跳动). 嵌套类(Nested Class)的结构: //外部类 class Out { private int age = 12; //嵌套类 class In { public void print() { System.out.println(age); } } } public class Demo { public static void main(String[]

JAVA-接口 抽象类 内部类 匿名类

接口中所有属性是Public static final,方法都是public. 访问修饰符则必须是public 接口也可扩展另一个接口,相似于类的继承,关键字extends http://www.cnblogs.com/dolphin0520/p/3811437.html 深入理解Java的接口和抽象类 http://baike.baidu.com/view/2493204.htm 面向接口编程 接口泛指供别人调用的方法或者函数,是对行为的抽象 继承是一个 "是不是"的关系,而 接口

如何利用c++编写不能被继承、但可以在类外定义对象的类

1 #include <iostream> 2 #include<string> 3 #include<map> 4 #include<vector> 5 #include"thread_pool.h" 6 7 8 using namespace std; 9 template<class T> 10 class base{ 11 friend T;/// friend class 12 private: 13 base(){

集合初始化器、类初始化器、匿名类

1:集合初始化器集合添加数据的两种方法第一种方法:第二种方法:利用集合初始化器2:对象初始化器1.当一个类中有构造方法,我们可以用构造方法来进行实例化一个对象2.当一个类中没有任何的构造方法,这个时候我们就可以利用对象初始化器进行实例化一个对象3:匿名类 原文地址:http://blog.51cto.com/11871779/2087253

编程思想 thisP84 和内部类 匿名类 Android ACTIVITY 跳转

类名.this http://m.blog.csdn.net/blog/nullreference_11109/7746822 15点54分  5月18日 2015年 <第一行代码>P37和P39中有可以参考 参考为知笔记 关键字 FirstActivity.this  Toast  第一行代码 context对象 向下转型

java匿名类和匿名对象及this的其他用法

/* 匿名内部类:就是内部类的简写格式. 必须前提:内部类必须继承或者实现一个类或者接口. 匿名内部类其实就是一个匿名 子类对象. 格式:new 父类对象 or 接口(){ 子类内容:(覆盖父类的, 而且可以增加自己的方法) }//相当于将 继承父类 和 new 的过程 写到了一起有某有!很方便有某有! */ class Outer{ int num; public Outer(){ num = 5; } class Inner{ int num; public Inner(){ num = 1

C++嵌套类（内部类与外部类）

在一个类中定义的类被称为嵌套类,定义嵌套类的类被称为外部类.对类进行嵌套通常是为了帮助实现另一个类,并避免名称冲突. 对类嵌套往往为了帮助实现另一个类,并避免名称冲突.如下: class queue { private: struct Node{ Item item;struct Node *next }; ... }; 由于struct在默认情况下其成员为公有的,   所以Node实际上是一个嵌套类. 作用域 嵌套类的声明位置决定了嵌套类的作用域,即它决定了程序的那部分可以创建嵌套类的对象.

java中的四种内部类

java中的内部类分为四个: 成员内部类 静态内部类 局部内部类 匿名内部类 1. 成员内部类: 定义在另一个类(外部类)的内部,而且与成员方法和属性平级叫成员内部类,......相当于外部类的非静态方法,如果被static修饰,就变成静态内部类了. )成员内部类中不能存在static关键字,即,不能声明静态属性.静态方法.静态代码块等.[非静态内部类也可以定义静态成员但需要同时有final关键词修饰,静态方法鉴于无法用final修饰,仍必须是在静态内部类 或者非内部类中定义.] )创建成员内部