静态代码块具有什么特点？它与构造代码块有什么不同？两者在程序中哪个先运行？为什么？

静态代码块：
    static
           {
         执行语句；
      }

构造代码块：
      {
               执行语句；
      }

静态代码 块 随着类加载 就 加载了 ，如同女娲造人
构造代码块 只能是 随着调用对象 才加载  如同人出现了以后 给自己做衣服

类里面的方法运行次序是：静态代码块，静态函数，代码块，构造函数。
其实你可以去试：
public class test
{
        public static void main(String[] args)
        {
                ManthTest.test1();
                ManthTest MT=new ManthTest();
               
        }
}
class ManthTest{
        ManthTest(){
                System.out.println("构造函数");
        }
        {
                System.out.println("代码块");
        }
        static{
                System.out.println("静态代码块");
        }
        public static void test1(){
                System.out.println("静态函数");
        }
}

静态代码块具有什么特点？它与构造代码块有什么不同？两者在程序中哪个先运行？为什么？

静态代码块的特点：随着类的加载而执行，只执行一次，并优先于主函数执行。用于给类进行初始化的。

区别：
1.静态代码（被static修饰，没有其他的名字）块给类初始化；
如：
static
{
        System.out.pringln(“hello”);
}
2.构造代码块给对象初始化，对象一建立就运行，而且优先于构造函数执行。
代码块定义的是一段对象所共有的特性的初始化java代码，而且不论这段代码定义在类中的什么地方
（作为一段独立块，不能嵌套在别的方法（函数）中），都首先执行这段代码。
比如人都有共同的相貌特征，那么在定义人的时候就可以将这些共同特性定义在代码块中。

说到哪个先运行的问题，在静态代码块的特点中，有“优先于主函数执行”这一句，而且构造代码块是给对象初始化的，
先new一个对象之后才有对对象的初始化，所以，综述，静态代码块先执行。

1. class A{
   
2.         public static int num=0;
   
3.         static{
   
4.                 System.out.println("静态代码执行");
   
5.         }
   
6.         A(){
   
7.                 System.out.println("构造方法执行");
   
8.                
   
9.         }
   
10. }
    
11. class B extends A{
    
12.        
    
13. }
    
14. public class Test {
    
15. public static void main(String[] args) throws ClassNotFoundException {
    
16.           // A a= new A();//创建对象时候，类初始化静态代码执行
    
17.              //int v= A.num;//访问类静态方法，类初始化静态代码执行
    
18.                                                  //  访问类静态方法也是一样
    
19.                  // new B();//创建子类对象时初始化父类，类初始化静态代码执行；
    
20.                  // Class.forName("com.day11.A");//动态加载在类初始化阶段静态代码执行
    
21.                   
    
22. 
    
23.         }
    
24. 
    
25. }

复制代码

静态代码块在类初始化时候执行；类的初始化时机：
创建类实例，此时加载字节码初始化类就会先初始化静态代码块；
调用某个类静态方法访问某类静态属性或接口，初始化化某类子类以及Class.forName()等都会先初始化静态代码里的内容。

1. class Test
   
2. {
   
3.         Test()
   
4.         {
   
5.                 //空参数构造函数
   
6.                 System.out.println("b");
   
7.         }
   
8.         static
   
9.         {
   
10.                 //静态代码块
    
11.                 System.out.println("a");
    
12.         }
    
13.         {
    
14.                 //构造代码块
    
15.                 System.out.println("c");
    
16.         }
    
17.         Test(int x)
    
18.         {
    
19.                 //带参数的构造函数
    
20.                 System.out.println(x);
    
21.         }
    
22. 
    
23.         public static void main(String[] args)
    
24.         {
    
25.                 //创建一个带参数的构造函数
    
26.                 Test t = new Test(4);
    
27.         }
    
28. }

复制代码

运行结果是： a c 4  
静态代码块是给类初始化的，类一加载就运行，优先于构造代码块。
构造代码块是给所有对象统一初始化的，优先于构造函数。
构造函数是给指定对象初始化的。

忘了结果了（附上）：

看看这里的情况是什么样的：null
静态代码块运行了
中国
谭磊
tanlei

public class Person {

        static{
                System.out.println("看看这里的情况是什么样的："+Person.country);//这里的时候还是  null。
                // name =  "谭磊";  此行会报错。
                country = "中国";
                System.out.println("静态代码块运行了");
                System.out.println(Person.country); //可以正常运行的
        }
        private String name;
        public static String country;
        Person(String name){
                this.name = name;               
        }
        {
                name = "谭磊";
                System.out.println(name);
        }
        public static void main(String[] args) {
               
                System.out.println(new Person("tanlei").name);
        }
       
}
自己看看运行的各个状态，学习中有疑问的时候可以先自己打印 状态语句 来 揣测下的。

放大了，或者下载之后看吧，效果不太好，主要右边一侧的小字是我总结的。

静态代码块是类的初始化动作，类一加载他就执行了，而构造代码块是构造实例时的初始化，对象不创建是不执行的；具体的我推荐你阅读thinking in java chapter4,

直接把我的笔记贴上来了，这是我研究了很久才搞定的，一大串流程我也说不出来，这个顺序反正挺啰嗦的，也不知道实战时有没有用处。