一直有个问题想不明白静态代码块和构造代码块以及成员代码块分别在什么时候使用啊？
我理解是静态代码块只在第一次new执行一次，之后不再执行，而构造代码块在每new一次就执行一次。其他的用处怎么讲？？

楼主你好  如果帖子的问题已经解决，请把帖子的类型改为“已解决”。

xscn 发表于 2013-7-20 00:43
静态代码块用来给类进行初始化，随类的加载而执行，优先于主函数执行并且只执行一次。当类中的方法都被静态 ...

额 我记错了 不好意思 是局部代码块

多谢各位了  都挺全面的，看来这些概念性的东西还是要记忆啊  理解了不会用也不行啊

静态代码块：用于给类初始化，类加载时就会被加载执行，只加载一次。
构造代码块：用于给对象初始化的。只要建立对象该部分就会被执行，且优先于构造函数。
构造函数：  给对应对象初始化的，建立对象时，选择相应的构造函数初始化对象。  
创建对象时，三者被加载执行顺序：静态代码块--->构造代码块--->构造函数

构造函数
特点：
函数名与类名相同
不能定义返回值类型
不可以写return语句
作用：
给对象进行初始化
注意：
默认构造函数的特点
多个构造函数是以重载的形式存在的

对象一建立就会调用与之对应的构造函数

构造函数的小细节：
当一个类中没有定义构造函数时，那么系统会默认给该类加入一个空参数的构造函数

当在类中自定义了构造函数后  默认的构造函数就没有了

构造函数和一般函数在写法上有不同

在运行上也有不同
构造函数是在对象一建立就运行，给对象初始化
而一般方法是对象调用才执行，给对象添加对象具备的功能

一个对象建立，构造函数只运行一次
而一般方法可以被该对象调用多次

什么时候定义构造函数？
当分析事物时，该事物存在就具备一些特性或者行为，那么将这些内容定义在构造函数中

构造代码块
class Soug
{
    构造代码块
    作用：给对象进行初始化
    对象一建立就运行，而且优先于构造函数执行
    和构造函数的区别
    构造代码块是给所有对象进行统一初始化
    而构造函数是给对应的对象初始化
    定义对象共性内容
   
    {
      System.out.println("构造代码块")
    }
}
静态代码块
格式：
static
{
  静态代码块中的执行语句
}

特点：随着类的加载而执行，只执行一次
用于给类进行初始化的

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. */
    

复制代码

静态代码块用来给类进行初始化，随类的加载而执行，优先于主函数执行并且只执行一次。当类中的方法都被静态了化，并且构造方法被private了，但是是我们不能在将这个类实例化，然而又想让类增加一些属性，就可以使用静态代码块
构造代码块定义在类中，可以给所有对象进行初始化，只要建立对象就运行优先于构造函数。当类有共同成员变量或共同的方法时，可以通过构造代码块对其进行初始化，就是不同对象共性的初始化方式，这样可以减少代码的重复。
你说的成员代码块是指局部代码块？好像没有成员代码块这个名词，有的话回复下我哦
局部代码块定义在方法中，作用是为了控制变量的生命周期,如我们在程序中已经使用完某个变量，并且在接下来的代码中，不会再用到她,那就没必要在内存中占用空间了，这用情况可以将变量及其所设计到的区域封装为局部代码块，他们在程序执行中顺序不变，只是在执行完成后消失。

楼主只要了解下这些代码块定义的位置和用途还有执行顺序，不难区分的

静态代码块：用于给类初始化，类加载时就会被加载执行，只加载一次。
  构造代码块：用于给对象初始化的。只要建立对象该部分就会被执行，且优先于构造函数。
  构造函数：  给对应对象初始化的，建立对象时，选择相应的构造函数初始化对象。  
   创建对象时，三者被加载执行顺序：静态代码块--->构造代码块--->构造函数
  
//利用代码进行测试 例题：06--06：StaticCodeDemo.java
class Person
{
private String name;
private int age=0;
private static String country="cn";
Person(String name,int age)
{
  this.name=name;
  this.age=age;
}
static
{
  System.out.println("静态代码块被执行");
}
{ System.out.println(name+"..."+age); }
public void setName(String name)
{
  this.name=name;
}
public void speak()
{
  System.out.println(this.name+"..."+this.age);
}
public static void showCountry()
{
  System.out.println("country="+country);
}
}
class StaticDemo
{
static
{
  System.out.println("StaticDemo 静态代码块1");
}
public static void main(String[] args)
{
  Person p=new Person("zhangsan",100);
  p.setName("lisi");
  p.speak();
  Person.showCountry();
}
static
{
  System.out.println("StaticDemo 静态代码块2");
}
}
输出结果：
   StaticDemo 静态代码块1
   StaticDemo 静态代码块2
   静态代码块被执行
   null...0    //构造代码块
   lisi...100  //speak()
   country=cn  //showCountry()