java 内部类

首先先区别两个概念类级内部类和对象级内部类

　 简单点说，类级内部类指的是，有static修饰的成员式内部类。

如果没有static修饰的成员式内部类被称为对象级内部类。

　　   类级内部类相当于其外部类的static成分，它的对象与外部类对象间不存在依赖关系，因此可直接创建。而对象级内部类的实例，是绑定在外部对象实例中的。

　　 类级内部类中，可以定义静态的方法。在静态方法中只能够引用外部类中的静态成员方法或者成员变量。

　   　类级内部类相当于其外部类的成员，只有在第一次被使用的时候才被会装载。

这一篇主要讲对象级内部类，下一篇会讲到类级内部类

下面看一个简单的例子

[java]  view plain  copy

 print ?

1. public class Father {  
2.     /* 
3.      * Son 是内部类 
4.      */  
5.     public class Son  
6.     {  
7.         public void eat()  
8.         {  
9.             System.out.println("eating");  
10.         }  
11.     }  
12.       
13.     public static void main(String[] args) {  
14.         new Father().new Son().eat();  
15.     }  
16. }  

从例子中可以看出 Father是父类

Son是内部类，再看一下怎么调用内部类，先实例化父类对象new Father,通过父类对象直接调用new Son()实例化内部类，接着就可以调用内部类的方法了eat()了。

介绍完了Java的内部类的简单的例子，下面我还想再说一下  内部类的注意事项。

第一点内部类可以访问外部类的属性和变量，不受private的限制

例子

[java]  view plain  copy

 print ?

1. public class Father {  
2.       
3.     private String foodnameString = "dumpling";  
4.       
5.     /* 
6.      * Son 是内部类 
7.      */  
8.     public class Son  
9.     {  
10.         public void eat()  
11.         {  
12.             System.out.println("eating "+foodnameString);  
13.         }  
14.     }  
15.       
16.     public static void main(String[] args) {  
17.         new Father().new Son().eat();  
18.     }  
19. }  

输出

[java]  view plain  copy

 print ?

1. eating <span style="font-family: Arial, Helvetica, sans-serif;">dumpling</span>  

可以看出内部类可以直接访问外部类的变量

第二点:

外部类不能调用内部类的方法和变量，需要先创建内部类的对象。例子参考上面的代码。

第三点：

如果内外部类有同名变量可以使用this关键字来区分

例子如下：

[java]  view plain  copy

 print ?

1. public class Father {  
2.       
3.     private String foodnameString = "dumpling";  
4.       
5.     /* 
6.      * Son 是内部类 
7.      */  
8.     public class Son  
9.     {  
10.         private String foodnameString = "apple";  
11.         public void eat()  
12.         {  
13.             System.out.println("i want eat "+Father.this.foodnameString + " but i eating "+foodnameString);  
14.         }  
15.     }  
16.       
17.     public static void main(String[] args) {  
18.         new Father().new Son().eat();  
19.     }  
20. }  

输出结果是

i want eat dumpling but i eating apple

第四点

内部类只有在实现的时候才被加载，实现了懒加载

看例子

[java]  view plain  copy

 print ?

1. public class Father {  
2.       
3.     private static String foodnameString = "dumpling";  
4.       
5.     /* 
6.      * Son 是内部类 
7.      */  
8.     public class Son  
9.     {  
10.         public Son()  
11.         {  
12.             System.out.println("子类被实例化");  
13.             Father.this.foodnameString = "apple";  
14.         }  
15.     }  
16.       
17.     public static void main(String[] args) {  
18.         System.out.println(""+foodnameString);  
19.     }  
20. }  

输出结果是

dumpling

上面代码尽管写了内部类，但是并没有执行赋值操作。

现在吧上述代码添加一行代码

[java]  view plain  copy

 print ?

1. public class Father {  
2.       
3.     private static String foodnameString = "dumpling";  
4.       
5.     /* 
6.      * Son 是内部类 
7.      */  
8.     public class Son  
9.     {  
10.         public Son()  
11.         {  
12.             System.out.println("子类被实例化");  
13.             Father.this.foodnameString = "apple";  
14.         }  
15.     }  
16.       
17.     public static void main(String[] args) {  
18.         new Father().new Son();  
19.         System.out.println(""+foodnameString);  
20.     }  
21. }  

输出结果为

子类被实例化
apple

好的内部类就介绍的这啦

还是那句话，希望对您有帮助，同时发现有问题的同学欢迎批评指正，来留言阿。