乐趣区

关于java:一些Java中不为人知的特殊方法学完后面试官可能都没你知道的多

如果你用过反射并且执行过 getDeclaredMethods 办法的话,你可能会感到很吃惊。你会发现呈现了很多源代码里没有的办法。如果你看一下这些办法的修饰符的话,可能会发现外面有些办法是 volatile 的。顺便说一句,如果在 Java 面试里问到“什么是 volatile 办法?”,你可能会吓出一身冷汗。正确的答案是没有 volatile 办法。但同时,getDeclaredMethods() 或者 getMethods() 返回的这些办法,Modifier.isVolatile(method.getModifiers()) 的后果却是 true。

一些用户遇到过这样的问题。他们发现,应用 immutator(这个我的项目摸索了 Java 的一些鲜为人知的细节)生成的 Java 代码应用 volatile 了作为办法的关键字,而这样的代码没法通过编译。后果就是这基本没法用。

这是怎么回事?syntethic 和 bridge 办法又是什么?

可见性

当你创立一个嵌套类的时候,它的公有变量和办法对下层的类是可见的。这个在不可变嵌套式 Builder 模式中用到了。这是 Java 语言标准里曾经定义好的一个行为。

package synthetic;

public class SyntheticMethodTest1 {private A aObj = new A();

    public class A {private int i;}

    private class B {private int i = aObj.i;}

    public static void main(String[] args) {SyntheticMethodTest1 me = new SyntheticMethodTest1();
        me.aObj.i = 1;
        B bObj = me.new B();
        System.out.println(bObj.i);
    }
}

JVM 是如何解决这个的?它可不晓得什么是外部类或者嵌套类的。JVM 对所有的类都厚此薄彼,它都认为是顶级类。所有类都会被编译成顶级类,而那些外部类编译完后会生成…$… class 的类文件。

$ ls -Fart
../                         SyntheticMethodTest2$A.class  MyClass.java  SyntheticMethodTest4.java  SyntheticMethodTest2.java
SyntheticMethodTest2.class  SyntheticMethodTest3.java     ./            MyClassSon.java            SyntheticMethodTest1.java

如果你创立一个外部类的话,它会被彻底编译成一个顶级类。

那这些公有变量又是如何被外部类拜访的呢?如果它们是个顶级类的公有变量(它们确实也是),那为什么别的类还能间接拜访这些变量?

javac 是这样解决这个问题的,对于任何 private 的字段,办法或者构造函数,如果它们也被其它顶层类所应用,就会生成一个 synthetic 办法。这些 synthetic 办法是用来拜访最后的公有变量 / 办法 / 构造函数的。这些办法的生成也很智能:只有的确被外部类用到了,才会生成这样的办法。

package synthetic;

import java.lang.reflect.Constructor;
import java.lang.reflect.Method;

public class SyntheticMethodTest2 {

    public static class A {private A(){}
        private int x;
        private void x(){};
    }

    public static void main(String[] args) {A a = new A();
        a.x = 2;
        a.x();
        System.out.println(a.x);
        for (Method m : A.class.getDeclaredMethods()) {System.out.println(String.format("%08X", m.getModifiers()) + " " + m.getName());
        }
        System.out.println("--------------------------");
        for (Method m : A.class.getMethods()) {System.out.println(String.format("%08X", m.getModifiers()) + "" + m.getReturnType().getSimpleName() +" " + m.getName());
        }
        System.out.println("--------------------------");
        for(Constructor<?> c : A.class.getDeclaredConstructors() ){System.out.println(String.format("%08X", c.getModifiers()) + " " + c.getName());
        }
    }
}

这些生成的办法的名字取决于具体的实现,最初叫什么也不好说。我只能说在我运行的这个平台上,上述程序的输入是这样的:

2
00001008 access$1
00001008 access$2
00001008 access$3
00000002 x
--------------------------
00000111 void wait
00000011 void wait
00000011 void wait
00000001 boolean equals
00000001 String toString
00000101 int hashCode
00000111 Class getClass
00000111 void notify
00000111 void notifyAll
--------------------------
00000002 synthetic.SyntheticMethodTest2$A
00001000 synthetic.SyntheticMethodTest2$A

在下面这个程序中,咱们给变量 x 赋值,而后又调用了一个同名的办法。这会触发编译器生成对应的 synthetic 办法。你会看到它生成了三个办法,应该是 x 变量的 setter 和 getter 办法,以及 x() 办法对应的一个 synthetic 办法。这些办法并不存在于 getMethods 办法里返回的列表中,因为它们是 synthetic 办法,是不能间接被调用的。从这点来看,它们和公有办法差不多。

看一下 java.lang.reflect.Modifier 外面定义的常量,能够明确这些十六进制的数字代表的是什么:

00001008 SYNTHETIC|STATIC
00000002 PRIVATE
00000111 NATIVE|FINAL|PUBLIC
00000011 FINAL|PUBLIC
00000001 PUBLIC
00001000 SYNTHETIC

列表中有两个是构造方法。还有一个公有办法以及一个 synthetic 办法。存在这个公有办法是因为咱们的确定义了它。而 synthetic 办法的呈现是因为咱们从外部类调用了它外部的公有成员。到目前为止,还没有呈现过 bridge 办法。

泛型和继承

到目前为止,看起来还不错。不过咱们还没有看到”volatile”办法。

看一下 java.lang.reflect.Modifier 的源码你会发现 0x00000040 这个常量被定义了两次。一次是定义成 VOLATILE,还有一次是 BRIDGE(后者是包外部公有的,并不对外开放)。

想呈现 volatile 办法的话,写个简略的程序就行了:

package synthetic;

import java.lang.reflect.Method;
import java.util.LinkedList;

public class SyntheticMethodTest3 {

    public static class MyLink extends LinkedList {
        @Override
        public String get(int i) {return "";}
    }

    public static void main(String[] args) {for (Method m : MyLink.class.getDeclaredMethods()) {System.out.println(String.format("%08X", m.getModifiers()) + "" + m.getReturnType().getSimpleName() +" " + m.getName());
        }
    }
}

这个链表有一个返回 String 的 get(int) 办法。先别探讨代码整不整洁的问题了。这只是段示例代码而已。整洁的代码当然也会呈现同样的问题,不过越简单的代码越难定位问题罢了。

输入的后果是这样的:

00000001 String get
00001041 Object get

这里有两个 get 办法。一个是代码里的那个,另外一个是 synthetic 和 bridge 办法。用 javap 反编译后会是这样的:

public java.lang.String get(int);
  Code:
   Stack=1, Locals=2, Args_size=2
   0:   ldc     #2; //String
   2:   areturn
  LineNumberTable:
   line 12: 0

public java.lang.Object get(int);
  Code:
   Stack=2, Locals=2, Args_size=2
   0:   aload_0
   1:   iload_1
   2:   invokevirtual   #3; //Method get:(I)Ljava/lang/String;
   5:   areturn

乏味的是,两个办法的签名是截然不同的,只有返回类型不同。这个在 JVM 外面是非法的,不过在 Java 语言里可不容许。bridge 的这个办法不干别的,就只是去调用了下原始的那个办法。

为什么咱们须要这个 synthetic 办法呢,谁会调用它?比方当初有段代码想要调用一个非 MyLink 类型变量的 get(int) 办法:

List<?> a = new MyLink();
        Object z = a.get(0);

它不能调用返回 String 的办法,因为 List 里没这样的办法。为了解释的更分明一点,咱们重写下 add 办法而不是 get 办法:

package synthetic;

import java.util.LinkedList;
import java.util.List;

public class SyntheticMethodTest4 {

    public static class MyLink extends LinkedList {
        @Override
        public boolean add(String s) {return true;}
    }

    public static void main(String[] args) {List a = new MyLink();
        a.add("");
        a.add(13);
    }
}

咱们会发现这个 bridge 办法

public boolean add(java.lang.Object);
  Code:
   Stack=2, Locals=2, Args_size=2
   0:   aload_0
   1:   aload_1
   2:   checkcast       #2; //class java/lang/String
   5:   invokevirtual   #3; //Method add:(Ljava/lang/String;)Z
   8:   ireturn

它不仅调用了原始的办法,它还进行了类型查看。这个查看是在运行时进行的,并不是由 JVM 本人来实现。正如你所想,在 18 行的中央会抛出一个异样:

Exception in thread "main" java.lang.ClassCastException: java.lang.Integer cannot be cast to java.lang.String
    at synthetic.SyntheticMethodTest4$MyLink.add(SyntheticMethodTest4.java:1)
    at synthetic.SyntheticMethodTest4.main(SyntheticMethodTest4.java:18)

下次如果你在面试中被问到 volatile 办法的话,说不定面试官晓得的还没你多:-) 私信”学习“有惊喜

退出移动版