Java内部类从字节码层面理解

最新推荐文章于 2022-01-25 11:36:42 发布
最新推荐文章于 2022-01-25 11:36:42 发布
阅读量209 收藏 1
点赞数
分类专栏： Java 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43526405/article/details/104355763
版权

1. 非静态内部类

  • 非静态内部类常用语法
package inner;
public class OuterClass {
    private String string;
    private int anInt;
    public OuterClass(String string, int anInt) {
        this.string = string;
        this.anInt = anInt;
    }
    public OuterClass(){
    }
    private void outInt(){
        System.out.println("int:"+anInt);
    }
    //非静态方法
    public void output1(){
        //外部类的非静态方法里面直接使用new就可以创建内部类实例
        InnerClass innerClass = new InnerClass();
        innerClass.innerPut();
    }
    //静态方法
    public static void output2(){
        //外部类的静态方法里面必须先创建外部类实例，再用外部类实例创建内部类实例
        OuterClass outerClass = new OuterClass("str", 10);
        InnerClass innerClass = outerClass.new InnerClass();  //语法为：外部类实例.new 内部类
        innerClass.innerPut();
    }
    //创建内部类
    class InnerClass{
        private void innerPut(){
            //内部类可以调用外部类的私有成员变量和私有成员方法
            System.out.println("string:"+string);
            outInt();
        }
    }

    public static void main(String[] args){
        //静态方法中使用内部类，必须先创建外部类实例，在用外部类实例创建内部类实例
        OuterClass outerClass = new OuterClass("str", 10);
        //声明外部类时可以添加内部类的类名,当然也可以不添加
        OuterClass.InnerClass innerClass = outerClass.new InnerClass();
        innerClass.innerPut();
    }
}

运行结果：

string:str
int:10
  • 非静态内部类可以调用外部类的私有成员变量和成员方法，但是不能声明静态变量和静态方法、静态类，原因：JVM在进行类加载的时候会先加载静态属性和静态代码块，因此非静态类里面的静态属性会优先于静态类进行加载，此时就会出现矛盾
  • 非静态内部类的声明：
    • 在外部类的方法中既可以使用InnerClass innerClass;,也可以使用OuterClass.InnerClass innerClass;,推荐使用第二种
    • 在不是外部类中的类声明，则只能使用第二种,OuterClass.InnerClass innerClass = new OuterClass().new InnerClass();
  • 非静态内部类的初始化：
    • 在外部类非静态方法中：和普通类的声明一样，InnerClass innerClass = new InnerClass();
    • 在外部类静态方法中：需要先创建外部类的实例，然后再用外部类的实例来创建内部类实例，InnerClass innerClass = new OuterClass().new InnerClass()
  • 在内部类中引用外部类对象OuterClass2.this
package inner;
public class OuterClass2 {
    public void output(){
        System.out.println("OuterClass2.output");
    }
    class InnerClass{
        public OuterClass2 getOuterClass2(){
            return OuterClass2.this; //引用外部类对象
        }
    }
    public static void main(String[] args){
        InnerClass innerClass = new OuterClass2().new InnerClass();
        OuterClass2 outerClass2 = innerClass.getOuterClass2();
        outerClass2.output();
    }
}

运行结果：

OuterClass2.output

2. 静态内部类

  • 静态内部类又称嵌套类
package inner;
public class OuterClass3 {
     //创建静态内部类
     static class StaticInnerClass{
         //可以声明静态和非静态的变量和方法，但是不能调用外部类的非静态成员和非静态方法
        private String str = "str";
        private static String string = "string";
        public void InnerPut(){
            System.out.println(str);
        }
        public static void staticInnerPut(){
            System.out.println(string);
        }
        static class StaticInnerClass2{
            public void staticInnerPut2(){
                System.out.println(string);
            }
        }
    }
    public static void main(String[] args){
         //第一种初始化方法
        OuterClass3.StaticInnerClass staticInnerClass = new OuterClass3.StaticInnerClass();
        //第二种初始化方法
        OuterClass3.StaticInnerClass staticInnerClass1 = new StaticInnerClass();
        staticInnerClass.InnerPut();
        OuterClass3.StaticInnerClass.StaticInnerClass2 staticInnerClass2 = new StaticInnerClass.StaticInnerClass2();
        staticInnerClass2.staticInnerPut2();
    }
}

运行结果：

str
string
  • 静态内部类中可以声明静态和非静态的成员变量、方法、类，但是在不能在嵌套类的对象中访问非静态的外围类对象
  • 静态内部类初始化：
    • 第一种方法OuterClass3.StaticInnerClass staticInnerClass = new OuterClass3.StaticInnerClass();
    • 第二种方法：OuterClass3.StaticInnerClass staticInnerClass1 = new StaticInnerClass();
  • 静态内部类中没有this引用，类似于一个static方法

3. 匿名内部类

  • 1.本质上是：继承父类形式的匿名内部类
package inner;
public class OuterClass4 {
    public FatherClass getFatherClass(){
        //匿名内部类
        return new FatherClass(){
            public void output(){
                System.out.println("Son");
            }
        };
    }
    public static void main(String[] args){
        OuterClass4 outerClass4 = new OuterClass4();
        FatherClass fatherClass = outerClass4.getFatherClass();
        fatherClass.output();
    }
}
class FatherClass{
    public void output(){
        System.out.println("Father");
    }
}

上述匿名内部类是下述的简化形式：

package inner;
public class OuterClass4_2 {
    class SonClass extends FatherClass{
        public void output(){
            System.out.println("son");
        }
    }
    public FatherClass getFatherClass(){
        return new SonClass();
    }
    public static void main(String[] args){
        OuterClass4_2 outerClass4_2 = new OuterClass4_2();
        FatherClass fatherClass = outerClass4_2.getFatherClass();
        fatherClass.output();
    }
}
class FatherClass{
    public void output(){
        System.out.println("Father");
    }
}

两个的输出结果一样：

Son
  • 2.本质上是：实现接口的匿名内部类形式
package inner;
public class OuterClass5 {
    public FatherInterface getFatherInterface(){
        return new FatherInterface() {
            @Override
            public void output() {
                System.out.println("Son");
            }
        };
    }
    public static void main(String[] args){
        OuterClass5 outerClass5 = new OuterClass5();
        FatherInterface fatherInterface = outerClass5.getFatherInterface();
        fatherInterface.output();
    }
}
interface FatherInterface{
    void output();
}

上述匿名内部类是下述的简化形式

package inner;
public class OuterClass5_2 {
    class SonClass implements FatherInterface{
        @Override
        public void output() {
            System.out.println("son");
        }
    }
    public FatherInterface getFatherInterface(){
        return new SonClass();
    }
    public static void main(String[] args){
        OuterClass5_2 outerClass5_2 = new OuterClass5_2();
        FatherInterface fatherInterface = outerClass5_2.getFatherInterface();
        fatherInterface.output();
    }
}
interface FatherInterface{
    void output();
}

两个的输出结果是一样的：

Son
  • 结论：匿名内部类实际上是继承了某个父类，或者是实现某个接口，通过new表达式返回引用被自动向上转型
  • 3.匿名内部类中向父类构造器传递参数:
package inner;
public class OuterClass4 {
    public FatherClass getFatherClass(String string){
        //匿名内部类
        return new FatherClass(string){
            public void output(){
                System.out.println("Son");
            }
        };
    }
    public static void main(String[] args){
        OuterClass4 outerClass4 = new OuterClass4();
        FatherClass fatherClass = outerClass4.getFatherClass("string");
        fatherClass.output();
    }
}
class FatherClass{
    private String string;
    public FatherClass(String string){
        this.string = string;
    }
    public void output(){
        System.out.println(string);
    }
}

输出结果：

Son
  • 4.匿名内部类变量注意点
package inner;
public class OuterClass4 {
    public FatherClass getFatherClass(String string){
        String str = "str";
        str = "null"; //可以重新赋值这可以看出此时的str并不是final类型
        //匿名内部类,如果你在匿名类中使用了参数变量或使用了局部变量，则它必须为final类型；如果你没有在匿名类中使用过它，那它就没有被默认添加final类型
        return new FatherClass(string){
            public void output(){
                System.out.println(string);//此时的string为final类型，如果再用string重新赋值则会报错
                string = "string";//报错
            }
        };
    }
    public static void main(String[] args){
        OuterClass4 outerClass4 = new OuterClass4();
        FatherClass fatherClass = outerClass4.getFatherClass("string");
        fatherClass.output();
    }
}
class FatherClass{
    private String string;
    public FatherClass(String string){
        this.string = string;
    }
    public void output(){
        System.out.println(string);
    }
}
  • 注意：匿名内部类中如果使用了方法传递进来的参数或者使用了局部变量，那么该参数一定是final类型。在JDK8之前不写final会报错，JDK8之后不写的话底层会默认帮你添加final。但是如果你没有在匿名内部类中使用过参数和局部变量，那么它们不会被默认添加上final类型
    原因：内部类和外部类各会产生一个class文件，实际上编译后的内部类的构造方法的里面，传了对应的外部类的引用和所有局部变量的形参。在外部类方法被调用后，局部变量会被销毁，因此内部类构造函数中的局部变量实际上是一份"复制"。如果不设为final，那么内部类构造完毕后，外部类的局部变量改变了，内部类中的局部变量却没有改变,这就产生了不一致的情况

4. 从字节码再看匿名内部类

  • 实例代码：
package inner;
public class InnerClass {
    public FatherClass getFatherClass(String string){
        String str = "str";
        return new FatherClass(string){
            public void output(){
                System.out.println(string);
            }
        };
    }
    public static void main(String[] args){
        InnerClass innerClass = new InnerClass();
        FatherClass fatherClass = innerClass.getFatherClass("string");
        fatherClass.output();
    }
}
class FatherClass{
    private String string;
    public FatherClass(String string){
        this.string = string;
    }
    public void output(){
        System.out.println(string);
    }
}

生成的字节码文件：
在这里插入图片描述

Compiled from "InnerClass.java"
class inner.InnerClass$1 extends inner.FatherClass {
  final java.lang.String val$string;
  final inner.InnerClass this$0;
  inner.InnerClass$1(inner.InnerClass, java.lang.String, java.lang.String);
    Code:
       0: aload_0
       1: aload_1
       2: putfield      #1                  // Field this$0:Linner/InnerClass;
       5: aload_0
       6: aload_3
       7: putfield      #2                  // Field val$string:Ljava/lang/String;
      10: aload_0
      11: aload_2
      12: invokespecial #3                  // Method inner/FatherClass."<init>":(Ljava/lang/String;)V
      15: return

  public void output();
    Code:
       0: getstatic     #4                  // Field java/lang/System.out:Ljava/io/PrintStream;
       3: aload_0
       4: getfield      #2                  // Field val$string:Ljava/lang/String;
       7: invokevirtual #5                  // Method java/io/PrintStream.println:(Ljava/lang/String;)V
      10: return
}

从这个字节码中我们可以得到很多信息：

  1. final java.lang.String val$string;因为我们使用了传进来的参数string，因此它是final类型。
  2. 因为我们没有在方法中使用局部变量str，因此它并不是final类型。
  3. final inner.InnerClass this$0;这个就是我们内部类可以访问外部类中的变量和方法的原因，内部类对象会秘密捕获外部类的一个引用，我们实际上就是通过这个外部类的引用来访问外部类的变量和方法的。
  4. inner.InnerClass$1(inner.InnerClass, java.lang.String, java.lang.String);参数、局部变量、外部类的引用在底层都转化成了匿名类内部的成员变量，并且是通过匿名类的构造函数传递进来的。

5. 局部内部类

  • 局部内部类与匿名内部类的简单比较
package inner;
public class InnerClass {
    InterfaceFather getInterfaceFather(){
        //局部内部类
        class LocalClass implements InterfaceFather{

            @Override
            public void output() {
                
            }
        }
        return new LocalClass();
    }
    InterfaceFather getInterfaceFather2(){
        //匿名内部类
        return new InterfaceFather() {
            @Override
            public void output() {
                
            }
        };
    }
}
interface InterfaceFather{
    void output();
}
  • 局部内部类的名字在方法外是不可见的，当我们需要自己命名一个构造器或者重载构造器或者需要多个内部类对象时，可以使用局部内部类。而匿名内部类只能用于实例初始化

6. 内部类标识符

  • 1.普通的内部类的标识符格式：外部类名$内部类名
public class OuterClass{
    public class InnerClass{}
    public static class InnerClass2{}
}

这个文件会生成的class文件：OuterClass$InnerClass.class, OuterClass$InnerClass2.class

  • 2.局部内部类的表示符格式：外部类名$数字+局部内部名，局部内部类加上数字编号，防止同一个类中，局部类重复
interface Contents{}
public class LocalClass{
    public void method(){
        class ContentesImp1 implements Contentes{
        }
    }

    public void method2(){
        class ContentesImp2 implements Contentes{
        }
    }
}

这个文件会生成的class文件：Contents.class LocalClass$1ContentesImp1.class, LocalClass$2ContentesImp2.class, LocalClass.class

  • 3.匿名类的标识符：外围类名$数字 编译器会简单地产生一个数字作为其标识符
interface Contents{}
public class AClass{
    public void method(){
        new Contents(){
        };
    }
    public void method2(){
        new Contents(){
        };
    }
}

这个文件会生成的class文件：AClass$1.class,AClass$2.class,AClass.class,Contents.class

  • 4.嵌套内部类：外部类名$内部类名 嵌套了多少内部类就在后面加多少个内部类
public class A{
    public class B{
        public class c{}
    }
}

这个文件会生成的class文件：A.clss,A$B.class,A$B$C.class

总结(为什么需要内部类)

  • 一般来说，内部类继承自某个类或实现某个接口。内部类的代码操作创建它的外部类对象，所以可以认为内部类提供了某种进入外部类的窗口
  • 内部类可以有效的实现"多重继承"，这使得多重继承的方案变得完整
  • 可以封闭我们所不想被别人访问的类

参考资料

《Java编程思想》

程序无言
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
java(1.8)字节码读例(匿名内部类)
01-20
源代码 public class ThreadDemo { public static void main(String[] args) { for(int i = 0;i<10;i++){ final int j = i; new Thread(new Runnable() { @Override public void run() { ...
从一个class文件深入理解Java字节码结构
11-15
我们都知道，Java程序最终是转换成class文件执行在虚拟机上的，那么class文件是个怎样的结构，虚拟机又是如何处理去执行class文件里面的内容呢，这篇文章带你深入理解Java字节码中的结构。 1.Demo源码 首先，编写一...
Java 基础巩固：内部类的字节码学习和实战使用场景
张拭心的博客 shixinzhang
11-30 1万+
文章出自：安卓进阶学习指南 主要贡献者： Cloud9527 Alex_赵 Struggle shixinzhang 读完本文你将了解: 背景介绍 四种内部类介绍 成员内部类 静态内部类 局部内部类 匿名内部类 内部类的使用场景 成员内部类的使用场景 静态内部类的使用场景 匿名内部类的使用场景 局部内部类 内存泄漏 总结 ...
一文详细了解java内部类
ckk727的博客
10-31 226
成员内部类 成员内部类就像是在外部类中定义了一个成员变量一样，因此成员内部类可以被public、protected、private或者包访问权限等多种权限修饰。同样的，如果是被public修饰的内部类，则可以在外部创建并调用，如果是被private修饰的内部类，则只能在外部类中创建并调用。 内部类中也可以定义若干字段与方法，它们同样可以被多种权限修饰，这点和普通的类是一样的。需要注意的一点是，如...
从字节码来看java内部类
qq_36258498的博客
12-25 686
在java中一个类的内部可以存在另一个类，这个类被称为内部类，也被叫做类的嵌套，内部类大体可以分为静态内部类和非静态内部类下面来简单研究下静态内部类 public class Demo1 { private static int i =1; static class Inner{ public static void fun(){ System.out.println(i); ...
Java 基础夯实3：通过字节码了解内部类
安卓进化论
11-30 1147
文章出自：安卓进阶学习指南主要贡献者：Cloud9527Alex_赵Struggleshixinzhang读完本文你将了解:通过反编译介绍四种内部类结合实战介绍内部类的使用场景背景介绍大家好，这篇文章是 《安卓进阶技能树计划》 的第一部分 《Java 基础系列》 的第三篇。我们做这个活动，除了要保证知识点的全面、完整，还想要让每一篇文章都有自己的思考，尽可能的将知识点与实践结合，努力让读者读了有所
从字节码角度深入分析内部类（局部内部类，成员内部类，静态内部类，匿名内部类）
qq838642798的博客
07-22 671
1.      局部内部类 源码: public void subscribeQueue(Jedis jedis,String[] channels) {            // TODO Auto-generated method stub            class MyJedisPubSub extendsJedisPubSub{                    
从Java代码到字节码（1）Java开发Java经验技巧共
11-22
从Java代码到字节码（1）Java开发Java经验技巧共41页.pdf.zip
java注解_反射_字节码_类加载机制.zip
05-13
java 注解 反射 字节码 类加载 包括pdf资料以及全部源码文件，具有非常大参考价值和学习意义
Java字节码指令集的使用详细
09-05
本篇文章对Java字节码指令集的使用进行了详细的介绍。需要的朋友参考下
Java 基础 - 类字节码详解
热门推荐
简单记录一下。
03-06 20万+
源代码通过编译器编译为字节码，再通过类加载子系统进行加载到JVM中运行。 多语言编译为字节码在JVM运行 计算机是不能直接运行java代码的，必须要先运行java虚拟机，再由java虚拟机运行编译后的java代码。这个编译后的java代码，就是本文要介绍的java字节码。 为什么jvm不能直接运行java代码呢，这是因为在cpu层面看来计算机中所有的操作都是一个个指令的运行汇集而成的，java是高级语言，只有人类才能理解其逻辑，计算机是无法识别的，所以java代码必须要先编译成字节码文件，jvm才能正
总结一下Java字节码
阳光大男孩！！！的博客
01-25 607
前言 字节码是一种中间码，我们都知道计算机运行只认机器码，我们使用Java编写出来的代码需要转换为机器码才能正常运行。 字节码就是Java代码-》机器码这个过程中的中间产物，编译器可以将Java代码编译成.class文件，该文件的内容就是字节码，之后可以交由JVM虚拟机将这些字节码加载。 字节码组成 字节码的生成，对应编译器的编译，是按照类来分别编译.class文件的，可以将一个字节码文件分成class摘要、常量池、方法栈帧这三部分。 class摘要：摘要主要就是记录class的一些基本信息，包括类的大小
为什么匿名内部类需要访问局部变量需要加上final
Hpsyche的博客
09-13 1298
前言 package hpsyche.finaltest; /** * @author Hpsyche */ public class Hello { public static void main(String[] args) { String str="haha"; new Thread(() -> System.out.println(str...
从字节码深刻理解内部类
a1102325298的博客
10-18 170
点击上方蓝字关注我嵌套类有四种：静态成员类非静态成员类匿名类局部类除了第一种之外，其他三种都被称为内部类。匿名类的缺陷除了在他们声明的时候之外，是无法将他们实例化的。不能执行 insta...
java反射——对内部类的处理
记忆的水晶
05-01 1269
Class类本身还提供对于获取内部类字节码的方法，分别为getClasses和getDeclaredClasses()，其中getClasses()只能得到访问级别为public的内部类，而getDeclaredClasses()则能得到所有声明了的内部类。 由于内部类可以分为实例内部类，静态内部类，匿名内部类，前面提到的getClasses()和getDeclaredClasses()目前还都
内部类
woniu_li的博客
07-28 140
概念 1. 在类的内部再定义一个完整的类称为内部类。 2. 内部类编译之后会生成独立的字节码文件。 3. 内部类可以访问外部类的私有成员，而不破坏封装。 4. 可为外部类提供必要的内部功能组件。 成员内部类 1.成员内部类：是外部类的一个成员部分，创建内部类时，必须依赖外部类 2.示例： public class Student { private int age = 18; private String name = "张三"; public void end(..
26.【内部类】
Luis
03-10 164
内部类 将一个类A定义在另一个类B里面，里面的那个类A就称为内部类，B则称为外部类。 内部类仍然是一个独立的类，在编译之后内部类会被编译成独立的.class文件，但是前面冠以外部类的类名和$符号。 比如：Person$Heart.class 成员内部类 成员内部类：定义在类中方法外的类。 定义格式： class 外部类 { class 内部类 { } } 访...
jave内部接口
epmark的博客
11-26 389
java内部接口和内部类类似，是定义在外部类中的接口或者是定义在外部接口中的内部接口。 package innerInterface; /** * * @author Epmark * 学习使用内部接口，包括定义在类中的内部接口和在接口中的内部接口 */ //定义一个外部类,在外部类中定义内部接口 class OuterClass{ //定义一个内部
java匿名内部类的字节码分析
最新发布
09-09
Java匿名内部类是指在定义一个类的同时实例化它的...总结来说，通过分析匿名内部类的字节码，可以了解到匿名内部类的继承关系、访问方式、实例化过程和调用方式，从而深入了解Java中匿名内部类的工作原理和实现机制。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值