从反编译深入理解JAVA内部类类结构以及final关键字

本文详细解析Java中成员内部类、局部内部类和匿名内部类的实现原理,包括它们如何访问外部类成员、生命周期管理以及为何局部变量必须使用final限定符。同时探讨静态内部类的独特之处。

摘要生成于 C知道 ,由 DeepSeek-R1 满血版支持, 前往体验 >

1.为什么成员内部类可以无条件访问外部类的成员?

  在此之前,我们已经讨论过了成员内部类可以无条件访问外部类的成员,那具体究竟是如何实现的呢?下面通过反编译字节码文件看看究竟。事实上,编译器在进行编译的时候,会将成员内部类单独编译成一个字节码文件,下面是Outter.java的代码:


public class Outter {
    private Inner inner = null;
    public Outter() {
         
    }
     
    public Inner getInnerInstance() {
        if(inner == null)
            inner = new Inner();
        return inner;
    }
      
    protected class Inner {
        public Inner() {
             
        }
    }
}


  编译之后,出现了两个字节码文件:


  反编译Outter$Inner.class文件得到下面信息:


E:\Workspace\Test\bin\com\cxh\test2>javap -v Outter$Inner
Compiled from "Outter.java"
public class com.cxh.test2.Outter$Inner extends java.lang.Object
  SourceFile: "Outter.java"
  InnerClass:
   #24= #1 of #22; //Inner=class com/cxh/test2/Outter$Inner of class com/cxh/tes
t2/Outter
  minor version: 0
  major version: 50
  Constant pool:
const #1 = class        #2;     //  com/cxh/test2/Outter$Inner
const #2 = Asciz        com/cxh/test2/Outter$Inner;
const #3 = class        #4;     //  java/lang/Object
const #4 = Asciz        java/lang/Object;
const #5 = Asciz        this$0;
const #6 = Asciz        Lcom/cxh/test2/Outter;;
const #7 = Asciz        <init>;
const #8 = Asciz        (Lcom/cxh/test2/Outter;)V;
const #9 = Asciz        Code;
const #10 = Field       #1.#11; //  com/cxh/test2/Outter$Inner.this$0:Lcom/cxh/t
est2/Outter;
const #11 = NameAndType #5:#6;//  this$0:Lcom/cxh/test2/Outter;
const #12 = Method      #3.#13; //  java/lang/Object."<init>":()V
const #13 = NameAndType #7:#14;//  "<init>":()V
const #14 = Asciz       ()V;
const #15 = Asciz       LineNumberTable;
const #16 = Asciz       LocalVariableTable;
const #17 = Asciz       this;
const #18 = Asciz       Lcom/cxh/test2/Outter$Inner;;
const #19 = Asciz       SourceFile;
const #20 = Asciz       Outter.java;
const #21 = Asciz       InnerClasses;
const #22 = class       #23;    //  com/cxh/test2/Outter
const #23 = Asciz       com/cxh/test2/Outter;
const #24 = Asciz       Inner;
 
{
final com.cxh.test2.Outter this$0;
 
public com.cxh.test2.Outter$Inner(com.cxh.test2.Outter);
  Code:
   Stack=2, Locals=2, Args_size=2
   0:   aload_0
   1:   aload_1
   2:   putfield        #10; //Field this$0:Lcom/cxh/test2/Outter;
   5:   aload_0
   6:   invokespecial   #12; //Method java/lang/Object."<init>":()V
   9:   return
  LineNumberTable:
   line 16: 0
   line 18: 9
 
  LocalVariableTable:
   Start  Length  Slot  Name   Signature
   0      10      0    this       Lcom/cxh/test2/Outter$Inner;
 
 
}


  第11行到35行是常量池的内容,下面逐一第38行的内容:

final com.cxh.test2.Outter this$0;

 

 这行是一个指向外部类对象的指针,看到这里想必大家豁然开朗了。也就是说编译器会默认为成员内部类添加了一个指向外部类对象的引用,那么这个引用是如何赋初值的呢?下面接着看内部类的构造器:

public com.cxh.test2.Outter$Inner(com.cxh.test2.Outter);


  从这里可以看出,虽然我们在定义的内部类的构造器是无参构造器,编译器还是会默认添加一个参数,该参数的类型为指向外部类对象的一个引用,所以成员内部类中的Outter this&0 指针便指向了外部类对象,因此可以在成员内部类中随意访问外部类的成员。从这里也间接说明了成员内部类是依赖于外部类的,如果没有创建外部类的对象,则无法对Outter this&0引用进行初始化赋值,也就无法创建成员内部类的对象了。所以,如果在外部类没有人引用的时候,而成员内部类有人引用,外部类因为被内部类引用所以不会被回收。这就是Android中常见的Activity内存泄露产生的原因。


2.为什么局部内部类和匿名内部类只能访问局部final变量?

  想必这个问题也曾经困扰过很多人,在讨论这个问题之前,先看下面这段代码:

public class Test {
    public static void main(String[] args)  {
         
    }
     
    public void test(final int b) {
        final int a = 10;
        new Thread(){
            public void run() {
                System.out.println(a);
                System.out.println(b);
            };
        }.start();
    }
}


  这段代码会被编译成两个class文件:Test.class和Test1.classOutterx.class(x为正整数)。

  

  根据上图可知,test方法中的匿名内部类的名字被起为 Test$1。

  上段代码中,如果把变量a和b前面的任一个final去掉,这段代码都编译不过。我们先考虑这样一个问题:

  当test方法执行完毕之后,变量a的生命周期就结束了,而此时Thread对象的生命周期很可能还没有结束,那么在Thread的run方法中继续访问变量a就变成不可能了,但是又要实现这样的效果,怎么办呢?Java采用了 复制  的手段来解决这个问题。将这段代码的字节码反编译可以得到下面的内容:



我们看到在run方法中有一条指令:

bipush 10


这条指令表示将操作数10压栈,表示使用的是一个本地局部变量。这个过程是在编译期间由编译器默认进行,如果这个变量的值在编译期间可以确定,则编译器默认会在匿名内部类(局部内部类)的常量池中添加一个内容相等的字面量或直接将相应的字节码嵌入到执行字节码中。这样一来,匿名内部类使用的变量是另一个局部变量,只不过值和方法中局部变量的值相等,因此和方法中的局部变量完全独立开。

  下面再看一个例子:

public class Test {
    public static void main(String[] args)  {
         
    }
     
    public void test(final int a) {
        new Thread(){
            public void run() {
                System.out.println(a);
            };
        }.start();
    }
}


反编译得到:



  我们看到匿名内部类Test$1的构造器含有两个参数,一个是指向外部类对象的引用,一个是int型变量,很显然,这里是将变量test方法中的形参a以参数的形式传进来对匿名内部类中的拷贝(变量a的拷贝)进行赋值初始化。

  也就说如果局部变量的值在编译期间就可以确定,则直接在匿名内部里面创建一个拷贝。如果局部变量的值无法在编译期间确定,则通过构造器传参的方式来对拷贝进行初始化赋值。

  从上面可以看出,在run方法中访问的变量a根本就不是test方法中的局部变量a。这样一来就解决了前面所说的 生命周期不一致的问题。但是新的问题又来了,既然在run方法中访问的变量a和test方法中的变量a不是同一个变量,当在run方法中改变变量a的值的话,会出现什么情况?

  对,会造成数据不一致性,这样就达不到原本的意图和要求。为了解决这个问题,java编译器就限定必须将变量a限制为final变量,不允许对变量a进行更改(对于引用类型的变量,是不允许指向新的对象),这样数据不一致性的问题就得以解决了。

  到这里,想必大家应该清楚为何 方法中的局部变量和形参都必须用final进行限定了。

  3.静态内部类有特殊的地方吗?


  从前面可以知道,静态内部类是不依赖于外部类的,也就说可以在不创建外部类对象的情况下创建内部类的对象。另外,静态内部类是不持有指向外部类对象的引用的,这个读者可以自己尝试反编译class文件看一下就知道了,是没有Outter this&0引用的。      
<think>好的,我现在需要回答用户关于Javafinal关键字的使用方法和规则的问题。首先,我需要仔细阅读用户提供的五个引用内容,确保理解每个引用的重点,然后综合这些信息来组织一个结构清晰的中文回答。 首先,用户的问题分为两部分:使用场景和规则。根据引用,final可以修饰类、方法、变量,每个部分有不同的作用。我需要将这些内容分门别类,逐一解释。同时,要注意引用对应的标注,比如引用[1]、[2]等,确保在回答中正确标注来源。 接下来,我需要检查是否有遗漏的信息。例如,引用[5]提到final引用数据类型时,地址不能被修改,但对象内容可以修改。这一点很重要,应该包含在变量修饰的部分。同时,引用[4]提到final方法不能被重写,这也需要强调。 然后,我需要考虑回答的结构。可能的结构是先总述final的作用,然后分点讨论类、方法、变量,每个部分详细说明规则和使用场景。在每个部分的末尾添加对应的引用标注。例如,在final类的部分,引用[1]和[2]都提到阻止继承,所以标注[^1][^2]。 同时,要注意用户提供的示例中的格式要求:行内数学表达式用$...$,独立公式用$$...$$,但在这个问题中可能涉及代码示例,所以需要正确使用代码块。例如,在讨论final变量时,可以举一个代码例子,如final int x = 10;,并说明其不可变。 另外,用户要求生成相关问题,我需要根据回答内容提出三个相关的问题,例如关于性能影响、设计模式中的应用,以及与不可变类的关系等。 最后,确保整个回答符合用户的要求:使用中文,结构清晰,引用正确,没有使用Markdown格式,段落之间用空行分隔,代码块用三个反引号包裹,并且相关问题部分明确标出。 现在,我需要将以上思考整理成一个连贯的回答,确保各部分信息准确,引用正确,并且语言流畅自然。</think>Java中的`final`关键字用于声明不可变的实体,具体规则和使用场景如下: ### 一、final修饰类 1. **规则** - final类不能被继承,即不允许有子类。 - 类的所有方法隐式声明为`final`(不可覆盖)[^2]。 2. **使用场景** - 设计工具类或核心组件时,防止继承导致的安全风险(如`String`类)[^5]。 ```java final class UtilityClass { // 工具类方法 } ``` --- ### 二、final修饰方法 1. **规则** - final方法不能被子类覆盖(重写)[^4]。 - 父类方法若声明为`final`,子类调用时需保持原逻辑。 2. **使用场景** - 保护关键算法或业务逻辑的完整性(如支付验证逻辑)[^5]。 ```java class Parent { public final void validate() { // 核心验证逻辑 } } ``` --- ### 三、final修饰变量 1. **规则** - **基本类型变量**:值不可修改(如`final int x = 10;`)[^3][^5]。 - **引用类型变量**:引用地址不可修改,但对象内部状态可修改(如`final List<String> list = new ArrayList<>();`允许`list.add("data")`)[^5]。 - **类成员变量**:必须在声明时或构造方法中初始化。 2. **使用场景** - 定义常量(如`MAX_SIZE`); - 多线程环境下共享不可变引用。 ```java final class Constants { public static final double PI = 3.14159; // 常量 } ``` --- ### 四、final参数的规则 - 方法参数声明为`final`时,方法内不能修改其值(适用于Lambda表达式或匿名内部类)。 ```java void process(final int input) { // input = 5; // 编译错误 } ``` --- ### 总结对比 | 修饰对象 | 规则特性 | 典型用途 | |---------|---------|---------| | 类 | 禁止继承 | 安全工具类 | | 方法 | 禁止重写 | 保护核心逻辑 | | 变量 | 禁止重新赋值 | 常量和线程安全 |
评论 6
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值