synthetic Java合成类型

版权声明:本文为博主原创文章,未经博主允许不得转载。 https://blog.csdn.net/a327369238/article/details/52608805

Synthetic

  看Class源码的时候,看到有个关键字Synthetic以及isSynthetic()方法,遂有兴趣查阅了一番。
  一开始以为,就是复合类型(引用类型),也就是非基本类型,可后来看到Java语言规范的描述(以及写代码测试),才知道不是,但看了许久,也不知道具体:

Any constructs introduced by a Java compiler that do not have a 
corresponding construct in the source code must be marked as 
synthetic, except for default constructors, the class initialization 
method, and the values and valueOf methods of the Enum class.
我的翻译:那些由Java编译器引入,并且在源代码中没有相应构造方法的结构体则被认为是合成
的,(被引入的代码)除了默认的构造器、类初始化方法(<init>();)以及枚举类型的
values/valueOf方法。

  对于synthetic好理解:Java编译器引入的字段(内部非静态类就具有一个指向父类的synthetic字段)、方法(泛型的桥方法以及拥有内部类并且内部类引用了外部类字段或方法都会产生相应的synthetic方法)或类。但对于synthetic类就不是很懂,我的理解是,某些类由编译器引入,这种类就是合成类型,但不知道有没有这种情况,这种情况又是什么种情况下。
  开始以为动态代理类是,但是写代码测试了下,不是,后来想想也是,代理类的生成在运行期,当然肯定不是编译器引入;再猜测匿名内部类可能是,写代码测试,通过反编译,发现生成的一个匿名类,确实有非默认构造器,觉得应该是,但结果还是不是。

interface AA{
    void eat();
}
class A {
    public AA aa = new AA() {
        @Override
        public void eat() {
            System.out.println("name = "+this.getClass().getName()+ " : " + this.getClass().isSynthetic());
        }
    };
}
//编译后得匿名类字节代码
class A$1 implements AA {
    A$1(A var1) {
        this.this$0 = var1;
    }
    public void eat() {
        "name = "+this.getClass().getName()+ " : " + this.getClass().isSynthetic()
    }
}
A a = new A();
a.aa.eat();//打印结果如下
name = com.fcc.test.A$1 : false

  这才想了想,匿名内部类只有构造器那部分是由编译器引入,另外还是有相当一部分是在源码中的,所以应该也不算是完全由编译器引入的类。
  后来又想从Class的isSynthetic()方法实现来看,getModifies()是获得修饰符对应的内部int值,又查看Modifier类,虽然有synthetic关键字,说明确实是修饰词,但是,不管是字段、方法还是类的修饰都不包括synthetic,所以猜测这一套机制并没有在Java源码中,而在编译器,在Java语言(规范)中,这一猜想也从以下代码测试获得:

public class Main {
    private String h = "hello";
    private class B {
        private B(){
            System.out.println(h);//访问外部类私有字段,会生成一个方法,这句话实现:
            //System.out.println(Main.access$000(var1));
        }
    }
    public void test(){       
        System.out.println("B : " + B.class.isSynthetic());
    }
    public static void main(String[] args) throws Exception
    {
        Main main = new Main();
        main.test();
        Class m = Class.forName("com.fcc.test.Main");
        Method[] methods = m.getDeclaredMethods();
        for(Method method : methods){
            if(method.isSynthetic()){
                System.out.println("name = " + method.getName());
            }
        }
    }
}
//输出结果
B : false
name = access$000

再之后不甘心,又查阅一番,终于找到了一个靠谱的:
http://www.progtown.com/topic127108-classissynthetic.html

public class Main {

    private static class Inner {
    }
    static void checkSynthetic (String name) {
        try {
            System.out.println (name + " : " + Class.forName (name).isSynthetic ());
        } catch (ClassNotFoundException exc) {
            exc.printStackTrace (System.out);
        }
    }
    public static void main(String[] args) throws Exception
    {
        new Inner ();
        checkSynthetic ("com.fcc.test.Main");
        checkSynthetic ("com.fcc.test.Main$Inner");
        checkSynthetic ("com.fcc.test.Main$1");
    }
}
//打印结果:
com.fcc.test.Main : false
com.fcc.test.Main$Inner : false
com.fcc.test.Main$1 : true
//编译结果,生成三个class文件: Main.class/Main$inner/Main$1.class
// $FF: synthetic class
class Main$1 {
}

  看到运行结果后,感觉真是6不行,接着就想为什么?Main$inner有意料之中,但Main$1哪里来的?我想了很久,只知道这个类是怎么出来的,大概出来是为了什么,但具体的实现也没搞明白。
  看代码,有很突兀和很关键的一句:new inner(); 就是这句话生成了Main$1类。
  随后,跟着疑问来了?这句话怎么会生成Main$1类呢?new inner();不是有inner类吗?不是Main$inner这个类的对象吗?
  要理解这其中的原理首先要明白:Java对于每一个类都是看作顶层类的,哪怕所谓的嵌套类(内部类)编译后都会生成一个单独类文件,这也是为什么会生成Main$inner的原理,也就是说,编译后,内外部两个类表面上其实就没啥关系了(但是内部非静态类只有外部类可以访问,这种权限认定不知道怎么实现的),然后Main$1是怎么回事呢?
  这里眼亮的可能看到了:inner这个内部类是私有的,私有内部类。前面知道,拥有内部类的类编译后内外部类两者没有关系,那么私有内部类编译后默认是没有对外构造器的(如果以上代码中在Inner手动给一个public的构造器,Main$1是不会出现的),但是我们又知道,外部类是可以引用内部类的,那么编译后,又是两个毫无关系的类,一个类没对外构造器,但另一个类确实是有对这个类的实例对象权限(这里就是重点,内部类哪怕没有public构造器,外部类都有实例化内部类对象的权限)的,这种情况下编译器就会生成一个合成类,也就是Main$1,一个什么也没有的空类(是的,什么也没有,连构造器都没有)。
  但到这里,仍然不明白其实现原理是怎么样的,原先以为合成类是那个内部类的副本,外部类访问内部类,在编译器认为只是和合成类交互,只是合成类只有外部类有权限访问,但是事实上,不管内部类怎么变化,合成类只是一个空的类,有点类似标记作用(真正作用却是不得而知)。

总结

synthetic总的来说,是由编译器引入的字段、方法、类或其他结构,主要用于JVM内部使用,为了遵循某些规范而作的一些小技巧从而绕过这些规范,有点作弊的感觉,只不过是由编译器光明正大的,人为是没有权限的(但事实上有时候还是能被利用到的)。

展开阅读全文

没有更多推荐了,返回首页