请问构造代码块、构造函数以及静态代码块之间的区别，求详细解答？

构造代码块：
        (1)作用：给对象进行初始化，对象一建立就执行，而且优先于构造函数执行
        (2)构造代码块和构造函数的区别：
                构造代码块是给所有不同对象的共性进行统一初始化
                构造函数是给对应的对象进行初始化
构造函数：
        (1)特点：
                方法名与类名相同
                没有返回类型
                没有返回值
        (2)作用：构造函数是用于创建对象，并对其进行初始化赋值，对象一建立就自动调用相对应的构造函数，
        (3)构造方法的注意事项:
                A:如果一个自定义类没有构造方法，系统会默认给出一个无参构造方法。
                B:如果一个自定义类提供了构造方法，那么，系统将不再给出无参构造方法。
                  这个时候，你可以不使用无参构造方法。
                  如果你想使用，那么，就必须手动给出无参构造方法。

                建议：一般情况下，我们的自定义类都要手动给出无参构造方法。
        (4)构造方法和成员方法的区别
                A:格式区别
                        构造方法和类名相同，并且没有返回类型，也没有返回值。
                        普通成员方法可以任意起名，必须有返回类型，可以没有返回值。
                B:作用区别
                        构造方法用于创建对象，并进行初始化值。
                        普通成员方法是用于完成特定功能的。
                C:调用区别
                        构造方法是在创建对象时被调用的，一个对象建立，只调用一次相应构造函数
                        普通成员方法是由创建好的对象调用，可以调用多次
静态代码块
                A:它只执行一次，它比main还先执行。
                B:执行顺序
                        静态代码块--构造代码块--构造方法

构造函数：函数名与类名相同，只在创建本类对象时调用一次，且仅一次。
静态代码块：定义在类内的代码块，用static标识，本类加载时调用一次。
构造代码块不太理解。。sry

这3个的运行的时机不一样

当用户第一次调用构造函数的时候,
1.静态构造代码块先执行
2.然后构造代码块再执行
3.最后构造函数运行

静态代码块,只会运行一次,就是在加载类时候,类不会重复加载.
构造函数和构造代码块,每次用户new时,都会运行.

楼主你好：

1,静态代码块、构造代码块、构造函数.区别？
------静态代码块：
当编译时，.class字节码文件就加载到了内存，主函数所属的类先加载到内存，所以静态代码块先被执行，当主函数中创建person对象时
这时person类的字节码文件也加载到内存中，然后初始化Person类。
(特点：随着类的加载而执行，只执行一次,并优先于主函数。
用于给类进行初始化的。)
------构造代码块：
作用：  给对象进行初始化。
对象一建立就运行，而且优先于构造函数执行。
和构造函数的区别：
构造代码块是给所有对象进行统一初始化，
而构造函数是给对应的对象初始化。
        
构造代码块中定义的是不同对象的共性初始化内容。
------构造函数：
构造函数和一般函数在写法上有不同。
在运行上也有不同。
构造函数是在对象一建立就运行。给对象初始化。
而一般方法是对象调用才执行，是给对象添加对象具备的功能。
一个对象建立，构造函数只运行一次。
而一般方法可以被该对象调用多次。
什么时候定义构造函数呢？
当分析事物时，该事物存在具备一些特性或者行为，那么将这些内容定义在构造函数中。

静态代码块也称类初始化块，负责对类进行初始化，随类的加载而加载，所以比构造代码块，构造函数先执行。

构造代码块，是从构造函数中抽出来的，比如两个构造函数中有相同的代码块，就可以把这相同的代码块抽出来，
单独存在，这就是构造代码块，好处可以使程序变得简洁。
构造代码块会在每次调用构造函数之前被隐式执行，所以构造代码块比构造函数先执行。

构造函数是对实例对象的初始化。

袁梦希 发表于 2013-4-26 21:29
楼主你好：

1,静态代码块、构造代码块、构造函数.区别？

精辟.......
这个贴可以修改为以解决了

可以根据下面这段代码的运行结果，得到它们的执行先后顺序等的区别：

1. /*
   
2. 构造代码块：用于初始化对象，只要对象建立就自动立即初始化，优先于构造函数
   
3. 构造函数：用于初始化对象，对象建立后，可以选择其中一个构造函数
   
4. 静态代码块：用于初始化类，类加载时执行，且只一次
   
5. */
   
6. class Person{
   
7.         String name;
   
8.         int age;
   
9.         static String country;
   
10.        
    
11.         {
    
12.                 System.out.print("This is a person.");
    
13.                 System.out.println("这是构造代码块");
    
14.                 }
    
15.        
    
16.         static{
    
17.                 country = "China";
    
18.                 System.out.println("这是静态代码块");
    
19.                 }
    
20.        
    
21.         Person(String name){
    
22.                 this.name = name;
    
23.                 System.out.println("使用第一个构造函数");
    
24.                 }
    
25.        
    
26.         Person(String name, int age){
    
27.                 this.name = name;
    
28.                 this.age = age;
    
29.                 System.out.println("使用第二个构造函数");
    
30.                 }
    
31.         }
    
32. 
    
33. class PersonDemo{
    
34.         public static void main(String[] args){
    
35.                 Person p1 = new Person("aa");
    
36.                 System.out.println("p1：name=" + p1.name + ", age=" + p1.age +
    
37.                                                    ", country="+Person.country);
    
38. 
    
39.                 Person p2 = new Person("aa",22);                                               
    
40.                 System.out.println("p2:name=" + p2.name + ", age=" + p2.age +
    
41.                                                    ", country="+Person.country);
    
42.                 }
    
43.         }

复制代码

构造代码块：给所有的对象统一初始化；  
构造函数：给对应的对象初始化；
静态代码块：随着类的加载而执行，只执行一次，用于给类初始化的
它们的执行顺序也是有区别的：静态代码块>构造代码块>构造函数