听毕老师说，静态代码块是用来初始化类的，怎么初始化类啊？请给我举个例子吧，谢谢啦。

1. class Person1
   
2. {
   
3.         public Person1()
   
4.         {
   
5.                 System.out.println("1.public.Person");
   
6.         }
   
7.         //此段代码首先被执行
   
8.         static {
   
9.                 System.out.println("2.Person类的态代码块被调用");
   
10.         }
    
11. }
    
12. public class TestStaticDemo {
    
13.         //运行本程序时，静态代码块会被自动执行
    
14.        
    
15.         static
    
16.         {
    
17.                 System.out.println("3.TestStaticDemo类的静态代码块被调用");
    
18.         }
    
19.         public static void main(String[] args) {
    
20.                
    
21.                 System.out.println("4.程序开始执行");
    
22.                
    
23.                 //产生两个实例化对象
    
24.                 new Person1();
    
25.                
    
26.                 new Person1();
    
27. 
    
28.         }
    
29. 
    
30. }

复制代码

一个类可以使用不包含在任何方法体中的静态代码块，当类被加载时，静态代码块被执行，且执行一次。静态代码块经常用来进行类属性的初始化。得知，静态代码块可以对静态属性初始化

静态代码: 只有 程序应用到类的数据的时候 ,即 只要类被加载到内存中个 静态代码就会被执行   
构造代码快:主要是在 创建对象的时候  首先被调用 优先于构造函数.
对象的初始化顺序:首先执行父类静态的内容，父类静态的内容执行完毕后，接着去执行子类的静态的内容，当子类的静态内容执行完毕之后，再去看父类有没有非静态代码块，如果有就执行父类的非静态代码块，父类的非静态代码块执行完毕，接着执行父类的构造方法；父类的构造方法执行完毕之后，它接着去看子类有没有非静态代码块，如果有就执行子类的非静态代码块。子类的非静态代码块执行完毕再去执行子类的构造方法。总之一句话，静态代码块内容先执行，接着执行父类非静态代码块和构造方法，然后执行子类非静态代码块和构造方法。
子类的构造方法，不管这个构造方法带不带参数，默认的它都会先去寻找父类的不带参数的构造方法。如果父类没有不带参数的构造方法，那么子类必须用supper关键子来调用父类带参数的构造方法，否则编译不能通过。
说白了，静态代码块就是用来对一个类的属性进行初始话用的，如果说你想要对类中某个属性进行初始化，那么你就可以用静态代码快。

1. 
   
2. <P>class Test01
   
3. {
   
4.         public static void main(String[] args)
   
5.         {
   
6.                 new StaticDemo();//无参构造
   
7. 
   
8.                 new StaticDemo("hello");//有参
   
9.         }
   
10. }
    
11. 
    
12. 
    
13. class StaticDemo
    
14. {
    
15.         {
    
16.                 System.out.println("构造代码块");//有两次构造故：第三和第五行行输出结果。构造代码块，new一个对象，执行一次。
    
17.         }
    
18.         public StaticDemo()
    
19.         {
    
20.                 System.out.println("无参构造方法");//第四行输出结果
    
21.         }
    
22.         public StaticDemo(String msg)
    
23.         {
    
24.                 System.out.println("有参构造方法");//第五行输出结果
    
25.         }
    
26. 
    
27.         static
    
28.         {
    
29.                 System.out.println("静态代码块2");//第一行输出结果。静态代码块优先于主函数执行，随着类的加载而执行一次
    
30.         }
    
31. 
    
32.         static
    
33.         {
    
34.                 System.out.println("静态代码块1");//第二行输出结果。如果有多个静态代码块，则按顺序执行
    
35.         }
    
36. }
    
37. 
    

复制代码

静态代码块   
格式：static {  静态代码块中的执行语句 }用于修饰成员变量和成员函数。
静态代码块的特点：随着类的加载而执行，只执行一次。并优先于主函数执行，不需要调用主函数，直接执行。
静态代码块给类初始化的，构造代码块给对象初始化的，构造函数给对应对象初始化的

静态代码块中所使用的成员也必须是静态的。
对于静态代码块它是用来描述类的相关信息。
对于比较消耗资源，然后加载一次就可以使用内容。放到静态代码块中。
对于程序在启动时需要优先加载的内容，也可以放入到静态代码块中。

1. class StaticDemo {
   
2. static{
   
3. System.out.println("第一执行");
   
4. }
   
5. public static void main(String[] args) {
   
6. Static s = new Static();
   
7. }
   
8. static{
   
9. System.out.println("第二执行");
   
10. }
    
11. }
    
12. class Static{
    
13. static{
    
14. System.out.println("第三执行");
    
15. }
    
16. {
    
17. System.out.println("第四执行");
    
18. }
    
19. Static(){
    
20. System.out.println("第五执行");
    
21. }
    
22. }
    

复制代码

关于静态代码块的使用，一楼已经说得很清楚，我再提供一个例子吧，方便理解，静态代码块格式：
static{
                  静态代码块中的执行语句；
}
在程序中执行顺序是：静态代码块---构造代码块---构造函数
本例中“第一执行”和“第二执行”都是静态代码块，优先于主函数执行，且按在程序中的顺序执行；
“第三执行”是Static类中的静态代码块，因为在主函数中创建了一个Static的类，当访问Static类时即执行此静态代码块，只执行一次；
“第四执行”是Static类中构造代码块，主函数中没创建一次对象就执行一次，次于Static中的静态代码块执行，但优先于Static中构造函数执行；
“第五执行”是Static类中构造函数，本例中最后执行
以上，希望有所帮助！

静态代码块

在java类中，可以将某一块代码声明为静态的。
static {
//静态代码块中的语句
}
静态代码块主要用于类的初始化。它只执行一次，并在main函数之前执行。

静态代码块的特点主要有：

静态代码块会在类被加载时自动执行。
静态代码块只能定义在类里面，不能定义在方法里面。
静态代码块里的变量都是局部变量，只在块内有效。
一个类中可以定义多个静态代码块，按顺序执行。
静态代码块只能访问类的静态成员，而不允许访问实例成员
给你看个简单的例子首先看一下的一个静态块代码（参考java的类装载机制）
//静态块:模拟生成内存中的用户数据，用户名为user1-10
//当程序启动时，这段代码（静态块中的）会自动执行，向userDB中存入数据
static  {  for(int i=0;i<10;i++)  
{
  UserInfo user=new UserInfo();

  user.setName("user"+i);

  user.setPassword("pwd"+i);

userDB.put(user.getName(), user);  

}

}
  “静态块”中代码的特点是：
在这个类被装载时就会执行，且只执行一次。这意味着“静态块”会先于属性初始化执行，当其他的对象调用Daotools中的方法千，UsuerDB中就已经保存入预设的数据。