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

Java中的内部类又分为非静态内部类(匿名内部类也是非静态的内部类)和静态内部类,两者与外部类的关系是不一样的,创建的方式也不一样。

1 非静态内部类
Java的非静态内部类在构造的时候,会将外部类的引用传递进来,并且作为内部类的一个属性,因此,内部类会隐式地持有其外部类的引用。也就是非静态内部类在构造的时候需要有一个外部类的实例传递进来进行构造,不能像普通的Java类那样直接就可以通过 new来生成;一个简单的例子如下:

1 import java.util.ArrayList;
 2 import java.util.LinkedList;
 3 import java.util.List;
 4 import java.util.Queue;
 5 import java.util.Scanner;
 6 
 7 public class Main {
 8 
 9     /**
10      * @param args
11      */
12     public  int k=3;
13     private static String string="Java";
14     protected float j=1.5f;
15     public static void show(){
16         System.out.println("show");
17     }
18     private void add(){
19         System.out.println("add");
20     }
21     public static void main(String[] args) {
22         // TODO Auto-generated method stub
23         Main m=new Main();
24         //合法的非静态内部类的构造方式
25         Child c=m.new Child();
26         //Child c=new Child() 这是不合法的构造方式
27         c.test();
28  
29     }
30 //内部类Child
31   class Child{
32      public int i;
33      public void test(){
34          System.out.println("k=:"+k);
35          System.out.println("string:"+string);
36          add();
37          System.out.println("j=:"+j);
38          show();
39      }
40      
41  }
42 
43 }

并且非静态的内部类可以访问外部类的所有成员变量与方法,包括静态的成员变量与方法,执行内部类Child的test()方法就可以得到下面的结果:

1 k=:3
2 string:Java
3 add
4 j=:1.5
5 show

2 静态内部类
Java中的静态内部类在构造的时候并不需要外部类的引用,因此静态的内部类不会持有外部类的引用,并且静态内部类只能访问外部类的静态成员变量和方法。一个简单的例子为(上面的代码做一些简单的改动):

public class Main {
 2 
 3     /**
 4      * @param args
 5      */
 6     public  int k=3;
 7     private static String string="Java";
 8     protected float j=1.5f;
 9     public static void show(){
10         System.out.println("show");
11     }
12     private void add(){
13         System.out.println("add");
14     }
15     public static void main(String[] args) {
16         // TODO Auto-generated method stub
17         Main m=new Main();
18         //Child c=m.new Childe();//非法
19         Child c=new Child();
20         c.test();
21  
22     }
23   static class Child{
24      public int i;
25     
26      public void test(){
27 //         System.out.println("k=:"+k);//不能访问外部类非静态变量
28          System.out.println("string:"+string);
29          //add(); //不能访问外部类的非静态方法
30 //         System.out.println("j=:"+j);
31          show();
32      }
33      
34  }
35 
36 }

从上面的代码可以看到,静态内部类的创建方式与普通的Java类的创建方式一样,执行第21行代码就可以得到如下结果:

1 string:Java
2 show

3 杂谈
Java的非静态内部类的这种创建方式,会隐式地持有外部类的引用,而且默认情况下这个引用是强引用,因此,如果内部类的生命周期长于外部类的生命周期,程序很容易就产生内存泄漏(你认为垃圾回收器会回收掉外部类的实例,但由于内部类持有外部类的引用,导致垃圾回收器不能正常工作)。为了避免这种情况的发生,你可以在内部类的内部显示持有一个外部类的软引用(或弱引用),并通过构造方法的方式传递进来,在内部类的使用过程中,先判断一下外部类是否被回收;

推荐阅读更多精彩内容

  • 不少新手站长都是学完SEO基础知识就开始自己动手建站,把理论用于实践,往往热情度非常高。但是这也是有非常大风险的事...
    AC美剧天堂阅读 82评论 0 0
  • 第二节课下课的课间操结束后,是我们班的武术课,今天的武术课没有学新的内容,就是巩固之前学的。 在上...
    王昱凯阅读 97评论 0 0
  • 上辈子你们是碳酸饮料吧?不然为什么我看到你们就开心得冒泡呢苗苗的:贵州的意思 蠢蠢的,土土的美育是一种刚需(人民日...
    dq920813阅读 29评论 0 0
  • 近日,某某领导初学易经,沉迷风水,每每闲暇之时,便借会议之名,为下属逐一算卦。每每到欣然之处,便高谈论阔,从太极阴...
    顺手给我new一个对象阅读 1,127评论 1 0