【Java】内部类与外部类的互访使用小结

转自：

内部类又称为嵌套类，可以把内部类理解为外部类的一个普通成员。

内部类访问外部类

里面的可以自由访问外面的，规则和static一样。（访问非静态时必须先创建对象）

具体如下：

非静态内部类的非静态方法

直接访问

[java] view plain copy

1. public class Outter {  
2.     int i = 5;  
3.     static String string = "Hello";  
4.       
5.     class Inner1{  
6.         void Test1 (){  
7.             System.out.println(i);  
8.             System.out.println(string);  
9.         }  
10.     }  
11. }<span style="font-family:Arial,Helvetica,sans-serif"> </span>  

静态内部类的非静态方法

因为静态方法访问非静态外部成员需先创建实例，所以访问i时必须先new外部类。

[java] view plain copy

1. public class Outter {  
2.     int i = 5;  
3.     static String string = "Hello";  
4.       
5.     static class Inner2{  
6.         void Test1 (){  
7.             System.out.println(new Outter().i);  
8.             System.out.println(string);  
9.         }  
10.     }  
11. }  

静态内部类的静态方法

规则如上

[java] view plain copy

1. public class Outter {  
2.     int i = 5;  
3.     static String string = "Hello";  
4.       
5.     static class Inner2{  
6.         static void Test2 (){  
7.             System.out.println(new Outter().i);  
8.             System.out.println(string);  
9.         }  
10.     }  
11. }<span style="font-family:Arial,Helvetica,sans-serif"> </span>  

 外部类访问内部类

大方向：因为将内部类理解为外部类的一个普通成员，所以外面的访问里面的需先new一个对象。

非静态方法访问非静态内部类的成员：

new 内部类对象

[java] view plain copy

1. public class Outter {  
2.     void Test1(){  
3.         System.out.println(new Inner1().i);  
4.     }  
5.     class Inner1{  
6.         int i = 5;  
7. //      static String string = "Hello";  定义错误！  
8.     }  
9. }  

 静态方法访问非静态内部类的成员

静态方法Test2访问非静态Inner1需先new外部类；

继续访问非静态成员i需先new 内部类

所以访问规则为：new Outter().new Inner1().i。

[java] view plain copy

1. public class Outter {  
2.     static void Test2(){  
3.         System.out.println(new Outter().new Inner1().i);  
4.     }  
5.     class Inner1{  
6.         int i = 5;  
7. //      static String string = "Hello";  定义错误！  
8.     }  
9. }<span style="font-family:Arial,Helvetica,sans-serif"> </span>  

非静态方法访问静态内部类的成员

先“外部类.内部类”访问至内部类。

若访问静态成员，则需先new再访问；若访问非静态成员，则可直接访问。

[java] view plain copy

1. public class Outter {  
2.     void Test1(){  
3.         Outter.Inner2 inner2 = new Outter.Inner2();  
4.         System.out.println(inner2.i);  
5.         System.out.println(inner2.string);  
6.         System.out.println(Outter.Inner2.string);  
7.     }  
8.     static class Inner2{  
9.         int i = 5;  
10.         static String string = "Hello";   
11.     }  
12. }<span style="font-family:Arial,Helvetica,sans-serif"> </span>  

非静态方法访问非静态内部类的成员

先“外部类.内部类”访问至内部类，再new即可访问静态成员。

[java] view plain copy

1. public class Outter {  
2.     void Test1(){  
3.         Outter.Inner1 inner2 = new Outter.Inner1();  
4.         System.out.println(inner2.i);  
5.     }  
6.     class Inner1{  
7.         int i = 5;  
8. //      static String string = "Hello"; 定义错误！  
9.     }  
10. }  

 

匿名内部类

匿名内部类访问外部成员变量时，成员变量前应加final关键字。

[java] view plain copy

1. final int k = 6;  
2. ((Button)findViewById(R.id.button2)).setOnClickListener(new OnClickListener() {  
3.     @Override  
4.     public void onClick(View v) {  
5.         // TODO Auto-generated method stub  
6.         System.out.println(k);  
7.     }  

1. });