内部类总结

类的成员变量通常可以分为三种
 1.实例成员变量,也就是不带static 修饰符的成员变量
 2.静态成员变量,也就是带static 修饰符的成员变量
 3.局部变量 也就是写在方法内部的成员变量

同样的,内部类也可以分为三种
1.实例内部类,也就是不带static 修饰符的内部类
2.静态内部类,也就是带static 修饰符的内部类
3.局部内部类,也就是写在方法内部的内部类

一.实例内部类的特点:
1.实例内部类的初始化.因为实例内部类自动获取外部类的引用,所有实例内部类的初始化必须写成这样:

java 代码

1. OuterClass.InnerClass innerClass = new OuterClass().new InnerClass();   

也可以省略掉OuterClass:

 

java 代码

1. InnerClass innerClass = new OuterClass().new InnerClass();   

 

也可以

java 代码

1. uterClass outer = new OuterClass();   
2. InnerClass inner = outer.new InnerClass();  

 

2.每个外部对象都有一个相应的内部类,两个对象之间的内部类里面的属性互不干扰.

java 代码

1. class OuterClass {   
2.        
3.     private class InnerClass {   
4.            
5.          String innerWord = "innerWord";   
6.     }   
7.     public static void main(String[] args){   
8.         OuterClass outer = new OuterClass();   
9.         InnerClass inner = outer.new InnerClass();   
10.            
11.         System.out.println(inner.innerWord); //innerWord   
12.         inner.innerWord="modified innerWord";   
13.            
14.         InnerClass inner2 = outer.new InnerClass();   
15.         System.out.println(inner2.innerWord);   //innerWord   
16.            
17.     }   
18. }   

 

3. JVM会自动使内部类实例引用它的外部类的实例,因此实例内部类自动获得对外部类的引用,它可以访问外部类的所有成员变量.

java 代码

1. public class OuterClass {   
2. private String value="Outer value";   
3. static private String key="Outer key";   
4.        
5. class InnerClass {   
6.         public void tt(){   
7.             value = "Inner value";   
8.             key = "Inner  key";   
9.         }   
10.     }   
11.   
12. }  

 

4.根据jvm的类加载机制(静态成员属于类,实例成员属于对象, 加载静态成员发生在类加载期,而加载实例成员发生在创建对象期),实例内部类是不能拥有静态方法和静态变量.
5.接口和抽象类同样可以拥有内部类,内部类自动拥有他们的实现类

java 代码

1. abstract class OuterClass {   
2.     private String value="Outer value";   
3.     static private String key="Outer key";   
4.        
5.     class InnerClass {   
6.         public  void tt(){   
7.             value = "11";   
8.             key = "11";   
9.         }   
10.     }   
11.        
12.     public void tt(){   
13.         //error!不能实例化OuterClass();   
14. //InnerClass innerClass = new OuterClass().new InnerClass();   
15.     }   
16.        
17. }   
18. class OuterClassImp extends OuterClass{   
19.     public void tt(){   
20.         InnerClass innerClass = new OuterClassImp().new InnerClass();   
21.     }   
22. }  

6.在直接构造内部类的实例时，JVM会自动使内部类实例引用它的外部类的实例,
比如:

如果另一个外部类继承一个内部类

java 代码

1. class Sample extends OuterClass.InnerClass{   
2. }  

 

java 代码

1. InnerClass innerClass  = new Sampe().  

JVM就无法决定让Sample的实例引用哪个Outer的实例

为了避免这种矛盾，JVM要求Sample的构造函数必须通过参数。传递一个Outer实例的引用，然后在构造方法中调用super语句来建立Sample实例与Outer实例的联系

java 代码

1. class Sample extends OuterClass.InnerClass{   
2.     Sample(OuterClass o){   
3.         o.super();   
4. }   
5. }  

 

java 代码

1. OuterClass out = new OuterClass();   
2. InnerClass innerClass = out.new Sample();