内部类

首页 > 代码库 > 内部类

2024-07-31 19:15:26 243人阅读

内部类是指在一个外部类的内部再定义一个类。类名不需要和文件夹相同。

*内部类可以是静态static的，也可用public，default，protected和private修饰。（而外部顶级类即类名和文件名相同的只能使用public和default）。

注意：内部类是一个编译时的概念，一旦编译成功，就会成为完全不同的两类。对于一个名为outer的外部类和其内部定义的名为inner的内部类。编译完成后出现outer.class和outer$inner.class两类。所以内部类的成员变量/方法名可以和外部类的相同。

1. 成员内部类

成员内部类，就是作为外部类的成员，可以直接使用外部类的所有成员和方法，即使是private的。同时外部类要访问内部类的所有成员变量/方法，则需要通过内部类的对象来获取。

要注意的是，成员内部类不能含有static的变量和方法。 因为成员内部类需要先创建了外部类，才能创建它自己的，了解这一点，就可以明白更多事情，在此省略更多的细节了。

在成员内部类要引用外部类对象时，使用outer.this来表示外部类对象；

而需要创建内部类对象，可以使用outer.inner obj = outerobj.new inner();

 
 


  
  
  
  
 
  
 
  
   public class Outer {  
  
  
  
  
 
  
 
  
       public static void main(String[] args) {  
  
  
  
  
 
  
 
  
           Outer outer = new Outer();  
  
  
  
  
 
  
 
  
           Outer.Inner inner = outer.new Inner();  
  
  
  
  
 
  
 
  
           inner.print("Outer.new");  
  
  
  
  
 
  
 
  
     
  
  
  
  
 
  
 
  
           inner = outer.getInner();  
  
  
  
  
 
  
 
  
           inner.print("Outer.get");  
  
  
  
  
 
  
 
  
       }  
  
  
  
  
 
  
 
  
     
  
  
  
  
 
  
 
  
       // 个人推荐使用getxxx()来获取成员内部类，尤其是该内部类的构造函数无参数时  
  
  
  
  
 
  
 
  
       public Inner getInner() {  
  
  
  
  
 
  
 
  
           return new Inner();  
  
  
  
  
 
  
 
  
       }  
  
  
  
  
 
  
 
  
     
  
  
  
  
 
  
 
  
       public class Inner {  
  
  
  
  
 
  
 
  
           public void print(String str) {  
  
  
  
  
 
  
 
  
               System.out.println(str);  
  
  
  
  
 
  
 
  
           }  
  
  
  
  
 
  
 
  
       }  
  
  
  
  
 
  
 
  
   }

2. 局部内部类

局部内部类，是指内部类定义在方法和作用域内。Thinking in Java给了这么两个例子：

定义在方法内：

 
 


  
  
  
  
 
  
 
  
   public class Parcel4 {  
  
  
  
  
 
  
 
  
       public Destination destination(String s) {  
  
  
  
  
 
  
 
  
           class PDestination implements Destination {  
  
  
  
  
 
  
 
  
               private String label;  
  
  
  
  
 
  
 
  
     
  
  
  
  
 
  
 
  
               private PDestination(String whereTo) {  
  
  
  
  
 
  
 
  
                   label = whereTo;  
  
  
  
  
 
  
 
  
               }  
  
  
  
  
 
  
 
  
     
  
  
  
  
 
  
 
  
               public String readLabel() {  
  
  
  
  
 
  
 
  
                   return label;  
  
  
  
  
 
  
 
  
               }  
  
  
  
  
 
  
 
  
           }  
  
  
  
  
 
  
 
  
           return new PDestination(s);  
  
  
  
  
 
  
 
  
       }  
  
  
  
  
 
  
 
  
     
  
  
  
  
 
  
 
  
       public static void main(String[] args) {  
  
  
  
  
 
  
 
  
           Parcel4 p = new Parcel4();  
  
  
  
  
 
  
 
  
           Destination d = p.destination("Tasmania");  
  
  
  
  
 
  
 
  
       }  
  
  
  
  
 
  
 
  
   }

定义在作用域里：

 
 


  
  
  
  
 
  
 
  
   public class Parcel5 {  
  
  
  
  
 
  
 
  
       private void internalTracking(boolean b) {  
  
  
  
  
 
  
 
  
           if (b) {  
  
  
  
  
 
  
 
  
               class TrackingSlip {  
  
  
  
  
 
  
 
  
                   private String id;  
  
  
  
  
 
  
 
  
                   TrackingSlip(String s) {  
  
  
  
  
 
  
 
  
                       id = s;  
  
  
  
  
 
  
 
  
                   }  
  
  
  
  
 
  
 
  
                   String getSlip() {  
  
  
  
  
 
  
 
  
                       return id;  
  
  
  
  
 
  
 
  
                   }  
  
  
  
  
 
  
 
  
               }  
  
  
  
  
 
  
 
  
               TrackingSlip ts = new TrackingSlip("slip");  
  
  
  
  
 
  
 
  
               String s = ts.getSlip();  
  
  
  
  
 
  
 
  
           }  
  
  
  
  
 
  
 
  
       }  
  
  
  
  
 
  
 
  
     
  
  
  
  
 
  
 
  
       public void track() {  
  
  
  
  
 
  
 
  
           internalTracking(true);  
  
  
  
  
 
  
 
  
       }  
  
  
  
  
 
  
 
  
     
  
  
  
  
 
  
 
  
       public static void main(String[] args) {  
  
  
  
  
 
  
 
  
           Parcel5 p = new Parcel5();  
  
  
  
  
 
  
 
  
           p.track();  
  
  
  
  
 
  
 
  
       }  
  
  
  
  
 
  
 
  
   }

局部内部类也像别的类一样进行编译，但只是作用域不同而已，只在该方法或条件的作用域内才能使用，退出这些作用域后无法引用的。

3. 嵌套内部类

嵌套内部类，就是修饰为static的内部类。声明为static的内部类，不需要内部类对象和外部类对象之间的联系，就是说我们可以直接引用outer.inner，即不需要创建外部类，也不需要创建内部类。

嵌套类和普通的内部类还有一个区别：普通内部类不能有static数据和static属性，也不能包含嵌套类，但嵌套类可以。而嵌套类不能声明为private，一般声明为public，方便调用。

4. 匿名内部类

有时候我为了免去给内部类命名，便倾向于使用匿名内部类，因为它没有名字。例如：

 
 


  
  
  
  
 
  
 
  
   ((Button) findViewById(R.id.start)).setOnClickListener(new Button.OnClickListener() {  
  
  
  
  
 
  
 
  
       @Override  
  
  
  
  
 
  
 
  
       public void onClick(View v) {  
  
  
  
  
 
  
 
  
           new Thread() {  
  
  
  
  
 
  
 
  
     
  
  
  
  
 
  
 
  
               @Override  
  
  
  
  
 
  
 
  
               public void run() {  
  
  
  
  
 
  
 
  
                   // TODO Auto-generated method stub  
  
  
  
  
 
  
 
  
               }  
  
  
  
  
 
  
 
  
     
  
  
  
  
 
  
 
  
           }.start();  
  
  
  
  
 
  
 
  
       }  
  
  
  
  
 
  
 
  
   });

匿名内部类是不能加访问修饰符的。 要注意的是，new 匿名类，这个类是要先定义的，看下面例子：

 
 


  
  
  
  
 
  
 
  
   public class Outer {  
  
  
  
  
 
  
 
  
       public static void main(String[] args) {  
  
  
  
  
 
  
 
  
           Outer outer = new Outer();  
  
  
  
  
 
  
 
  
           Inner inner = outer.getInner("Inner", "gz");  
  
  
  
  
 
  
 
  
           System.out.println(inner.getName());  
  
  
  
  
 
  
 
  
       }  
  
  
  
  
 
  
 
  
     
  
  
  
  
 
  
 
  
       public Inner getInner(final String name, String city) {  
  
  
  
  
 
  
 
  
           return new Inner() {  
  
  
  
  
 
  
 
  
               private String nameStr = name;  
  
  
  
  
 
  
 
  
     
  
  
  
  
 
  
 
  
               public String getName() {  
  
  
  
  
 
  
 
  
                   return nameStr;  
  
  
  
  
 
  
 
  
               }  
  
  
  
  
 
  
 
  
           };  
  
  
  
  
 
  
 
  
       }  
  
  
  
  
 
  
 
  
   }  
  
  
  
  
 
  
 
  
     
  
  
  
  
 
  
 
  
   //注释后，编译时提示类Inner找不到  
  
  
  
  
 
  
 
  
   /* interface Inner {  
  
  
  
  
 
  
 
  
       String getName();  
  
  
  
  
 
  
 
  
   } */

同时在这个例子，留意外部类的方法的形参， 当所在的方法的形参需要被内部类里面使用时，该形参必须为final。这里可以看到形参name已经定义为final了，而形参city 没有被使用则不用定义为final。为什么要定义为final呢？在网上找到本人比较如同的解释：

“这是一个编译器设计的问题，如果你了解java的编译原理的话很容易理解。

首先，内部类被编译的时候会生成一个单独的内部类的.class文件，这个文件并不与外部类在同一class文件中。

当外部类传的参数被内部类调用时，从java程序的角度来看是直接的调用例如：

public void dosome(final String a,final int b){

class Dosome{public void dosome(){System.out.println(a+b)}};

Dosome some=new Dosome();

some.dosome();

}

从代码来看好像是那个内部类直接调用的a参数和b参数，但是实际上不是，在java编译器编译以后实际的操作代码是

class Outer$Dosome{

public Dosome(final String a,final int b){

this.Dosome$a=a;

this.Dosome$b=b;

}

public void dosome(){

System.out.println(this.Dosome$a+this.Dosome$b);

}

}}

从以上代码看来，内部类并不是直接调用方法传进来的参数，而是内部类将传进来的参数通过自己的构造器备份到了自己的内部，自己内部的方法调用的实际是自己的属性而不是外部类方法的参数。

这样理解就很容易得出为什么要用final了，因为两者从外表看起来是同一个东西，实际上却不是这样，如果内部类改掉了这些参数的值也不可能影响到原参数，然而这样却失去了参数的一致性，因为从编程人员的角度来看他们是同一个东西，如果编程人员在程序设计的时候在内部类中改掉参数的值，但是外部调用的时候又发现值其实没有被改掉，这就让人非常的难以理解和接受，为了避免这种尴尬的问题存在，所以编译器设计人员把内部类能够使用的参数设定为必须是final来规避这种莫名其妙错误的存在。”

(简单理解就是，拷贝引用，为了避免引用值发生改变，例如被外部类的方法修改等，而导致内部类得到的值不一致，于是用final来让该引用不可改变)

因为匿名内部类，没名字，是用默认的构造函数的，无参数的，那如果需要参数呢？则需要该类有带参数的构造函数：

 
 


  
  
  
  
 
  
 
  
   public class Outer {  
  
  
  
  
 
  
 
  
       public static void main(String[] args) {  
  
  
  
  
 
  
 
  
           Outer outer = new Outer();  
  
  
  
  
 
  
 
  
           Inner inner = outer.getInner("Inner", "gz");  
  
  
  
  
 
  
 
  
           System.out.println(inner.getName());  
  
  
  
  
 
  
 
  
       }  
  
  
  
  
 
  
 
  
     
  
  
  
  
 
  
 
  
       public Inner getInner(final String name, String city) {  
  
  
  
  
 
  
 
  
           return new Inner(name, city) {  
  
  
  
  
 
  
 
  
               private String nameStr = name;  
  
  
  
  
 
  
 
  
     
  
  
  
  
 
  
 
  
               public String getName() {  
  
  
  
  
 
  
 
  
                   return nameStr;  
  
  
  
  
 
  
 
  
               }  
  
  
  
  
 
  
 
  
           };  
  
  
  
  
 
  
 
  
       }  
  
  
  
  
 
  
 
  
   }  
  
  
  
  
 
  
 
  
     
  
  
  
  
 
  
 
  
   abstract class Inner {  
  
  
  
  
 
  
 
  
       Inner(String name, String city) {  
  
  
  
  
 
  
 
  
           System.out.println(city);  
  
  
  
  
 
  
 
  
       }  
  
  
  
  
 
  
 
  
     
  
  
  
  
 
  
 
  
       abstract String getName();  
  
  
  
  
 
  
 
  
   }

注意这里的形参city，由于它没有被匿名内部类直接使用，而是被抽象类Inner的构造函数所使用，所以不必定义为final。

而匿名内部类通过实例初始化，可以达到类似构造器的效果：

 
 


  
  
  
  
 
  
 
  
   public class Outer {  
  
  
  
  
 
  
 
  
       public static void main(String[] args) {  
  
  
  
  
 
  
 
  
           Outer outer = new Outer();  
  
  
  
  
 
  
 
  
           Inner inner = outer.getInner("Inner", "gz");  
  
  
  
  
 
  
 
  
           System.out.println(inner.getName());  
  
  
  
  
 
  
 
  
           System.out.println(inner.getProvince());  
  
  
  
  
 
  
 
  
       }  
  
  
  
  
 
  
 
  
     
  
  
  
  
 
  
 
  
       public Inner getInner(final String name, final String city) {  
  
  
  
  
 
  
 
  
           return new Inner() {  
  
  
  
  
 
  
 
  
               private String nameStr = name;  
  
  
  
  
 
  
 
  
               private String province;  
  
  
  
  
 
  
 
  
     
  
  
  
  
 
  
 
  
               // 实例初始化  
  
  
  
  
 
  
 
  
               {  
  
  
  
  
 
  
 
  
                   if (city.equals("gz")) {  
  
  
  
  
 
  
 
  
                       province = "gd";  
  
  
  
  
 
  
 
  
                   }else {  
  
  
  
  
 
  
 
  
                       province = "";  
  
  
  
  
 
  
 
  
                   }  
  
  
  
  
 
  
 
  
               }  
  
  
  
  
 
  
 
  
     
  
  
  
  
 
  
 
  
               public String getName() {  
  
  
  
  
 
  
 
  
                   return nameStr;  
  
  
  
  
 
  
 
  
               }  
  
  
  
  
 
  
 
  
     
  
  
  
  
 
  
 
  
               public String getProvince() {  
  
  
  
  
 
  
 
  
                   return province;  
  
  
  
  
 
  
 
  
               }  
  
  
  
  
 
  
 
  
           };  
  
  
  
  
 
  
 
  
       }  
  
  
  
  
 
  
 
  
   }  
  
  
  
  
 
  
 
  
     
  
  
  
  
 
  
 
  
   interface Inner {  
  
  
  
  
 
  
 
  
       String getName();  
  
  
  
  
 
  
 
  
       String getProvince();  
  
  
  
  
 
  
 
  
   }

5.内部类的继承

内部类的继承，是指内部类被继承，普通类 extents 内部类。而这时候代码上要有点特别处理，具体看以下例子：

 
 


  
  
  
  
 
  
 
  
   public class InheritInner extends WithInner.Inner {  
  
  
  
  
 
  
 
  
     
  
  
  
  
 
  
 
  
       // InheritInner() 是不能通过编译的，一定要加上形参  
  
  
  
  
 
  
 
  
       InheritInner(WithInner wi) {  
  
  
  
  
 
  
 
  
           wi.super();  
  
  
  
  
 
  
 
  
       }  
  
  
  
  
 
  
 
  
     
  
  
  
  
 
  
 
  
       public static void main(String[] args) {  
  
  
  
  
 
  
 
  
           WithInner wi = new WithInner();  
  
  
  
  
 
  
 
  
           InheritInner obj = new InheritInner(wi);  
  
  
  
  
 
  
 
  
       }  
  
  
  
  
 
  
 
  
   }  
  
  
  
  
 
  
 
  
     
  
  
  
  
 
  
 
  
   class WithInner {  
  
  
  
  
 
  
 
  
       class Inner {  
  
  
  
  
 
  
 
  
     
  
  
  
  
 
  
 
  
       }  
  
  
  
  
 
  
 
  
   }

可以看到子类的构造函数里面要使用 父类的外部类对象.super();而这个对象需要从外面创建并传给形参。

至于内部类的重载，感觉Thinking in Java的例子很复杂，在平常应用中应该很少，因为有点难懂，不清晰。而内部类和闭包之间的事情，暂时放下，以后再看。

内部类有两种情况：

(1) 在类中定义一个类(私有内部类，静态内部类)

(2) 在方法中定义一个类(局部内部类，匿名内部类)

1、私有内部类 —— 在方法之间定义的内部类，非静态

我们首先看看类中内部类的两个特点：

(1) 在外部类的作用范围内可以任意创建内部类对象，即使内部类是私有的(私有内部类)。即内部类对包围它的外部类可见。

例如 (实际上，内部类是可以设置为public公开的，但一般我是当做成员变量设置为private)

  
  


   
   
   
   
 
   
 
   
    //代码1：内部类对外部类可见  
   
   
   
   
 
   
 
   
    class Outer{  
   
   
   
   
 
   
 
   
        //创建私有内部类对象  
   
   
   
   
 
   
 
   
        public Inner in=new Inner();  
   
   
   
   
 
   
 
   
      
   
   
   
   
 
   
 
   
        //私有内部类  
   
   
   
   
 
   
 
   
        private class Inner{  
   
   
   
   
 
   
 
   
             ...  
   
   
   
   
 
   
 
   
        }  
   
   
   
   
 
   
 
   
    }

(2) 在内部类中可以访问其外部类的所有域，即使是私有域。即外部类对内部类可见。

例如

  
  


   
   
   
   
 
   
 
   
    //代码2：外部类对内部类可见  
   
   
   
   
 
   
 
   
    //(内部类可以访问外部类的所有成员变量和方法)  
   
   
   
   
 
   
 
   
    class Outer{  
   
   
   
   
 
   
 
   
        //外部类私有数据域  
   
   
   
   
 
   
 
   
        private int data=http://www.mamicode.com/0;  
   
   
   
   
 
   
 
   
      
   
   
   
   
 
   
 
   
        //内部类  
   
   
   
   
 
   
 
   
        class Inner{  
   
   
   
   
 
   
 
   
            void print(){  
   
   
   
   
 
   
 
   
                //内部类访问外部私有数据域  
   
   
   
   
 
   
 
   
                System.out.println(data);  
   
   
   
   
 
   
 
   
            }  
   
   
   
   
 
   
 
   
        }  
   
   
   
   
 
   
 
   
    }

问题来了：上面两个特点到底如何办到的呢？内部类的"内部"到底发生了什么？

其实，内部类是Java编译器一手操办的。虚拟机并不知道内部类与常规类有什么不同。编译器是如何瞒住虚拟机的呢？

对内部类进行编译后发现有两个class文件：Outer.class 和Outer$Inner.class 。这说明内部类Inner仍然被编译成一个独立的类(Outer$Inner.class)，而不是Outer类的某一个域。虚拟机运行的时候，也是把Inner作为一种常规类来处理的。

但问题来了，即然是两个常规类，为什么他们之间可以互相访问私有域那(最开始提到的两个内部类特点)？这就要问问编译器到底把这两个类编译成什么东西了。

我们利用reflect反射机制来探查了一下内部类编译后的情况（关于探查类内部机制的代码提供在下面的附件里Reflect.java）。

(1)、编译代码1生成 Outer$Inner.class 文件后使用 ReflectUtil.reflect("Outer$Inner") 对内部类Inner进行反射。运行结果发现了三个隐含的成分：

   
   


    
    
    
    
 
    
 
    
     //反编译代码 
    
    
    
    
 
    
 
    
     class Outer$Inner 
    
    
    
    
 
    
 
    
     { 
    
    
    
    
 
    
 
    
         Outer$Inner(Outer,Outer$Inner);  //包可见构造器 
    
    
    
    
 
    
 
    
         private Outer$Inner(Outer);   //私有构造器将设置this$0域 
    
    
    
    
 
    
 
    
         final Outer this$0;   //外部类实例域this$0 
    
    
    
    
 
    
 
    
     }

好了，现在我们可以解释上面的第一个内部类特点了： 为什么外部类可以创建内部类的对象？并且内部类能够方便的引用到外部类对象?

首先编译器将外、内部类编译后放在同一个包中。在内部类中附加一个包可见构造器。这样，虚拟机运行Outer类中Inner in=new Inner(); 实际上调用的是包可见构造： new Outer$Inner(this,null)。因此即使是private内部类，也会通过隐含的包可见构造器成功的获得私有内部类的构造权限。

再者，Outer$Inner类中有一个指向外部类Outer的引用this$0，那么通过这个引用就可以方便的得到外部类对象中可见成员。但是Outer类中的private成员是如何访问到的呢？这就要看看下面Outer.class文件中的秘密了。

(2)、编译代码2生成 Outer.class文件，然后使用 ReflectUtil.reflect("Outer") 对外部类Outer进行反射。运行结果发现一个隐含成分如下：

  
  


   
   
   
   
 
   
 
   
    //反编译代码  
   
   
   
   
 
   
 
   
    class Outer  
   
   
   
   
 
   
 
   
    {  
   
   
   
   
 
   
 
   
        static int access$0(Outer);  //静态方法，返回值是外部类私有域 data 的值  
   
   
   
   
 
   
 
   
    }

现在可以解释第二个特点了： 为什么内部类可以引用外部类的私有域？

原因的关键就在编译器在外围类中添加了静态方法access$0。它将返回值作为参数传递给他的对象域data。这样内部类Inner中的打印语句：

System.out.println(data);

实际上运行的时候调用的是：

System.out.println(this$0.access$0(Outer));

总结一下编译器对类中内部类做的手脚吧：

(1) 在内部类中偷偷摸摸的创建了包可见构造器，从而使外部类获得了创建权限。

(2) 在外部类中偷偷摸摸的创建了访问私有变量的静态方法，从而使内部类获得了访问权限。

这样，类中定义的内部类无论私有，公有，静态都可以被包围它的外部类所访问。

2、静态内部类 —— 在方法间定义的内部类，静态

内部类也有静态的区别，这就是静态内部类，我们来看看代码：

   
   


    
    
    
    
 
    
 
    
     package hr.test;  
    
    
    
    
 
    
 
    
     //代码3：静态内部类对外部变量的引用  
    
    
    
    
 
    
 
    
     public class Outer{  
    
    
    
    
 
    
 
    
         private static int i=0;  
    
    
    
    
 
    
 
    
       
    
    
    
    
 
    
 
    
         //创建静态内部类对象  
    
    
    
    
 
    
 
    
         public Inner in=new Inner();  
    
    
    
    
 
    
 
    
       
    
    
    
    
 
    
 
    
         //静态内部类  
    
    
    
    
 
    
 
    
         private static class Inner{  
    
    
    
    
 
    
 
    
             public void print(){  
    
    
    
    
 
    
 
    
                 System.out.println(i);   //如果i不是静态变量，这里将无法通过编译  
    
    
    
    
 
    
 
    
             }  
    
    
    
    
 
    
 
    
         }   
    
    
    
    
 
    
 
    
     }

静态内部类和私有内部类最大的区别在于，静态内部类中无法引用到其外围类的非静态成员。这是为什么？我们还是来看看静态内部类Outer$Inner中发生了什么吧？

  
  


   
   
   
   
 
   
 
   
    //反编译代码  
   
   
   
   
 
   
 
   
    class Outer$Inner  
   
   
   
   
 
   
 
   
    {  
   
   
   
   
 
   
 
   
        private Outer$Inner();  
   
   
   
   
 
   
 
   
        Outer$Inner(hr.test.Outer$Inner);  
   
   
   
   
 
   
 
   
    }

与上面私有内部类反编译1比较发现，少了一个指向外围类对象的引用final Outer this$0; 也就是说静态内部类无法得到其外围类对象的引用，那么自然也就无法访问外围类的非静态成员了。 因此，静态内部类只能访问其外围类的静态成员，除此之外与非静态内部类没有任何区别。

3、局部内部类 —— 在方法中定义的内部类

方法内部类也有两个特点

(1) 方法中的内部类没有访问修饰符，即方法内部类对包围它的方法之外的任何东西都不可见。

(2) 方法内部类只能够访问该方法中的局部变量，所以也叫局部内部类。而且这些局部变量一定要是final修饰的常量。

例如

  
  


   
   
   
   
 
   
 
   
    class Outter{  
   
   
   
   
 
   
 
   
        public void outMethod(){  
   
   
   
   
 
   
 
   
            final int beep=0;  
   
   
   
   
 
   
 
   
            class Inner{  
   
   
   
   
 
   
 
   
                //使用beep  
   
   
   
   
 
   
 
   
            }  
   
   
   
   
 
   
 
   
      
   
   
   
   
 
   
 
   
            Inner in=new Inner();  
   
   
   
   
 
   
 
   
        }  
   
   
   
   
 
   
 
   
    }

这又是为什么呢？

(1) 我们首先对Outter类进行反射发现，Outter中再也没有返回私有域的隐藏方法了。

(2) 对Inner类的反射发现，Inner类内部多了一个对beep变量的备份隐藏域：final int val$i;

我们可以这样解释Inner类中的这个备份常量域，首先当JVM运行到需要创建Inner对象之后，Outter类已经全部运行完毕，这是垃圾回收机制很有可能释放掉局部变量beep。那么Inner类到哪去找beep变量呢？

编译器又出来帮我们解决了这个问题，他在Inner类中创建了一个beep的备份 ，也就是说即使Ouuter中的beep被回收了，Inner中还有一个备份存在，自然就不怕找不到了。

但是问题又来了。如果Outter中的beep不停的在变化那。那岂不是也要让备份的beep变量无时无刻的变化。 为了保持局部变量与局部内部类中备份域保持一致。编译器不得不规定死这些局部域必须是常量，一旦赋值不能再发生变化了。

所以为什么局部内部类应用外部方法的域必须是常量域的原因所在了。

内部类的特点总结

(1) 在方法间定义的非静态内部类：

● 外围类和内部类可互相访问自己的私有成员。

● 内部类中不能定义静态成员变量。

(2) 在方法间定义的静态内部类：

● 只能访问外部类的静态成员。

(3) 在方法中定义的局部内部类：

● 该内部类没有任何的访问控制权限

● 外围类看不见方法中的局部内部类的，但是局部内部类可以访问外围类的任何成员。

● 方法体中可以访问局部内部类，但是访问语句必须在定义局部内部类之后。

● 局部内部类只能访问方法体中的常量，即用final修饰的成员。

(4) 在方法中定义的匿名内部类：

● 没有构造器，取而代之的是将构造器参数传递给超类构造器。

提起Java内部类（Inner Class）可能很多人不太熟悉，实际上类似的概念在C++里也有，那就是嵌套类（Nested Class），关于这两者的区别与联系，在下文中会有对比。内部类从表面上看，就是在类中又定义了一个类（下文会看到，内部类可以在很多地方定义），而实际上并没有那么简单，乍看上去内部类似乎有些多余，它的用处对于初学者来说可能并不是那么显著，但是随着对它的深入了解，你会发现Java的设计者在内部类身上的确是用心良苦。学会使用内部类，是掌握Java高级编程的一部分，它可以让你更优雅地设计你的程序结构。下面从以下几个方面来介绍：

第一次见面

[java] view plain copy print ?

public interface Contents {
int value();
}
public interface Destination {
String readLabel();
}
public class Goods {
private class Content implements Contents {
private int i = 11;
public int value() {
return i;
}
}
protected class GDestination implements Destination {
private String label;
private GDestination(String whereTo) {
label = whereTo;
}
public String readLabel() {
return label;
}
}
public Destination dest(String s) {
return new GDestination(s);
}
public Contents cont() {
return new Content();
}
}
class TestGoods {
public static void main(String[] args) {
Goods p = new Goods();
Contents c = p.cont();
Destination d = p.dest("Beijing");
}
}

public interface Contents { int value(); } public interface Destination { String readLabel(); } public class Goods { private class Content implements Contents { private int i = 11; public int value() { return i; } } protected class GDestination implements Destination { private String label; private GDestination(String whereTo) { label = whereTo; } public String readLabel() { return label; } } public Destination dest(String s) { return new GDestination(s); } public Contents cont() { return new Content(); } } class TestGoods { public static void main(String[] args) { Goods p = new Goods(); Contents c = p.cont(); Destination d = p.dest("Beijing"); } }

在这个例子里类Content和GDestination被定义在了类Goods内部，并且分别有着protected和private修饰符来控制访问级别。Content代表着Goods的内容，而GDestination代表着Goods的目的地。它们分别实现了两个接口Content和Destination。在后面的main方法里，直接用 Contents c和Destination d进行操作，你甚至连这两个内部类的名字都没有看见！这样，内部类的第一个好处就体现出来了隐藏你不想让别人知道的操作，也即封装性。

同时，我们也发现了在外部类作用范围之外得到内部类对象的第一个方法，那就是利用其外部类的方法创建并返回。上例中的cont()和dest()方法就是这么做的。那么还有没有别的方法呢？当然有，其语法格式如下：

outerObject=new outerClass(Constructor Parameters);

outerClass.innerClass innerObject=outerObject.new InnerClass(Constructor Parameters);

注意在创建非静态内部类对象时，一定要先创建起相应的外部类对象。至于原因，也就引出了我们下一个话题非静态内部类对象有着指向其外部类对象的引用，对刚才的例子稍作修改：

[java] view plain copy print ?

public class Goods {
private int valueRate = 2;
private class Content implements Contents {
private int i = 11 * valueRate;
public int value() {
return i;
}
}
protected class GDestination implements Destination {
private String label;
private GDestination(String whereTo) {
label = whereTo;
}
public String readLabel() {
return label;
}
}
public Destination dest(String s) {
return new GDestination(s);
}
public Contents cont() {
return new Content();
}
}

public class Goods { private int valueRate = 2; private class Content implements Contents { private int i = 11 * valueRate; public int value() { return i; } } protected class GDestination implements Destination { private String label; private GDestination(String whereTo) { label = whereTo; } public String readLabel() { return label; } } public Destination dest(String s) { return new GDestination(s); } public Contents cont() { return new Content(); } }

在这里我们给Goods类增加了一个private成员变量valueRate，意义是货物的价值系数，在内部类Content的方法value()计算价值时把它乘上。我们发现，value()可以访问valueRate，这也是内部类的第二个好处一个内部类对象可以访问创建它的外部类对象的内容，甚至包括私有变量！这是一个非常有用的特性，为我们在设计时提供了更多的思路和捷径。要想实现这个功能，内部类对象就必须有指向外部类对象的引用。Java编译器在创建内部类对象时，隐式的把其外部类对象的引用也传了进去并一直保存着。这样就使得内部类对象始终可以访问其外部类对象，同时这也是为什么在外部类作用范围之外向要创建内部类对象必须先创建其外部类对象的原因。

有人会问，如果内部类里的一个成员变量与外部类的一个成员变量同名，也即外部类的同名成员变量被屏蔽了，怎么办？没事，Java里用如下格式表达外部类的引用：

outerClass.this

有了它，我们就不怕这种屏蔽的情况了。

静态内部类

和普通的类一样，内部类也可以有静态的。不过和非静态内部类相比，区别就在于静态内部类没有了指向外部的引用。这实际上和C++中的嵌套类很相像了，Java内部类与C++嵌套类最大的不同就在于是否有指向外部的引用这一点上，当然从设计的角度以及以它一些细节来讲还有区别。

除此之外，在任何非静态内部类中，都不能有静态数据，静态方法或者又一个静态内部类（内部类的嵌套可以不止一层）。不过静态内部类中却可以拥有这一切。这也算是两者的第二个区别吧。

局部内部类

是的，Java内部类也可以是局部的，它可以定义在一个方法甚至一个代码块之内。

[java] view plain copy print ?

public class Goods1 {
public Destination dest(String s) {
class GDestination implements Destination {
private String label;
private GDestination(String whereTo) {
label = whereTo;
}
public String readLabel() {
return label;
}
}
return new GDestination(s);
}
public static void main(String[] args) {
Goods1 g = new Goods1();
Destination d = g.dest("Beijing");
}
}

public class Goods1 { public Destination dest(String s) { class GDestination implements Destination { private String label; private GDestination(String whereTo) { label = whereTo; } public String readLabel() { return label; } } return new GDestination(s); } public static void main(String[] args) { Goods1 g = new Goods1(); Destination d = g.dest("Beijing"); } }

上面就是这样一个例子。在方法dest中我们定义了一个内部类，最后由这个方法返回这个内部类的对象。如果我们在用一个内部类的时候仅需要创建它的一个对象并创给外部，就可以这样做。当然，定义在方法中的内部类可以使设计多样化，用途绝不仅仅在这一点。

下面有一个更怪的例子：

[java] view plain copy print ?

public class Goods2 {
private void internalTracking(boolean b) {
if (b) {
class TrackingSlip {
private String id;
TrackingSlip(String s) {
id = s;
}
String getSlip() {
return id;
}
}
TrackingSlip ts = new TrackingSlip("slip");
String s = ts.getSlip();
}
}
public void track() {
internalTracking(true);
}
public static void main(String[] args) {
Goods2 g = new Goods2();
g.track();
}
}

public class Goods2 { private void internalTracking(boolean b) { if (b) { class TrackingSlip { private String id; TrackingSlip(String s) { id = s; } String getSlip() { return id; } } TrackingSlip ts = new TrackingSlip("slip"); String s = ts.getSlip(); } } public void track() { internalTracking(true); } public static void main(String[] args) { Goods2 g = new Goods2(); g.track(); } }

你不能在if之外创建这个内部类的对象，因为这已经超出了它的作用域。不过在编译的时候，内部类TrackingSlip和其他类一样同时被编译，只不过它由它自己的作用域，超出了这个范围就无效，除此之外它和其他内部类并没有区别。

匿名内部类

java的匿名内部类的语法规则看上去有些古怪，不过如同匿名数组一样，当你只需要创建一个类的对象而且用不上它的名字时，使用内部类可以使代码看上去简洁清楚。它的语法规则是这样的：

new interfacename(){......}; 或 new superclassname(){......};

下面接着前面继续举例子：

[java] view plain copy print ?

public class Goods3 {
public Contents cont() {
return new Contents() {
private int i = 11;
public int value() {
return i;
}
};
}
}

public class Goods3 { public Contents cont() { return new Contents() { private int i = 11; public int value() { return i; } }; } }

这里方法cont()使用匿名内部类直接返回了一个实现了接口Contents的类的对象，看上去的确十分简洁。

在java的事件处理的匿名适配器中，匿名内部类被大量的使用。例如在想关闭窗口时加上这样一句代码：

[java] view plain copy print ?

frame.addWindowListener(new WindowAdapter(){
public void windowClosing(WindowEvent e){
System.exit(0);
}
});

frame.addWindowListener(new WindowAdapter(){ public void windowClosing(WindowEvent e){ System.exit(0); } });

有一点需要注意的是，匿名内部类由于没有名字，所以它没有构造函数（但是如果这个匿名内部类继承了一个只含有带参数构造函数的父类，创建它的时候必须带上这些参数，并在实现的过程中使用super关键字调用相应的内容）。如果你想要初始化它的成员变量，有下面几种方法：

如果是在一个方法的匿名内部类，可以利用这个方法传进你想要的参数，不过记住，这些参数必须被声明为final。

将匿名内部类改造成有名字的局部内部类，这样它就可以拥有构造函数了。

在这个匿名内部类中使用初始化代码块。

为什么需要内部类？

java内部类有什么好处？为什么需要内部类？

首先举一个简单的例子，如果你想实现一个接口，但是这个接口中的一个方法和你构想的这个类中的一个方法的名称，参数相同，你应该怎么办？这时候，你可以建一个内部类实现这个接口。由于内部类对外部类的所有内容都是可访问的，所以这样做可以完成所有你直接实现这个接口的功能。

不过你可能要质疑，更改一下方法的不就行了吗？

的确，以此作为设计内部类的理由，实在没有说服力。

真正的原因是这样的，java中的内部类和接口加在一起，可以的解决常被C++程序员抱怨java中存在的一个问题没有多继承。实际上，C++的多继承设计起来很复杂，而java通过内部类加上接口，可以很好的实现多继承的效果。

内部类

声明：以上内容来自用户投稿及互联网公开渠道收集整理发布，本网站不拥有所有权，未作人工编辑处理，也不承担相关法律责任，若内容有误或涉及侵权可进行投诉：投诉/举报工作人员会在5个工作日内联系你，一经查实，本站将立刻删除涉嫌侵权内容。

联系
我们

首页 > 代码库 > 内部类

内部类

1. 成员内部类

2. 局部内部类

3. 嵌套内部类

4. 匿名内部类

5.内部类的继承

看完仍有疑问？有类似问题直接问程序猿