对于内部匿名类一点点货色

Java内门类与匿名类详解

最新推荐文章于 2025-12-13 12:19:21 发布

原创最新推荐文章于 2025-12-13 12:19:21 发布 · 395 阅读

1 ·

CC 4.0 BY-SA版权

文章标签：

#string #class #thread #import #exception #java

内部匿名类是一个很非一般的内门类,通常惟独干GUI的人都市常常涉及到他

存在它的原因是:
1.一个内类型的对象能够访问创设它的对象的兑现，包括私有底据。即内类型范例对包孕它的哪个种的范例来说，是特权的。
二.关于同一个包中的其余种来说,内类型能够掩藏起来,换言之，内类型甭管步骤的看得出性何以，那怕是public，除开包容种，其余种都没法施用它。
三.匿名内门类可以很便利的定义回调。
四.应用内门类可以十分便利的编撰事件驱动程序。

实则它真个的目的单单为了定义回调－－更上一层楼乃是事件驱动。
接口和回调：编程一个惯用的形式是回调方式,在这种形式中你可以指定当一个特定时间发作时回调对象上的步骤。

匿名种和内类型中的中的this :
有时，我们会用到一些内类型和匿名种。当在匿名类顶用this时，这个this则指的是匿名种或内类型自身。
这时候如其我们要运用外类型的步骤和变量的话，则应当加上外门类的类名。如次面这个例证：

Java代码
一.public class A {
2. int i = 一;
3. public A() {
4. Thread thread = new Thread() {
5. public void run() {
6. for(;;) {
7. A.this.run();
8. try {
9. sleep(1000);
10. } catch(InterruptedException ie) {
11. }
12. }
13. }
14. };
15. thread.start();
16. }
17. public void run() {
18. System.out.println("i = " + i);
19. i++;
20. }
21. public static void main(String[] args) throws Exception {
22. new A();
23. }
24.}
public class A {
int i = 一;
public A() {
Thread thread = new Thread() {
public void run() {
for(;;) {
A.this.run();
try {
sleep(1000);
} catch(InterruptedException ie) {
}
}
}
};
thread.start();
}
public void run() {
System.out.println("i = " + i);
i++;
}
public static void main(String[] args) throws Exception {
new A();
}
}

在上面这个例证中, thread 是一个匿名种对象，在它的定义中，它的 run 函数里用到了外门类的 run 函数。
这时候因为函数同名，直接调用就不行了。这时候有两种办法，一种乃是把外部的 run 函数换一个名字，但这种办法关于一个开发到半路的运用来说是不可取的
。那么就可以用这个例证中的办法用外类型的类名加上 this 引述来说明要调用的是外门类的步骤 run。

关于这个例证：

Java代码
一.this.test(new Inner(){
2. public void method一(){
3. System.out.print("1111");
4. }
5.
6. public void method二(){
7. System.out.print("22222");
8. }
9.});
this.test(new Inner(){
public void method一(){
System.out.print("1111");
}

public void method二(){
System.out.print("22222");
}
});

这个时分调用test()步骤，那Inner种的method一和method二是什么时候被调用的？难道说也是this对象向他们发讯息（例如传到一个参数）吗？仍是直接显式的调用？？

关于Inner种，除开this这个种，乃是this.test(...那句中的this，它能够调用Inner种的步骤，其余地方都不行，然则，这也急需你在种中有个地方封存有对这个内类型范例的引述才可以。再则明一次，内类型是用以在某个时时调用外头的步骤而存在的－－这乃是回调。

为了说明内门类范例的步骤唯其如此在包容种的范例中调用，其余地方没法调用，给个事例如次：
JAVA二适用课程源码：

Java代码
1./** 一个应用程序，用以演练内类型的运用 */
2./** 种Outer */
三.class Outer{
四.private static int size;
5./** 内门类Inner的宣言 */
六.public class Inner{
七.private int size;
8./** 步骤doStuff() */
九.public void doStuff(int size){
十.size++; //存取局部变量
11.this.size++; //存取其内类型的成员变量
12.Outer.this.size++; //存取其外类型的成员变量
13.System.out.println(size+" "+this.size+" "+Outer.this.size);
14.}
15.}//内门类Inner完事
16./** 种Outer中定义的范例步骤testInner()步骤 */
17.public void testInner(){
18.Inner i=new Inner();
19.i.doStuff(五);
20.}
21./** main()步骤 */
22.public static void main(String[] a){
23.Outer o=new Outer();
24.o.testInner();
25.}
26.}//种Outer完事
/** 一个应用程序，用以演练内类型的施用 */
/** 种Outer */
class Outer{
private static int size;
/** 内门类Inner的宣言 */
public class Inner{
private int size;
/** 步骤doStuff() */
public void doStuff(int size){
size++; //存取局部变量
this.size++; //存取其内门类的成员变量
Outer.this.size++; //存取其外门类的成员变量
System.out.println(size+" "+this.size+" "+Outer.this.size);
}
}//内门类Inner终结
/** 种Outer中定义的范例步骤testInner()步骤 */
public void testInner(){
Inner i=new Inner();
i.doStuff(五);
}
/** main()步骤 */
public static void main(String[] a){
Outer o=new Outer();
o.testInner();
}
}//种Outer完了

那么，何以应用内类型,匿名类兑现事件处置呢？
JAVA---事件适配器

一．事件适配器--EventAdapter
　　下例中采取了鼠标适配器：

Java代码
一.import java.awt.*;
2.　　import java.awt.event.*;
3.　　public class MouseClickHandler extends MouseAdaper{
4.　　　　public void mouseClicked(MouseEvent e) //只兑现亟需的步骤
5.　　　　　　　{ ……}
6.　　}
import java.awt.*;
　　import java.awt.event.*;
　　public class MouseClickHandler extends MouseAdaper{
　　　　public void mouseClicked(MouseEvent e) //只兑现亟需的步骤
　　　　　　　{ ……}
　　}
　　java.awt.event包中定义的事件适配器类包括以次几个：
　　一．ComponentAdapter( 组件适配器)
　　二．ContainerAdapter( 器皿适配器)
　　三．FocusAdapter( 焦点适配器)
　　四．KeyAdapter( 键盘适配器)
　　五．MouseAdapter( 鼠标适配器)
　　六．MouseMotionAdapter( 鼠标运动适配器)
　　七．WindowAdapter( 窗口适配器)
　2. 用内类型兑现事件处置
　　内类型（inner class）是被定义于另一个类中的种，应用内门类的重要原因是因为：
　　◇ 一个内类型的对象可访问外类型的成员步骤和变量，包括私有的成员。
　　◇ 兑现事件监听器时，采取内类型、匿名类编程十分简单兑现其效能。
　　◇ 编撰事件驱动程序，内门类很便利。　　
　　因而内门类所能够运用的地方往往是在AWT的事件处理机制中。
例5.11

Java代码
一.import java.awt.* ;
2.　　　import java.awt.event.*；
3.　　　　　public class InnerClass{
4.　　　　　　　private Frame f;
5.　　　　　　　private TextField tf;
6.　　　　　　　public InnerClass(){
7.　　　　　　　f=new Frame("Inner classes example");
8.　　　　　　　tf=new TextField(30);
9.　　　　　}
10.　　　　　public voidi launchFrame(){
11.　　　　　　　Label label=new Label("Click and drag the mouse");
12.　　　　　　　f.add(label,BorderLayout.NORTH);
13.　　　　　　　f.add(tf,BorderLayout.SOUTH);
14.　　　　　　　f.addMouseMotionListener(new MyMouseMotionListener());/*参数为内类型对象*/
15.　　　　　　　f.setSize(300,200);
16.　　　　　　　f.setVisible(true);
17.　　　　　}
18.　　　　　class MyMouseMotionListener extends MouseMotionAdapter{ /*内门类开始*/
19.　　　　　　　public void mouseDragged(MouseEvent e) {
20.　　　　　　　　　String s="Mouse dragging: x="+e.getX()+"Y="+e.getY();
21.　　　　　　　　　tf.setText(s); }
22.　　　　　　　} ;
23.　　　　　　　public static void main(String args[]) {
24.　　　　　　　　　InnerClass obj=new InnerClass();
25.　　　　　　　　　obj.launchFrame();
26.　　　　　　　}
27.　　　　　}//内类型终结
28.　　　　}
import java.awt.* ;
　　　import java.awt.event.*；
　　　　　public class InnerClass{
　　　　　　　private Frame f;
　　　　　　　private TextField tf;
　　　　　　　public InnerClass(){
　　　　　　　f=new Frame("Inner classes example");
　　　　　　　tf=new TextField(30);
　　　　　}
　　　　　public voidi launchFrame(){
　　　　　　　Label label=new Label("Click and drag the mouse");
　　　　　　　f.add(label,BorderLayout.NORTH);
　　　　　　　f.add(tf,BorderLayout.SOUTH);
　　　　　　　f.addMouseMotionListener(new MyMouseMotionListener());/*参数为内门类对象*/
　　　　　　　f.setSize(300,200);
　　　　　　　f.setVisible(true);
　　　　　}
　　　　　class MyMouseMotionListener extends MouseMotionAdapter{ /*内类型开始*/
　　　　　　　public void mouseDragged(MouseEvent e) {
　　　　　　　　　String s="Mouse dragging: x="+e.getX()+"Y="+e.getY();
　　　　　　　　　tf.setText(s); }
　　　　　　　} ;
　　　　　　　public static void main(String args[]) {
　　　　　　　　　InnerClass obj=new InnerClass();
　　　　　　　　　obj.launchFrame();
　　　　　　　}
　　　　　}//内类型完事
　　　　}

三．匿名种（Anonymous Class）
　　应一个内门类的种声名只是在创设该类对象时用了一次，并且要发生的新类需承袭于一个已有的父类或兑现一个接口，才华思考用匿名种，因为匿名类自身默默无闻，因而它也就不存在结构步骤，它急需展示地调用一个无参的父
种的结构步骤，而且重写父类的步骤。所谓的匿名乃是此类连名字都没有，只是展示地调用一个无参的父类的结构步骤。
例5.12

Java代码
一.import java.awt.* ;
2.　　　import java.awt.event.*;
3.　　　　public class AnonymousClass{
4.　　　　　private Frame f;
5.　　　　　private TextField tf;
6.　　　　　public AnonymousClass(){
7.　　　　　　f=new Frame("Inner classes example");
8.　　　　　　tf=new TextField(30);
9.　　　　}
10.　　　　public void launchFrame(){
11.　　　　　　Label label=new Label("Click and drag the mouse");
12.　　　　　　f.add(label,BorderLayout.NORTH);
13.　　　　　　f.add(tf,BorderLayout.SOUTH);
14.　　　　　　f.addMouseMotionListener(new MouseMotionAdapter(){ //匿名类开始
15.　　　　　　　public void mouseDragged(MouseEvent e){
16.　　　　　　　　String s="Mouse dragging: x="+e.getX()+"Y="+e.getY();
17.　　　　　　　　tf.setText(s); }
18.　　　　　　} ); //匿名类完结
19.　　　　　　f.setSize(300,200);
20.　　　　　　f.setVisible(true);
21.　　　　　　}
22.　　　　　　　public static void main(String args[]) {
23.　　　　　　　　AnonymousClass obj=new AnonymousClass();
24.　　　　　　　　obj.launchFrame();
25.　　　　　　　　}
26.　　　　　　}
import java.awt.* ;
　　　import java.awt.event.*;
　　　　public class AnonymousClass{
　　　　　private Frame f;
　　　　　private TextField tf;
　　　　　public AnonymousClass(){
　　　　　　f=new Frame("Inner classes example");
　　　　　　tf=new TextField(30);
　　　　}
　　　　public void launchFrame(){
　　　　　　Label label=new Label("Click and drag the mouse");
　　　　　　f.add(label,BorderLayout.NORTH);
　　　　　　f.add(tf,BorderLayout.SOUTH);
　　　　　　f.addMouseMotionListener(new MouseMotionAdapter(){ //匿名类开始
　　　　　　　public void mouseDragged(MouseEvent e){
　　　　　　　　String s="Mouse dragging: x="+e.getX()+"Y="+e.getY();
　　　　　　　　tf.setText(s); }
　　　　　　} ); //匿名类终结
　　　　　　f.setSize(300,200);
　　　　　　f.setVisible(true);
　　　　　　}
　　　　　　　public static void main(String args[]) {
　　　　　　　　AnonymousClass obj=new AnonymousClass();
　　　　　　　　obj.launchFrame();
　　　　　　　　}
　　　　　　}
　　实则仔细分析，例5.11和5.12兑现的都是完全同样的效能，只不过采用的模式不同。5.11中的事件处置类是一个内类型，而5.12的事件处置类是匿名种，可以说从种的关系来说是愈来愈不清楚，但
是程序也愈来愈精练。熟习这两种模式也非常有助于编纂图形界面的程序。
亲消遥IDE中实践一下子，会了解的更深切1点

本文来源：
我的异常网
 Java Exception
Dotnet Exception
Oracle Exception