电脑系统城官网 - 一键重装系统-Win7旗舰版/win10 64位系统下载,唯一官网:www.pcxitongcheng.com!

当前位置:首页 > 网络编程 > JavaScript > 详细页面

Java内部类的实现原理与可能的内存泄漏说明

时间:2020-10-08来源:www.pcxitongcheng.com作者:电脑系统城

在使用java内部类的时候要注意可能引起的内存泄漏

代码如下

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
package com.example;
public class MyClass {
 
 public static void main(String[] args) throws Throwable {
 
 }
 
 public class A{
  public void methed1(){
 
  }
 }
 
 public static class B{
  public void methed1(){
 
  }
 }

编译生成了如下文件

反编译MyClass

反编译MyClassA

反编译GlassB

从反编译的结果可以知道,内部类的实现其实是通过编译器的语法糖实现的,通过生成相应的子类即以OutClassName$InteriorClassName命名的Class文件。

并添加构造函数,在构造函数中传入外部类,这也是为什么内部类能使用外部类的方法与字段的原因。

我们明白了这个也就要小心,当外部类与内部类生命周期不一致的时候很有可能发生内存泄漏,例如在一个Activity启动一个Thread执行一个任务,因为Thread是内部类持有了Activity的引用,当Activity销毁的时候如果Thread的任务没有执行完成,造成Activity的引用不能释放,Activity不能被释放而引起了内存泄漏。

这种情况下可以通过声明一个static的内部类来解决问题,从反编译中可以看出,声明为static的类不会持有外部类的引用,如果你想使用外部类的话,可以通过软引用的方式保存外部类的引用。

具体的代码就不上了。

补充知识:Java内部类的底层实现原理

摘要:

定义:在一个类中创建另一个类,叫做成员内部类,这个内部类可以是静态的,也可以是非静态的。

已知静态内部类的应用(可以解决的问题):

通过内部类解决java 的单继承问题,外部类不能同时继承的类可以交给内部类继承

设计模式中,builder 模式通过定义一个静态内部类实现

类型汇总:

静态内部类

成员内部类

方法内部类

匿名内部类

一、静态内部类

静态内部类的定义和普通的静态变量或者静态方法的定义方法是一样的,使用static关键字,只不过这次static是修饰在class上的,一般而言,只有静态内部类才允许使用static关键字修饰,普通类的定义是不能用static关键字修饰的,这一点需要注意一下。下面定义一个静态内部类:

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
public class Out {
 private static String name;
 private int age;
  
 public static class In{
  private int age;
  public void sayHello(){
    
   System.out.println("my name is : "+name);
   //--编译报错---
   //System.out.println("my age is :"+ age);
  }
 }
}

在上述代码中,In这个类就是一个静态内部类。我们说内部类是可以访问外部类的私有字段和私有方法的,对于静态内部类,它遵循一致的原则,只能访问外部类的静态成员。上述代码中,外部类的非静态私有字段age在静态内部类中使不允许访问的,而静态字段name则是可访问的。下面我们看,如何创建一个静态内部类的实例对象。

?
1
2
3
4
public static void main(String [] args){
 Out.In innerClass = new Out.In();
 innerClass.sayHello();
}

静态内部类的实例对象创建还是比较简洁的,不同于成员内部类,它不需要关联外部类实例(具体的下文介绍),下面我们再看一段代码:

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
public class Out {
 private static String name;
  
 public static class In{
  public void sayHello(){
   System.out.println(name);
   showName();
  }
 }
  
 private static void showName(){
  System.out.println(name);
 }
}

上述代码在内部类中两次访问了外部类的静态成员,第一次访问了静态字段name,第二次访问的静态方法showName。在我们反编译这个类之前,首先需要知道的是,所谓的内部类的概念只是出现在编译阶段,对于jvm层是没有内部类这个概念的。也就是说,编译器会将一个类编译成一个源文件,对于内部类也是一样,它会从它的外部类中抽离出来,增加一些与外部类的联系,然后被编译成一个单独的源文件。下面我们先编译运行之后,利用Dj反编译class文件看看编译器都做了些什么事情。

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
//这是我们的Out外部类
public class Out
{
 //省去了一些不重要的部分
 private static void showName()
 {
  System.out.println(name);
 }
  
 private static String name;
  
 static String access$000(){return name;}
 static void access$100(){showName();}
  
}
//这是我们的内部类
public static class Out$In
{
  
 public void sayHello()
 {
  System.out.println(Out.access$000());
  Out.access$100();
 }
  
 public Out$In()
 {
 }
}

相信大家也已经看出来这两者之间的某种联系,编译器将Out这个类编译成两个独立的class源文件。对于Out中所有的私有成员(也就是内部类分离出去之后不能访问的成员),增设了可供调用的access$xxx方法,从而实现内部类与外部类之间的联系。这就是他们的本质。

至于使用场景,一般来说,对于和外部类联系紧密但是并不依赖于外部类实例的情况下,可以考虑定义成静态内部类。下面我们看稍显复杂的成员内部类。

二、成员内部类

我们说了,四种不同类型的内部类都各自有各自的使用场景,静态内部类适合于那种和外部类关系密切但是并不依赖外部类实例的情况。但是对于需要和外部类实例相关联的情况下,可以选择将内部类定义成成员内部类。以下代码定义了一个简单的成员内部类:

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
public class Out {
 private String name;
  
 public void showName(){
  System.out.println("my name is : "+name);
 }
  
 public class In{
  public void sayHello(){
   System.out.println(name);
   Out.this.showName();
  }
 }
}

以上定义了一个简单的内部类In,我们的成员内部类可以直接访问外部类的成员字段和成员方法,因为它是关联着一个外部类实例的。下面我们看看在外部是如何创建该内部类实例的。

?
1
2
3
4
5
public static void main(String [] args){
 Out out = new Out();
 Out.In in = out.new In();
 in.sayHello();
}

因为成员内部类是关联着一个具体的外部类实例的,所以它的实例创建必然是由外部类实例来创建的。对于实例的创建,我们只需要记住即可,成员内部类的实例创建需要关联外部类实例对象,静态内部类实例创建相对简单。下面我们主要看看在编译阶段编译器是如何保持内部类对外部类成员信息可访问的。

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
//反编译的Out外部类源码
public class Out
{
 //省略部分非核心代码
 public void showName()
 {
  System.out.println((new StringBuilder()).append("my name is : ").append(name).toString());
 }
  
 private String name;
  
 static String access$000(Out o){return o.name;}
}
//反编译的内部类In源码
public class Out$In
{
 public void sayHello()
 {
  System.out.println(Out.access$000(Out.this));
  showName();
 }
  
 final Out this$0;
  
 public Out$In()
 {
  this.this$0 = Out.this;
  super();
 }
}

由上述代码其实我们可以知道,当我们利用外部类实例创建内部类实例的时候,会将外部类实例作为初始资源传入内部类构造过程。这样我们就可以通过该实例访问外部类所有的成员信息,包括私有成员。(显式增加了暴露方法)

至于使用场景,对于那种要高度依赖外部类实例的情况下,定义一个成员内部类则会显的更加明智。

三、方法内部类

方法内部类,顾名思义,定义在一个方法内部的类。方法内部类相对而言要复杂一些,下面定义一个方法内部类:

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
public class Out {
 private String name;
  
 public void sayHello(){
  class In{
   public void showName(){
    System.out.println("my name is : "+name);
   }
  }
  
  In in = new In();
  in.showName();
 }
}

我们定义了一个类,在该类中又定义了一个方法sayHello,然而在该方法中我们定义了一个内部类,类In就是一个方法内部类。我们的方法内部类的生命周期不超过包含它的方法的生命周期,也就是说,方法内部类只能在方法中使用。所以在声明的时候,任何的访问修饰符都是没有意义的,于是Java干脆不允许使用任何的访问修饰符修饰方法内部类。其中还需要注意一点的是,定义和使用时两回事,别看那一大串定义类的代码,你实际想要使用该类,就必须new对象,而对于方法内部类而言,只能在方法内部new对象。这就是方法内部类的简单介绍,下面我们看看其实现原理。

有关方法内部类的实现原理其实是和成员内部类差不太多的,也是在内部类初始化的时候为其传入一个外部类实例,区别在哪呢?就在于方法内部类是定义在具体方法的内部的,所以该类除了可以通过传入的外部实例访问外部类中的字段和方法,对于包含它的方法中被传入的参数也会随着外部类实例一起初始化给内部类。

毋庸置疑的是,方法内部类的封装性比之前介绍的两种都要完善。所以一般只有在需要高度封装的时候才会将类定义成方法内部类。

四、匿名内部类

可能内部类的所有分类中,匿名内部类的名号是最大的,也是我们最常用到的,多见于函数式编程,lambda表达式等。下面我们重点看看这个匿名内部类。

匿名内部类就是没有名字的内部类,在定义完成同时,实例也创建好了,常常和new关键字紧密结合。当然,它也不局限于类,也可以是接口 ,可以出现在任何位置。下面我们定义一个匿名内部类:

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
//首先定义一个普通类
public class Out {
 private String name;
  
 private void sayHello(){
  System.out.println("my name is :" + name);
 }
}
//定义和使用一个匿名内部类
public static void main(String [] args){
 Out out = new Out(){
  @Override
  public void sayHello(){
   System.out.println("my name is cyy");
  }
  public void showName(){
   System.out.println("hello single");
  }
 };
 out.sayHello();
}

从上述代码中可以很显然的让我们看出来,我们的匿名内部类必定是要依托一个父类的,因为它是没有名字的,无法用一个具体的类型来表示。所以匿名内部类往往都是通过继承一个父类,重写或者重新声明一些成员来实现一个匿名内部类的定义。实际上还是利用了里式转换原理。

从中我们也可以看到,一个匿名内部类定义的完成就意味着该内部类实例创建的完成。下面我们看看其实现原理:

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
//反编译出来的匿名内部类
static class Test$1 extends Out
{
 Out out;
 public void sayHello()
 {
  System.out.println("my name is cyy");
 }
  
 Test$1(Out o)
 {
  this.out = o;
 }
}

其实在看了上述三种内部类的原理之后,反而觉得匿名内部类的实现较为简单了。主要思路还是将内部类抽离出来,通过初始化传入外部类的实例以达到对外部类所有成员的访问。只是在匿名内部类中,被依托的父类不是他的外部类。匿名内部类的主要特点在于,没有名字,对象只能被使用一次,可以出现在任意位置。所以它的使用场景也是呼之欲出,对于一些对代码简洁度有所要求的情况下,可首选匿名内部类。

以上完成了对四种内部类的简单介绍,对于他们各自实现的原理也都已经介绍过了。其实大致相同,由于jvm对每个类都要求一个单独的源码文件,所以编译阶段就完成了分离的操作,但是在分离的过程中又要保持内部类和外部类之间的这种联系,于是编译器添加了一些接口保持这种信息共享的结构。使用内部类可以大大增加程序的封装性,使得代码整体简洁度较高。

分享到:

相关信息

系统教程栏目

栏目热门教程

人气教程排行

站长推荐

热门系统下载

公众号