静态代码块，普通代码块，静态构造函数，普通构造函数，成员变量（显示和隐式）执行顺序哪位高手能讲解一下吗？？？？最好能给个代码说明一下啊，求救啊！！！这个弄不明白，我都没法往下看了！！
非常感谢大家，我快被这个执行顺序弄疯了！！！！！

静态代码块是给类初始化的时候执行的，普通代码块是new对象的时候执行到，静态构造函数不可以用，普通构造函数是给对象初始化用的，成员变量的隐式赋值是早于构造函数，原因很简单，如果构造函数先执行了，然后再执行成员变量的隐式赋值，那构造函数的赋值就没有了。至于没有静态构造函数，构造函数是为了将一个类实例化一个对象才需要使用的，进行一些必备的初始化操作（即使你没写任何代码，实际上运行库也帮你添了很多操作）。何为静态，就是全局的，已经初始化过的，静态函数就是指该函数不和具体对象相关，只和类相关，但是构造函数是和对象直接关联的，这两个东西从面向对象的概念上完全不可能融合在一起。运行下我的代码就知道了，

1. package io.demo;
   
2. 
   
3. import java.util.Properties;
   
4. 
   
5. public class SystemDemo {
   
6. 
   
7.         public static void main(String[] args) {
   
8.                 // TODO Auto-generated method stub
   
9.                         Person p=new Person("lisi",33);
   
10.                         p.name="zhangsan";
    
11.         }
    
12. 
    
13. }
    
14. class Person
    
15. {
    
16.        
    
17.         String name;
    
18.         int age;
    
19.         Person(String name,int age)
    
20.         {
    
21.                 System.out.println("构造函数");
    
22.                 this.name=name;
    
23.                 this.age=age;
    
24.         }
    
25.         static
    
26.         {
    
27.                
    
28.                 System.out.println("静态代码块");
    
29.         }
    
30.         {
    
31.                
    
32.                 System.out.println("普通代码块");
    
33.         }
    
34. }
    

复制代码

1. class Person
   
2. {
   
3.         public static String nationality;//国籍 静态成员
   
4.         public String name;//姓名 非静态成员
   
5.         public int age;
   
6.          //静态代码块,用于初始化静态成员，或者要在类生成字节码时加载一些数据
   
7.           //当把这个类加载到内存中时，调用，第一次用需要加载，第二次就不用了，所以只运行一次
   
8.         static{
   
9.                 //-------------1------
   
10.                 nationality="china";//初始化静态成员
    
11.         }
    
12.         //静态构造函数,用于给所有Person的实例进行初始化，就是说当我们常见某个对象的实例时，如果没有指定姓名年龄，它就是张三，18
    
13.         {
    
14.                 //-------------2------
    
15.          name="张三";
    
16.                  age=18;
    
17.         }
    
18.         //显示构造函数，如果没写构造函数，默认隐式的为：public Person(){} 如果写了,隐式的就被覆盖了
    
19.         public Person(String name,int age){
    
20.                 //------------3--------------
    
21.                 this.name=name;
    
22.                 this.age=age;
    
23.         }
    
24.         //如果没有写构造的话，默认的就是它，如果写了它就会被覆盖，所以如果Person p=new Person()这样就找不到无参构造，一般都会加上
    
25.         public Person(){
    
26.                 --------------4--------------
    
27.         }
    
28.        
    
29. }
    
30. class Test
    
31. {
    
32.         //第一次创建对象时，需要将这个类加载到内存
    
33.         Person p1=new Person();//因为是第一次用到Person，需要加载，说以会是 1,2,4
    
34.         Person p2=new Person("王五",34);//因为不是第一次用到Persn,无需加载 ，1不在执行  顺序：2,3
    
35. }
    
36.       

复制代码

静态即表示属于类的，非静态的属于对象。
构造方法没有静态的。成员变量能够被public，private等修饰，当public修饰 时，表示在类外可以被直接
当private修饰时，被封装起来，外部不能直接访问
public class Exam {

        private String name="lisi";        //私有化成员变量，外部调用时，只能采用下边的getName（）方法
        public String age="40";                //公有成员变量，可直接使用对象.age调用
        static void show(){
                System.out.println("属于类的静态show（）");
        }                                                //静态 的，属于类，可以直接Exam.show()
       
        Exam(){
               
        }       //在不写构造函数时，系统默认有一个无参构造方法
        public String getName() {
                return name;
        }
        public void setName(String name) {
                this.name = name;
        }
}
class Test{

        public static void main(String[] args){
                Exam e=new Exam();
                Exam.show();
                System.out.println(e.age);
        }
   
}

public class Demo {
    Demo(){
        System.out.println("构造方法");
    }
    {
        System.out.println("构造代码块");//实例化对象的时候才会去调用！
    }
    static{
        System.out.println("静态代码块");
    }
   
    public static void main(String[] args) {
        new Demo();
        new Demo();//再次创建对象，证明无论创建几次对象，静态代码块都只执行一次
        System.out.println("普通代码块");
    }
}

静态构造函数真心没听过，我也不明白啊，普通构造函数在创建有参的情况下，一般都建一个无参的构造函数。静态代码块只是在JVM加载类时，只执行一次；后面在创建对象new Person();也不会执行了。

1. class Test1
   
2. {
   
3.         /*private static int i=0;
   
4.         public static int aMethod()
   
5.                 {
   
6.                  i++;
   
7.                 return i;
   
8.                 } */
   
9.         public static void main(String[] args)
   
10.         {
    
11.         //Test1 test = new Test1();
    
12.         Demo a = new Demo();
    
13.         System.out.println("__________________");
    
14.         Demo b = new Demo(50);
    
15.         //Test1.aMethod();  
    
16.         //System.out.println(Test1.aMethod());
    
17.         //System.out.println(a.getI());
    
18.         //System.out.println(a.getI());
    
19.         }
    
20. }
    
21. class Demo
    
22. {
    
23.         private int age;
    
24.         public int getI()
    
25.         {
    
26.                 return age;
    
27.         }
    
28.         Demo()
    
29.         {
    
30.                 System.out.println("无参数构造函数");
    
31.         }
    
32.         Demo(int age)
    
33.         {
    
34.                 //if(age < 0 | age > 120)
    
35.                         System.out.println("构造函数代码块");
    
36.                 //else
    
37.                         this.age = age;
    
38.         }
    
39.         static
    
40.         {
    
41.                 System.out.println("静态代码块");       
    
42.         }
    
43.         {
    
44.                 System.out.println("普通代码块");
    
45.         }
    
46. }

复制代码

  运行下就可以了；非静态成员变量在构造函数前出初始化，静态成员变量随着类的加载而加载。