java反射中，Class.forName和classloader的区别(代码说话)

原文：http://blog.csdn.net/qq_27093465/article/details/52262340

java中class.forName()和classLoader都可用来对类进行加载。
class.forName()前者除了将类的.class文件加载到jvm中之外，还会对类进行解释，执行类中的static块。
而classLoader只干一件事情，就是将.class文件加载到jvm中，不会执行static中的内容,只有在newInstance才会去执行static块。
Class.forName(name, initialize, loader)带参函数也可控制是否加载static块。并且只有调用了newInstance()方法采用调用构造函数，创建类的对象

看下Class.forName()源码

[java]  view plain  copy

1. //Class.forName(String className)  这是1.8的源码  
2.    public static Class<?> forName(String className) throws ClassNotFoundException {  
3.        Class<?> caller = Reflection.getCallerClass();  
4.        return forName0(className, true, ClassLoader.getClassLoader(caller), caller);  
5.    }  
6. //注意第二个参数，是指Class被loading后是不是必须被初始化。 不初始化就是不执行static的代码即静态代码  

然后就是，测试代码证明上面的结论是OK的，如下：

[java]  view plain  copy

1. package com.lxk.Reflect;  
2.   
3. /** 
4.  * Created by lxk on 2017/2/21 
5.  */  
6. public class Line {  
7.     static {  
8.         System.out.println("静态代码块执行：loading line");  
9.     }  
10. }  

[java]  view plain  copy

1. package com.lxk.Reflect;  
2.   
3. /** 
4.  * Created by lxk on 2017/2/21 
5.  */  
6. public class Point {  
7.     static {  
8.         System.out.println("静态代码块执行：loading point");  
9.     }  
10. }  

[java]  view plain  copy

1. package com.lxk.Reflect;  
2.   
3. /** 
4.  * Class.forName和classloader的区别 
5.  * <p> 
6.  * Created by lxk on 2017/2/21 
7.  */  
8. public class ClassloaderAndForNameTest {  
9.     public static void main(String[] args) {  
10.         String wholeNameLine = "com.lxk.Reflect.Line";  
11.         String wholeNamePoint = "com.lxk.Reflect.Point";  
12.         System.out.println("下面是测试Classloader的效果");  
13.         testClassloader(wholeNameLine, wholeNamePoint);  
14.         System.out.println("----------------------------------");  
15.         System.out.println("下面是测试Class.forName的效果");  
16.         testForName(wholeNameLine, wholeNamePoint);  
17.   
18.     }  
19.   
20.     /** 
21.      * classloader 
22.      */  
23.     private static void testClassloader(String wholeNameLine, String wholeNamePoint) {  
24.         Class<?> line;  
25.         Class<?> point;  
26.         ClassLoader loader = ClassLoader.getSystemClassLoader();  
27.         try {  
28.             line = loader.loadClass(wholeNameLine);  
29.             point = loader.loadClass(wholeNamePoint);  
30.             //demo = ClassloaderAndForNameTest.class.getClassLoader().loadClass(wholeNamePoint);//这个也是可以的  
31.             System.out.println("line   " + line.getName());  
32.             System.out.println("point   " + point.getName());  
33.         } catch (ClassNotFoundException e) {  
34.             e.printStackTrace();  
35.         }  
36.     }  
37.   
38.     /** 
39.      * Class.forName 
40.      */  
41.     private static void testForName(String wholeNameLine, String wholeNamePoint) {  
42.   
43.         try {  
44.             Class line = Class.forName(wholeNameLine);  
45.             Class point = Class.forName(wholeNamePoint);  
46.             System.out.println("line   " + line.getName());  
47.             System.out.println("point   " + point.getName());  
48.         } catch (Exception e) {  
49.             e.printStackTrace();  
50.         }  
51.     }  
52.   
53.   
54. }  

执行结果如下：

备注：

根据运行结果，可以看到，classloader并没有执行静态代码块，如开头的理论所说。

而下面的Class.forName则是夹在完之后，就里面执行了静态代码块，可以看到，2个类，line和point的静态代码块执行结果是一起的，然后才是各自的打印结果。

也说明上面理论是OK的。

更新于2017/06/20

因为看到有小伙伴有疑问，我就把自己以前的代码拿出来再次测试一遍，发现结果仍然是相同的。

但是，因为我的Javabean model又经历了其他的测试，所以，两个model内部的代码稍有变化，

然后，还真就测试出来了不一样的地方。

这估计是其他理论所没有的。具体看下面的代码吧。

只是修改了Line的代码，添加了几个静态的方法和变量。

[java]  view plain  copy

1. package com.lxk.reflect;  
2.   
3. /** 
4.  * Created by lxk on 2017/2/21 
5.  */  
6. public class Line {  
7.     static {  
8.         System.out.println("静态代码块执行：loading line");  
9.     }  
10.   
11.     public static String s = getString();  
12.   
13.     private static String getString() {  
14.         System.out.println("给静态变量赋值的静态方法执行：loading line");  
15.         return "ss";  
16.     }  
17.   
18.     public static void test() {  
19.         System.out.println("普通静态方法执行：loading line");  
20.     }  
21.   
22.     {  
23.         System.out.println("要是普通的代码块呢？");  
24.     }  
25.   
26.     public Line() {  
27.         System.out.println("构造方法执行");  
28.     }  
29. }  

可以看到，除了原来的简单的一个静态代码块以外，我又添加了构造方法，静态方法，以及静态变量，且，静态变量被一个静态方法赋值。

然后，看执行结果。

稍有不同。

除了，静态代码块的执行外，竟然还有一个静态方法被执行，就是给静态变量赋值的静态方法被执行了。

这个估计是以前没人发现的吧。

所以

上面的结论，就可以进一步的修改啦。

也许，这个执行的也叫，static块呢。

好吧，

我为什么会测试这个呢，是因为有一次，有遇到说，类加载的问题，详情看下面链接。

Java类的各种成员初始化顺序如：父子类继承时的静态代码块,普通代码块,静态方法,构造方法,等先后顺序

这个也是值得看一看的。