今天看了下静态初始化的帖子，有些疑问？
class StaticDemo {
        public static void main(String[] args) {
               
                Demo1 d = Demo1.getInstance();

                System.out.println(d.count1+"......."+d.count2);
        }

}
class Demo1{
            private static Demo1 d = new Demo1();
        public static int count1=5;
        public static int count2=6;
        private Demo1(){
                System.out.println(count1+"...构造函数前..."+count2);
                count1++;
                count2++;
                System.out.println(count1+"...构造函数后..."+count2);
        }
               
        static{
                System.out.println(count1+"...静态代码块前..."+count2);
                count1++;
                count2++;
                System.out.println(count1+"...静态代码块后..."+count2);
        }
        private static Demo1 h = new Demo1();
        
        public static Demo1 getInstance(){               
                                return d ;
        }
}
结果为
0...构造函数前...0
1...构造函数后...1
5...静态代码块前...6
6...静态代码块后...7
6...构造函数前...7
7...构造函数后...8
7.......8



为什么创建对象位置不同，初始化方式也不同？

今天这是神马情况，这么多问静态的，jvm加载的时候对静态的顺序有关系

1. /*
   
2. Java静态变量初始化遵循以下规则:
   
3. 静态变量会按照声明的顺序先依次声明并设置为该类型的默认值,但不赋值为初始化的值.
   
4. 声明完毕后,再按声明的顺序依次设置为初始化的值,如果没有初始化的值就跳过.
   
5. */
   
6. class StaticDemo {
   
7.         public static void main(String[] args) {
   
8.                
   
9.                 Demo1 d = Demo1.getInstance();
   
10. 
    
11.                 System.out.println(d.count1+"......."+d.count2);
    
12.         }
    
13. 
    
14. }
    
15. class Demo1{
    
16.         //private static Demo1 d = new Demo1();  
    
17.                 /*在此处，new Demo1,有规则知，内存在还没有对count1，count2初始化，所以默认值为0；
    
18.                         所以:打印：
    
19.                         0...构造函数前...0
    
20.                         1...构造函数后...1
    
21.                 接着初始化count1和count2为5和6
    
22.                 执行static
    
23.                 {
    
24.                 }中的代码打印出
    
25.                         5...静态代码块前...6
    
26.                         6...静态代码块后...7
    
27.                 然后在执行new Demo1  打印出
    
28.                         6...构造函数前...7
    
29.                         7...构造函数后...8
    
30.                 最后执行main函数中的getInstance()并打印得到结果：
    
31.                         7.......8
    
32. 
    
33.                 */
    
34.         public static int count1=5;
    
35.         public static int count2=6;
    
36.                 //private static Demo1 d = new Demo1();
    
37.                 /*
    
38.                 初始化语句在此处
    
39.                 此时：
    
40.                 count1 count2先初始化 为5 和 6
    
41.                 然后 d 初始化
    
42.                         5...构造函数前...6
    
43.                         6...构造函数后...7
    
44.                 执行static区代码
    
45.                         6...静态代码块前...7
    
46.                         7...静态代码块后...8
    
47.                 h初始化
    
48.                         7...构造函数前...8
    
49.                         8...构造函数后...9
    
50.                 最后main方法中的代码执行
    
51.                         8.......9
    
52.                 */
    
53.                
    
54.         private Demo1(){
    
55.                 System.out.println(count1+"...构造函数前..."+count2);
    
56.                 count1++;
    
57.                 count2++;
    
58.                 System.out.println(count1+"...构造函数后..."+count2);
    
59.         }
    
60.                
    
61.         static{
    
62.                 System.out.println(count1+"...静态代码块前..."+count2);
    
63.                 count1++;
    
64.                 count2++;
    
65.                 System.out.println(count1+"...静态代码块后..."+count2);
    
66.         }
    
67.         private static Demo1 h = new Demo1();
    
68.         
    
69.         public static Demo1 getInstance(){               
    
70.                                 return d ;
    
71.         }
    
72. }

复制代码

你试着看分析其他情况，希望能帮到你。

jvm加载静态的时候，有多个跟静态有关的变量，对象，静态代码块时，是按代码的顺序执行的。对象创建在前，就先初始化静态对象，并调用构造函数。在后面就后初始化。

感谢啊{:soso_e113:}，继续奋斗啊