三、内部类与外部类的引用关系

于 2021-08-25 21:10:34 发布
阅读量731 收藏
点赞数
分类专栏： Java基础知识 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/eava_wu/article/details/119919612
版权

内部类引用外部类成员的情况

Java的内部类持有外部类的的引用，在字节码层面是怎么设计的呢？我们写一段代码来看看,假设有这么一个内部类Inner，访问了外部类Out，示例代码如下:

public class Outer {
	int outerField = 5;
	class Inner{
		public int InnerMethod(){
			//调用外部类的成员变量
			return outerField+1;
		}
	}
	public Inner getInnter(){
		return new Inner();
	}

	public static void main(String[] args) {
		Outer outer = new Outer();
		Inner innter = outer.getInnter();
		System.out.println(innter.InnerMethod());
	}
}

接下来我们使用：

javac Outer.java
java Outer

这段代码的意思是，内部类访问了外部类的outerField，然后+1返回。最后再打印，我们贴一下打印结果:

6

接下来我们看一下我们Javac之后,反编译的产物:

Outer.class

public class Outer {
    int outerField = 5;

    public Outer() {
    }

    public Outer.Inner getInnter() {
        return new Outer.Inner();
    }

    public static void main(String[] var0) {
        Outer var1 = new Outer();
        Outer.Inner var2 = var1.getInnter();
        System.out.println(var2.InnerMethod());
    }

    class Inner {
        Inner() {
        }

        public int InnerMethod() {
            return Outer.this.outerField + 1;
        }
    }
}

Outer$Inner.class

class Outer$Inner {
    Outer$Inner(Outer var1) {
        this.this$0 = var1;
    }

    public int InnerMethod() {
        return this.this$0.outerField + 1;
    }
}

可以看到，Out$Innter.class反编译后的构造函数默认带了Outer参数。

接下来我们使用javap -c Out来看看字节码

Compiled from "Outer.java"
public class com.java.oom.Outer {
  int outerField;

  //out class
  public com.java.oom.Outer();
    Code:
       0: aload_0
       1: invokespecial #1                  // Method java/lang/Object."<init>":()V
       4: aload_0
       5: iconst_5
       6: putfield      #7                  // Field outerField:I
       9: return
     
  public com.java.oom.Outer$Inner getInnter();
    Code:
       0: new           #13                 // class com/java/oom/Outer$Inner
       3: dup
       4: aload_0
       //这行， invokespecial需要传入 (Lcom/java/oom/Outer;)V来执行init函数。
       5: invokespecial #15                 // Method com/java/oom/Outer$Inner."<init>":(Lcom/java/oom/Outer;)V
       8: areturn

  public static void main(java.lang.String[]);
    Code:
       0: new           #8                  // class com/java/oom/Outer
       3: dup
       4: invokespecial #18                 // Method "<init>":()V
       7: astore_1
       8: aload_1
       9: invokevirtual #19                 // Method getInnter:()Lcom/java/oom/Outer$Inner;
      12: astore_2
      13: getstatic     #23                 // Field java/lang/System.out:Ljava/io/PrintStream;
      16: aload_2
      17: invokevirtual #29                 // Method com/java/oom/Outer$Inner.InnerMethod:()I
      20: invokevirtual #33                 // Method java/io/PrintStream.println:(I)V
      23: return
}

综合反编译的结果和字节码，所以我们说，Java内部类会在init阶段，把外部类的对象传进去，然后在构造函数里面赋值为内部类的成员变量。

内部类不使用外部类的成员，是否会持有外部类的对象

那我们看一下，假设内部类不引用外部类的成员变量，会是什么样呢？

我们对刚才的Outer进行小范围的修改:

package com.java.oom;

import java.util.concurrent.atomic.AtomicInteger;

public class Outer {
	class Inner{
		public int InnerMethod(){
			//调用外部类的成员变量
			return 10;
		}
	}
	public Inner getInnter(){
		return new Inner();
	}

	public static void main(String[] args) {
		Outer outer = new Outer();
		Inner innter = outer.getInnter();
		System.out.println(innter.InnerMethod());
	}
}

接下来我们编译一下

javac Outer.java
java Outer

执行结果:

10

看一下生成的Outer.class:

//
// Source code recreated from a .class file by IntelliJ IDEA
// (powered by Fernflower decompiler)
//

package com.java.oom;

public class Outer {
    public Outer() {
    }

    public Outer.Inner getInnter() {
        return new Outer.Inner();
    }

    public static void main(String[] var0) {
        Outer var1 = new Outer();
        Outer.Inner var2 = var1.getInnter();
        System.out.println(var2.InnerMethod());
    }

    class Inner {
        Inner() {
        }

        public int InnerMethod() {
            return 10;
        }
    }
}

然后看一下Inner.class:

//
// Source code recreated from a .class file by IntelliJ IDEA
// (powered by Fernflower decompiler)
//

package com.java.oom;

class Outer$Inner {
    Outer$Inner(Outer var1) {
        this.this$0 = var1;
    }

    public int InnerMethod() {
        return 10;
    }
}

这里看到还是有引用的，但是反编译出来的不一定是最终的，我们来看看字节码:

警告: 二进制文件Outer包含com.java.oom.Outer
Compiled from "Outer.java"
public class com.java.oom.Outer {
  public com.java.oom.Outer();
    Code:
       0: aload_0
       1: invokespecial #1                  // Method java/lang/Object."<init>":()V
       4: return

  public com.java.oom.Outer$Inner getInnter();
    Code:
       0: new           #2                  // class com/java/oom/Outer$Inner
       3: dup
       4: aload_0
       5: invokespecial #3                  // Method com/java/oom/Outer$Inner."<init>":(Lcom/java/oom/Outer;)V
       8: areturn

  public static void main(java.lang.String[]);
    Code:
       0: new           #4                  // class com/java/oom/Outer
       3: dup
       4: invokespecial #5                  // Method "<init>":()V
       7: astore_1
       8: aload_1
       9: invokevirtual #6                  // Method getInnter:()Lcom/java/oom/Outer$Inner;
      12: astore_2
      13: getstatic     #7                  // Field java/lang/System.out:Ljava/io/PrintStream;
      16: aload_2
      17: invokevirtual #8                  // Method com/java/oom/Outer$Inner.InnerMethod:()I
      20: invokevirtual #9                  // Method java/io/PrintStream.println:(I)V
      23: return
}

我们看看getInner的第五航，这里调用了Inner方法的init方法，这里你可以认为是调用了构造函数，传入的参数是

com/java/oom/Outer;返回值是void。到这里就真的确定在new Inner的时候，传入了Outer对象。那证明内部类无论是使用还是不适用外部类的对象，均会持有外部类的引用。所以开发时需要谨慎的使用匿名内部类，控制好使用的生命周期。还有就是使用静态内部类。都说到这了，我们看一下静态内部类的字节码表现是怎么样的.

静态内部类

我们对之前的类进行稍微的修改，把inner变成static:

//
// Source code recreated from a .class file by IntelliJ IDEA
// (powered by Fernflower decompiler)
//

package com.java.oom;

public class Outer {
    public Outer() {
    }

    public Outer.Inner getInnter() {
        return new Outer.Inner();
    }

    public static void main(String[] var0) {
        Outer var1 = new Outer();
        Outer.Inner var2 = var1.getInnter();
        System.out.println(var2.InnerMethod());
    }

    static class Inner {
        Inner() {
        }

        public int InnerMethod() {
            return 10;
        }
    }
}




package com.java.oom;

class Outer$Inner {
    Outer$Inner() {
    }

    public int InnerMethod() {
        return 10;
    }
}

我们再来看一下字节码:

警告: 二进制文件Outer包含com.java.oom.Outer
Compiled from "Outer.java"
public class com.java.oom.Outer {
  public com.java.oom.Outer();
    Code:
       0: aload_0
       1: invokespecial #1                  // Method java/lang/Object."<init>":()V
       4: return

  public com.java.oom.Outer$Inner getInnter();
    Code:
       0: new           #2                  // class com/java/oom/Outer$Inner
       3: dup
       4: invokespecial #3                  // Method com/java/oom/Outer$Inner."<init>":()V
       7: areturn

  public static void main(java.lang.String[]);
    Code:
       0: new           #4                  // class com/java/oom/Outer
       3: dup
       4: invokespecial #5                  // Method "<init>":()V
       7: astore_1
       8: aload_1
       9: invokevirtual #6                  // Method getInnter:()Lcom/java/oom/Outer$Inner;
      12: astore_2
      13: getstatic     #7                  // Field java/lang/System.out:Ljava/io/PrintStream;
      16: aload_2
      17: invokevirtual #8                  // Method com/java/oom/Outer$Inner.InnerMethod:()I
      20: invokevirtual #9                  // Method java/io/PrintStream.println:(I)V
      23: return
}

从字节码可以看出，调用getInner方法的invokespecial函数，执行Init的参数和返回值是

"<init>":()V //()表示没有参数

这里非常需要注意的一个点是，静态内部类的生命周期是很长的，如果持有了短生命周期的东西，会造成内存泄漏，通常的解法是使用弱引用来持有短生命周期的对象。以AndroidHandler为例子:

package com.jhzl.memoryleak;

import androidx.annotation.NonNull;
import androidx.appcompat.app.AppCompatActivity;
import android.app.Activity;
import android.os.Bundle;
import android.os.Handler;
import android.os.Looper;
import android.os.Message;
import java.lang.ref.WeakReference;

public class MainActivity extends AppCompatActivity {

   static class MainHandler extends  Handler{
       WeakReference<Activity> activityWeakReference = null;
       MainHandler(Activity activity){
            activityWeakReference = new WeakReference(activity);
       }
       @Override
       public void handleMessage(@NonNull Message msg) {
           super.handleMessage(msg);
           if (activityWeakReference == null){
               return;
           }
           Activity activity = activityWeakReference.get();
       }
   }

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        MainHandler mainHandler = new MainHandler(this);
    }
}

这里就使用到了Activity对象，有可能生命周期就比Handler短，所以需要用弱引用包裹一下，防止泄露。

怪叔叔萝莉控
关注
专栏目录
浅谈Java内部类及变量的调用
weixin_53122091的博客
12-13 1803
说到Java的内部类大致分为以下四种：成员内部类、局部内部类、匿名内部类、静态内部类。 这次我们先谈谈最为简单的成员内部类 首先，成员内部类是直接定义在另一个类中（与成员并列），它可以用所有的修饰符修饰。 这里有一个Father类，里面有定义的一个成员内部类Son public class Father { private String fatherName = "父亲"; public int age = 40; protected int money; ...
外部类，内部类以及静态内部类的加载关系深入探讨
mmyzhenyuanzi的博客
07-19 545
前言： 　　在看单例模式的时候，在网上找帖子看见其中有一种（IoDH） 实现单例的方式，其中用到了静态内部类，文章中有写到当jvm加载外部类的时候，并没有加载静态内部内这和之前自己想的不一样，特意在网上找了一些帖子总结一下。 一、学习前千的疑问： 　　稍微了解Java虚拟机内的加载过程的步骤，都很清楚，一个类的静态资源、一些常量都是在类加载的时候就被加载金内存中分配空间了，所以我一开始理所当然的以为静态内部类中的静态变量同样属于静态资源，也应该在在内加载的时候被加载，然而实际情况却不是这样的，带着这个
内部类和外部类之间的相互调用
weixin_30677073的博客
04-21 354
内部类： ①静态内部类中可以有非静态的方法 ②当内部类中有静态方法或者静态成员变量时，一定是静态内部类 一般内部类在外部类的成员变量位置，像这样： 1 public class Outer { 2 class Inner{ 3 4 } 5 } 1、外部类访问内部类： 　　　内部类被static修饰：可以直接new 　　　　Inn...
Java内部类持有外部类的引用
sscout的博客
09-22 1245
在Java中内部类的定义与使用一般为成员内部类与匿名内部类，他们的对象都会隐式持有外部类对象的引用，影响外部类对象的回收。通过反编译我们可以来验证这个理论。 public class Outer { private String name; class Inner{ private String test; } } Outer是一个普通的类，它有一个...
Java内部类持有外部类的引用详细分析与解决方案
weixin_33869377的博客
03-27 213
在Java中内部类的定义与使用一般为成员内部类与匿名内部类，他们的对象都会隐式持有外部类对象的引用，影响外部类对象的回收。 GC只会回收没有被引用或者根集不可到达的对象（取决于GC算法），内部类在生命周期内始终持有外部类的对象的引用，造成外部类的对象始终不满足GC的回收条件，反映在内存上就是内存泄露。（如，Android中Activity的内存泄露） 解决方案为 1.将内部类定义为static 2...
java 外部类 内部类_Java内部类持有外部类的引用详细分析与解决方案
weixin_42451850的博客
02-18 283
在Java中内部类的定义与使用一般为成员内部类与匿名内部类，他们的对象都会隐式持有外部类对象的引用，影响外部类对象的回收。GC只会回收没有被引用或者根集不可到达的对象(取决于GC算法)，内部类在生命周期内始终持有外部类的对象的引用，造成外部类的对象始终不满足GC的回收条件，反映在内存上就是内存泄露。(如，Android中Activity的内存泄露)解决方案为1.将内部类定义为static2.用st...
对Java的面对对象编程中对象和引用以及内部类的理解
09-02
- 静态内部类与普通成员内部类类似，但可以独立于外部类实例存在，只能访问外部类的静态成员。 - 局部内部类仅能在方法内定义，不能声明为静态，只能在该方法内部使用，同样可以访问外部类的所有成员，但生命周期...
Java中的静态内部类详解及代码示例
08-29
静态内部类与其它内部类的区别在于非静态内部类在编译完成之后会隐含地保存一个引用，该引用是指向创建它的外部类，但是静态内部类却没有。静态内部类只是嵌套在外部类中，因此也被称为嵌套内部类。 静态内部类的...
全面了解Java中的内部类和匿名类
09-01
4. 依赖关系：非静态内部类可以持有对外部类的引用，使得它们能够紧密协作。 理解并熟练运用内部类和匿名类是Java高级编程的关键部分，它们可以提升代码的灵活性和可维护性。在实际开发中，可以根据需求选择合适的...
java内部类调用外部类属性，真香系列
m0_56830725的博客
07-21 657
概述 什么是Redis Redis有哪些优缺点 为什么要用Redis /为什么要用缓存 为什么要用Redis而不用map/guava做缓存? Redis为什么这么快 二、数据类型 Redis有哪些数据类型 Redis的应用场景 三、持久化 什么是Redis持久化? Redis的持久化机制是什么?各自的优缺点? 如何选择合适的持久化方式 Redis持久化数据和缓存怎么做扩容? 四、过期键的删除策略 Redis的过期键的删除策略 Redis key的过期时间和永久有效分别怎么设置? 我们知道通过e
java中的内部类详细总结
09-04
这种方式生成的字节码文件为`Out$In.class`，其中`$`表示内部类与外部类的关系。 2. 局部内部类 局部内部类是在方法、构造器或块中定义的类，其作用域仅限于该方法、构造器或块。局部内部类可以访问其所在作用域内...
内存泄漏-内部类持有外部类引用
whurs的专栏
11-25 5160
1.内部类持有外部类引用 我们在处理Android内存泄漏的时候，经常会遇到一些是由于内部类持有外部类引用而引发的。严格来说是非static的内部类的非static对象或匿名内部类的非static对象持有了当前所在外部类的引用造成的。下面我们用一个例子来进行说明 public class LeakTestActivity extends BaseActivity { private But...
java外部类_Java里什么叫内部类什么叫外部类?
weixin_39883091的博客
02-15 671
内部类简介虽然Java是一门相对比较简单的编程语言，但是对于初学者， 还是有很多东西感觉云里雾里，理解的不是很清晰。内部类就是一个经常让初学者感到迷惑的特性。 即使现在我自认为Java学的不错了，但是依然不是很清楚。其中一个疑惑就是为什么内部类对象可以访问外部类对象中的成员(包括成员变量和成员方法)？早就想对内部类这个特性一探究竟了，今天终于抽出时间把它研究了一下。内部类就是定义在一个类内部的类。...
在内部类中生成对外部类的引用
奔跑的蜗牛
08-10 506
在内部类中使用 外包类.this 生成对外部类的对象的引用 备注：在拥有外包类对象之前是无法创建内部类对象的，因为内部类对象需要指向外包类对象的引用.public class ThisAndNew { public class Inner{ public ThisAndNew outer(){ /** * 在内部类中使用
内部类引用外部类对象
atarik@163.com
11-28 2238
测试实体类 @Data public class TestEn { String ss; Inner inner; //@Data public class Inner{ String s; @Override public String toString() { return "Inner [s=" + s + "]"; } public Strin
内部类可以直接访问外部类成员吗_Java面向对象之内部类—inner class
weixin_35983438的博客
01-28 2187
Java面向对象之内部类—inner class内部类Java 类中的可以定义的成员有：字段、方法、内部类，内部类是定义在类结构中的另一个类，因为定义在类的内部，故称为内部类。public class OuterClass {......public class InnerClass {......}}在上述的代码示例中，就可以将InnerClass称之为OuterClass的内部类。为什么使用内...
内部类与外部类的地址关系
最新发布
05-14
如果内部类是静态的，它与外部类之间没有地址关系，它们之间是相互独立的。而如果内部类是非静态的，它们之间就存在着地址关系，内部类实例中包含一个指向外部类实例的引用。这个引用可以通过内部类的构造函数来初始...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值