加载是在什么时期加载的呢？编译时期就加载了还是运行时再加载？静态方法随着类的加载而加载，先于对象，下面程序当A类加载时，成员变量a和成员函数show也会加载，那么当程序运行时刻，A.show()调用时，a=new A()这个初始化什么时候执行呢？
class A
{
       static A a=new A();
       public static A show()
      {
       return a;
      }
}
class B
{
       public static void main(String[] args)
      {
          A a=A.show();
      }
}

1. 
   
2. public class Test4 {
   
3. 
   
4. /**
   
5. 
   
6. * @param args
   
7. 
   
8. */
   
9. 
   
10. private static A a1 = new A(1);
    
11. 
    
12. private final F f = new F();
    
13. 
    
14. private B b = new B();
    
15. 
    
16. static{
    
17. a1=new A(3);
    
18. a2=new A(4);
    
19. a3=new A(5);
    
20. System.out.println("c");
    
21. 
    
22. }
    
23. private static A a2 = new A(2);
    
24. private static A a3;
    
25. public Test4(){
    
26. 
    
27. System.out.println("Test");
    
28. 
    
29. }
    
30. 
    
31. public static void main(String[] args) {
    
32. 
    
33. Test4 t = new Test4();
    
34.   
    
35. }
    
36. }
    
37. class A{
    
38. 
    
39. public A(int i){
    
40. 
    
41. System.out.println("A"+i);
    
42. 
    
43. }
    
44. 
    
45. }
    
46. 
    
47. class B{
    
48. 
    
49. public B(){
    
50. 
    
51. System.out.println("B");
    
52. 
    
53. }
    
54. 
    
55. }
    
56. 
    
57. class F{
    
58. 
    
59. public F(){
    
60. 
    
61. System.out.println("F");
    
62. 
    
63. }
    
64. 
    
65. }
    

复制代码

看看，这个可以直接编译运行
这种情况一直不明白怎么回事，在论坛上求解的时候没有一个符合的

类在用的时候才加载，也就是建立对象，调用函数时才加载

1 编译是将java程序编译为jvm可执行代码（是一个翻译的过程，并不会执行程序，就像对于老外写的文章（这个就相当于.java的文件）我们看不懂，就让人翻译为我们看得懂的汉字(就相当于.class)。）。
2 运行：编译器把java程序翻译为java字节码后，这个时候的工作就有解释器来完成，也就是所说的运行，解释器在执行过程中他会分为3步：代码的装入 代码的校验 代码的执行。而你问的关于类的加载其实就是解释器执行过程中的第一步.
3  当调用A.show()时，这个时候就开始加载A 类了，也就是按照加载类的规则进行加载，而你的这个a刚好是静态的所以会被第一时间加载，这就是为什么类名能够调用静态变量的原因。

以前记得static代码块貌似是Java类加载过程中优先级最高的，但是最近几天写代码发现不是这样的，因为static变量的优先级要比static代码块高得多，所以因此我犯了不少错误，下面以一个例子来说明一下一个类初始化为对象的时候的加载过程：

1. package day0508;
   
2. public class Test4 {
   
3. /**
   
4. * @param args
   
5. */
   
6. private static A a = new A();
   
7. private final F f = new F();
   
8. private B b = new B();
   
9. static{
   
10. System.out.println("c");
    
11. }
    
12. public Test4(){
    
13. System.out.println("Test");
    
14. }
    
15. public static void main(String[] args) {
    
16. Test t = new Test();
    
17. try {
    
18. Class.forName("day0508.Test4");
    
19. } catch (ClassNotFoundException e) {
    
20. // TODO: handle exception
    
21. e.printStackTrace();
    
22. }
    
23. }
    
24. class A{
    
25. public A(){
    
26. System.out.println("A");
    
27. }
    
28. }
    
29. class B{
    
30. public B(){
    
31. System.out.println("B");
    
32. }
    
33. }
    
34. class F{
    
35. public F(){
    
36. System.out.println("F");
    
37. }
    
38. }
    
39. }
    

复制代码

直接运行Test t = new test();这句话，运行结果为
A  F  c  B  Test 所以是先static变量，然后是static的代码块，然后才是普通变量，最后是构造函数
如果是运行Class.forName()函数的话，运行结果为
A  F  c 还是这样，先是static变量，然后才是static代码块，所以那种对于class.Forname加载类，只调用static代码块的误区要克服，因为还有一个static代码块在等着你，呵呵，我得记录下来以示警戒。