构造代码块,静态代码块,构造函数, 这三个是谁先执行,谁后执行,还有他们一般在开发中都会在什么地方用到,或者说可能会起到什么作用?

         静态代码块首先执行，它是随着类的加载而执行，只执行一次，并优先于主函数；（用于给类初始化的）;
         构造代码块：随着对象的加载而加载；给对象初始化，并且优先于构造函数执行;
         构造函数：构造函数是在对象一建立就运行，给对应到对象初始化；
  

(1)
        静态代码块：
        格式：
        static
        {
                静态代码块中的执行语句；
        }
        特点：随着类的加载而执行，只执行一次，并优先于主函数；（用于给类初始化的）;
(2)
        构造代码块：
        格式：
        {
                构造代码块的执行语句；
        }
        特点：随着对象的加载而加载；给对象初始化，并且优先于构造函数执行;
(3)
        构造函数：
        格式：
        类名（参数）  //参数可有可无；
        {
                 构造函数的执行语句；
        }
        特点：构造函数是在对象一建立就运行，给对应到对象初始化；
        与一般函数有区别：一个对象的建立，构造函数只运行一次，
        而一般函数可以被该对象调用多次；
(4)
        优先级：静态代码块（优先于对象存在，给类初始化）>构造代码块（给所有对象初始化）>构造函数（给对应对象初始化）

        当类中的对象都具有一些共性内容时可以使用静态代码块，
        如person类中，国籍都是CN。
        
        当对象一产生就会有一个固定的动作就使用构造代码块，
        如person类中，小孩一被创建就会哭
        
        当事物具备一些特性或者行为，那么将这些内容定义在构造函数中，给对应的对象初始化，
        如person类中，小孩的姓名。

class Demo
{
        static String name;
        //方法名跟类名相同，称之为构造函数,这个你肯定熟悉：new Demo();后面的Demo()可以理解为构造函数，就是在你new对象的时候执行一次。
        //构造函数也可以重载，如：
        Demo(String name)
        {
                this.name = name;
        }
        Demo()
        {
        }
        //静态代码块，静态代码块是最先执行的，同时，如果类中有静态代码块，那么静态所涉及到的属性和方法也一定要是静态，否则会编译失败。因为他是先于对象存在的。
        public static void demo()
        {
                name = "abc";
        }
        //构造代码块,在每次new对象时候首先执行一次，如果有多个，就依次执行完，再执行构造函数
        {
                name = "abc";
        }
}

总体来说执行优先级:
   静态代码块>构造代码块>构造函数
-------------------------------------------------------------------------
static代码块与构造代码块的比较:
1：构造代码块必然是在对象实体建立时才会运行，即进行new操作的时候。
2：静态代码块只需要在类被加载时就运行。
3：无论什么情况，静态代码块总是优先于构造代码块运行。

测试代码：
class Person
{
        {
                System.out.println("b");
        }

        static
        {
                System.out.println("a");
        }
        
        static void show()
        {
                System.out.println("show run");
        }
}

class Run
{
        public static void main(String [] x)
        {
                //Person.show();
                //Person p = new Person();
                Person p = null;
        }
}
---------------------------------------------
概念：

构造代码块:

用于给所有对象初始化，并且优先于构造函数运行。可以用于共性初始化。

static代码块:

什么是静态代码块？

Class StaticCode

{

   static

{

  S.o.p(“haha”)；

}

}

特点：

1：随着类的加载而加载

2：只运行一次

3：优先于主函数执行

4：用于初始化类

5：静态代码块只能访问静态成员。

:构造函数:
特点：
_函数名和类名相同
_不用定义返回值
_不能写return语句
PS：当类中没有定义构造函数时，类会自动生成一个空参数的构造函数，若定义了便不会。

作用：
_对对象进行初始化。
_不同构造函数对应不同的对象进行初始化，重载。
_若没有对应的构造函数，对象无法创建。

与一般函数的不同：格式/运行
格式：写法不同。
运行：
_构造函数是在对象建立时候就运行，并且初始化对象,构造函数只运行1次，
_一般函数是对象调用才执行，是给对象增加功能,一般方法可以运行多次

构造函数可以被私有化，私有化的构造函数无法创建与之对应对象，若所有构造函数都私有化了，那么这个类无法创建对象。

静态代码块的特点：随着类的加载而执行，只执行一次。用于给类进行初始化的。
构造代码块和构造函数：作用是给对象进行初始化，对象一建立就运行，而且优先于构造函数执行；
                                 构造代码块和构造函数的区别是构造代码块是给所有对象进行统一初始化，而构造函数时给对应的对象初始化。
                                 构造代码块中定义的是不同对象共性的初始化内容。示例代码：

1. class Person
   
2. {
   
3.         private int age;
   
4.         private String name;
   
5.         //定义静态代码块
   
6.         static  
   
7.     {  
   
8.         System.out.println("a");  
   
9.     }
   
10.         //定义构造代码块
    
11.         {
    
12.                 System.out.println("构造代码块run...");
    
13.         }
    
14.         Person()
    
15.         {
    
16.                 System.out.println("空构造函数...");
    
17.         }
    
18.         Person(int n,String a)
    
19.         {
    
20.                 this.age = n;
    
21.                 this.name = a;
    
22.                 System.out.println("name = "+name+", age = "+age);
    
23.         }
    
24. }
    
25. class TestPerson
    
26. {
    
27.         static  
    
28.     {  
    
29.         System.out.println("b");  
    
30.     }
    
31.         public static void main(String[] args)
    
32.         {
    
33.                 new Person();
    
34.                 new Person(15,"lili");
    
35.         }
    
36.     static  
    
37.     {  
    
38.         System.out.println("c");  
    
39.     }
    
40. }

复制代码

从结果可以看出：三者的执行顺序是静态代码块（属于类，只加载一次）>构造代码块>构造函数
至于三者什么时候用，你可以看看三者的特点，根据实际情况选择到底怎么用。。。

执行顺序:首先静态代码块(不论对象多少,只执行一次) , 其次构造代码块(有多少对象就执行多少次) , 再次构造函数(有多少对象就执行多少次).
至于开发中的应用 ,就不知道了,还没学到那个程度.
测试代码:

1. class ABC
   
2. {
   
3.         //静态代码块
   
4.         static
   
5.         {
   
6.         System.out.println("ABC类，静态代码块");
   
7.         }
   
8.         //构造代码块
   
9.         {
   
10.         System.out.println("ABC类，构造代码块");
    
11.         }
    
12.         //构造函数
    
13.         ABC()
    
14.         {
    
15.           System.out.println("ABC类，构造函数");
    
16.         }
    
17.         //静态代码块
    
18.         static
    
19.         {
    
20.         System.out.println("ABC类，静态代码块##");
    
21.         }
    
22. }
    
23. 
    
24. class Demo
    
25. {
    
26.         public static void main(String[] args)
    
27.         {
    
28.                 //用于测试三种代码块的执行顺序
    
29.                 ABC abc = new ABC();
    
30.                 ABC abc1 = new ABC();
    
31.                 ABC abc2= new ABC();
    
32. 
    
33.         }
    
34. }

复制代码