本篇内容主要讲解“Java中不为人知的特殊方法是什么”，感兴趣的朋友不妨来看看。本文介绍的方法操作简单快捷，实用性强。下面就让小编来带大家学习“Java中不为人知的特殊方法是什么”吧!

10年积累的成都网站制作、成都网站设计、外贸营销网站建设经验，可以快速应对客户对网站的新想法和需求。提供各种问题对应的解决方案。让选择我们的客户得到更好、更有力的网络服务。我虽然不认识你，你也不认识我。但先做网站后付款的网站建设流程，更有安吉免费网站建设让你可以放心的选择与我们合作。

可见性

当你创建一个嵌套类的时候，它的私有变量和方法对上层的类是可见的。这个在不可变嵌套式Builder模式中用到了。这是Java语言规范里已经定义好的一个行为。

package synthetic;
//java框架www.1b23.compublic 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;
//java框架www.1b23.compublic 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());
        }
    }
}

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

200001008 access$100001008 access$200001008 access$300000002 x
--------------------------00000111 void wait00000011 void wait00000011 void wait00000001 boolean equals00000001 String toString00000101 int hashCode00000111 Class getClass00000111 void notify00000111 void notifyAll
--------------------------00000002 synthetic.SyntheticMethodTest2$A00001000 synthetic.SyntheticMethodTest2$A

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

看一下java.lang.reflect.Modifier里面定义的常量，可以明白这些十六进制的数字代表的是什么：

00001008 SYNTHETIC|STATIC00000002 PRIVATE00000111 NATIVE|FINAL|PUBLIC00000011 FINAL|PUBLIC00000001 PUBLIC00001000 SYNTHETIC

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

泛型和继承

到目前为止，看起来还不错。不过我们还没有看到”volatile”方法。

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

想出现volatile方法的话，写个简单的程序就行了：

package synthetic;import java.lang.reflect.Method;import java.util.LinkedList;
//java框架www.1b23.compublic class SyntheticMethodTest3 {public static class MyLink extends LinkedList {@Overridepublic 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 get00001041 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: 0public 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 {@Overridepublic 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)

到此，相信大家对“Java中不为人知的特殊方法是什么”有了更深的了解，不妨来实际操作一番吧！这里是创新互联网站，更多相关内容可以进入相关频道进行查询，关注我们，继续学习！

标题名称：Java中不为人知的特殊方法是什么
标题链接：http://azwzsj.com/article/pgdgdh.html