java - 内部类

内部类分为4种

[plain]  view plain  copy

1. 成员内部类(非静态内部类)  
2. 局部内部类  
3. 静态内部类  
4. 匿名内部类  

成员内部类(member inner class)非静态内部类

[plain]  view plain  copy

1. 定义在外部类里面不使用static修饰  
2. 成员内部类相当于外部类的成员,内部类可以访问外部类一切成员  
3. 编译之后生成.class文件: OutterClass$InnerClass.class   
4. 内部类不可以有静态成员  

案例

[java]  view plain  copy

1. package com.itlwc;  
2.   
3. class OutterClass {  
4.     int x = 100;  
5.     class InnerClass {  
6.         int x = 50;  
7.   
8.         public void show() {  
9.             //使用预定义对象引用this  
10.             System.out.println("调用外部类成员x = " + OutterClass.this.x);  
11.             System.out.println("调用成员内部类成员x = " + this.x);  
12.         }  
13.     }  
14. }  
15.   
16. public class Test {  
17.     public static void main(String[] args) {  
18.         //生成对象的方法  
19.         OutterClass.InnerClass ocic = new OutterClass().new InnerClass();  
20.         ocic.show();  
21.     }  
22. }  
23. /* 
24. 打印结果: 
25.     调用外部类成员x = 100 
26.     调用成员内部类成员x = 50 
27. */  

局部内部类(local inner class)

[java]  view plain  copy

1. 定义在方法中  
2. 局部内部类只能访问局部final的成员  

案例

[java]  view plain  copy

1. package com.itlwc;  
2.   
3. class OutterClass {  
4.     public void getInnerClass() {  
5.         // 局部内部类只能访问final的变量  
6.         final int x = 0;  
7.         class InnerClass {  
8.             public void show() {  
9.                 System.out.println("局部内部类的方法" + x);  
10.             }  
11.         }  
12.         InnerClass ic = new InnerClass();  
13.         ic.show();  
14.     }  
15. }  
16.   
17. public class Test {  
18.     public static void main(String[] args) {  
19.         OutterClass oc = new OutterClass();  
20.         oc.getInnerClass();  
21.     }  
22. }  
23. /* 
24. 打印结果: 
25.     局部内部类的方法0 
26. */  

静态内部类(static inner class)

[plain]  view plain  copy

1. 定义在类的里面使用static关键字  
2. 编译之后生成.class文件: OutterClass$InnerClass.class  
3. 静态内部类只能访问静态成员  
4. 静态内部类不能使用this  

案例

[java]  view plain  copy

1. package com.itlwc;  
2.   
3. class OutterClass {  
4.     static class InnerClass {  
5.         public void show() {  
6.             System.out.println("静态内部类的方法");  
7.         }  
8.     }  
9. }  
10.   
11. public class Test {  
12.     public static void main(String[] args) {  
13.         //生成对象的方法  
14.         OutterClass.InnerClass oi = new OutterClass.InnerClass();  
15.         oi.show();  
16.     }  
17. }  
18. /* 
19. 打印结果: 
20.     静态内部类的方法 
21. */  

非静态内部类和静态内部类的区别

[java]  view plain  copy

1. 非静态内部类与外部类对象成员存在共享关系,是外部类的组成部分,用来辅助工作  
2. 静态内部类与外部类之间没有这样的关系,静态内部类已经脱离了外部类的控制,  
3.     static关键字只是说明创建对象不依赖外部类的引用的存在,并不是说这个类是静态的  

匿名内部类(anonymous inner class)

[java]  view plain  copy

1. 定义:没有名字的内部类  
2. 匿名内部类没有名称,因此匿名内部类在声明类的同时也创建了对象  
3. 匿名内部类没有class,名字,extends,implements,构造方法,  
4.     但它会隐式继承一个父类或者实现一个接口,这两个不能同时(这个是内部类很重要的特点)  
5. 因为匿名内部类没有名称,没办法声明匿名内部类类型的引用,  
6.     因此匿名内部类中的成员只能内部使用  
7. 匿名内部类对象的使用都是通过多态进行的,  
8.     如果匿名内部类重写了父类方法,可以通过多态让父类的引用调用匿名内部类的方法  
9.     (案例一)  
10. 匿名内部类编译后也是一个独立的类文件,  
11.     由于没有名字,使用数字代替,如 OutClass$1.class  
12. 匿名内部类对象初始化的代码可以写在非静态语句块中  
13.     (案例二)  

案例一

[java]  view plain  copy

1. package com.itlwc;  
2.   
3. class Father {  
4.     public void show() {  
5.         System.out.println("Father类的方法");  
6.     }  
7. }  
8.   
9. public class Test {  
10.     public static void main(String[] args) {  
11.         // 定义匿名内部类并创建对象  
12.         Father f = new Father() {  
13.             // 重写了父类的方法  
14.             public void show() {  
15.                 System.out.println("匿名内部类的方法");  
16.             }  
17.         };  
18.         // 通过多态调用了父类的引用调用了子类的对象  
19.         f.show();  
20.     }  
21. }  
22. /* 
23. 打印结果: 
24.     匿名内部类的方法 
25. */  

案例二

[java]  view plain  copy

1. package com.itlwc;  
2.   
3. abstract class Father {  
4.     int age;  
5.   
6.     abstract void show();  
7. }  
8.   
9. public class Test {  
10.     public static void main(String[] args) {  
11.         // 定义匿名内部类并创建对象  
12.         Father f = new Father() {  
13.             // 非静态代码块中对成员age进行初始化  
14.             {  
15.                 age = 18;  
16.             }  
17.   
18.             // 实现父类的方法  
19.             public void show() {  
20.                 System.out.println("年龄 = " + age);  
21.             }  
22.         };  
23.         // 通过多态使用父类的引用调用子类对象  
24.         f.show();  
25.     }  
26. }  
27. /* 
28. 打印结果: 
29.     年龄 = 18 
30. */  

有名字的内部类和匿名内部类的区别

[java]  view plain  copy

1. 如果有两个或者两个方法会使用该类,建议使用内部类  
2. 如果只有一个方法使用该类,建议使用匿名内部类