静态代码块  构造代码块  构造函数  对于初学者的总是让我搞混淆， 求大神来个比较直观的例子 比较容易记住的窍门

1. 
   
2. /*
   
3. 
   
4. 
   
5. 区别：
   
6. 
   
7. 1、静态代码块：它是随着类的的加载而执行，类一加载,静态代码块就会执行，并且只执行一次
   
8. 2、构造代码块：是用于给对象进行初始化，对象一建立，构造代码块就会运行
   
9. 3、成员代码块：是类对象在调用的类的方法的时候，才会执行。
   
10. 4、所以静态代码块比构造代码块先执行，构造代码块比构造函数先执行，构造函数比成员代码块先执行；
    
11. 
    
12. */
    
13. 
    
14. 
    
15. 
    
16. class StaticCode{
    
17. int num=1;
    
18. 
    
19. //建立构造函数
    
20. StaticCode(){
    
21.   System.out.println("third");
    
22. }
    
23. 
    
24. //建立静态代码块
    
25. static{
    
26.   System.out.println("first");
    
27. }
    
28. 
    
29. //建立构造代码块
    
30. {
    
31.   System.out.println("second");
    
32. }
    
33. 
    
34. //建立一个show()方法
    
35. public static void show(){
    
36.   System.out.println("show  run");
    
37. }
    
38. }
    
39. class Demo1{
    
40. public static void main(String[] args){
    
41. StaticCode sc= new StaticCode();
    
42.   System.out.println("调用成员了……");
    
43.   sc.show();
    
44. }
    
45. }
    
46. 
    
47. /*
    
48. 输出结果：
    
49. first
    
50. second
    
51. third
    
52. 调用成员了……
    
53. show  run
    
54. 
    
55. 
    
56. 从输出结果看到：先是静态代码块，然后是构造代码块，然后是构造函数，最后才是类的成员函数。从new一个对象
    
57. 可以看出，对象一建立，就迅速执行了这些程序。
    
58. 
    
59. */
    

复制代码

class A
{
        //静态代码块，
        static
        {
                System.out.println("这是类A中的静态代码块");
        }
       
        //        构造代码块
        {
                System.out.println("这是类A中的构造代码块");
        }
       
        // 无参构造函数
        public A()
        {
                System.out.println("这是A类的构造函数");
        }

        // 带有形参的构造函数
        public A( int a)
        {
                System.out.println("这是A类的构造函数"+" a="+a);
        }
       
        //定义A类中一个普通的方法show()
        public void show()
        {
                System.out.println("这是A类中的show方法");
        }

        //定义A类中一个静态的方法static_show()
        public static void static_show()
        {
                System.out.println("这是A类中的static_show方法");
        }
}

class  Test2
{
        static
        {
                System.out.println("这是主函数中的静态代码块");
        }

        {
                System.out.println("这是主函数中的构造代码块");
        }

        public static void main(String[] args)
        {
                System.out.println("------main 函数开始执行-------");
                new A();
                System.out.println("---------------");
                A a=new A(3);
                System.out.println("---------------");
                A.static_show();
                a.show();
               
        }
}


解释：先执行了主函数中的静态代码块，然后主函数中的main函数再执行，主函数中的main中是new A（） 这句话，先执行Ａ中的静态代码块，然后执行构造代码块，在执行了Ａ的构造函数，可是当执行A a =new A();时候，却没有再执行静态代码块，而是直接执行了构造代码块，和构造函数，这就说明，静态代码块 随着类的加载而执行，只执行一次,并优先于主函数。

这是我自己改编的一个小程序，你可以看看，希望对你理解这几个问题有帮助。

//静态代码块，如下代码是以类关键字代码形式写的
        static
        {

        }
//构造函数，方法名于函数名是一致的
class A
{              
        // 无参构造函数
       A()
        {
               
        }