牛客网Java刷题知识点之代码块（局部代码快、构造代码块、静态代码块）

　　不多说，直接上干货！

代码块包括局部代码快、构造代码块、静态代码块。

　　代码块，就是一段独立的代码空间。

1、局部代码快
　　对局部变量的生命周期进行控制。

2、构造代码块
　　对所有对象进行初始化。

3、静态代码块
　　对类进行初始化。

1、什么是局部代码快

 　　是在函数中的代码块。

 　　如

  public void show(){         
       //局部代码块   
        {  
            int i=55;  
        }  
        System.out.println("上边是局部代码块");  
  } 

 2、什么是构造代码块

 　　构造对象的代码块。

　　创建几个对象，就调用几次。

　　构造代码块的作用就是：给所有对象进行相同部分的初始化。

　　而我们的构造方法是对对应的对象进行有针对性的独特的初始化。

class Person{  
        private String name;

　　//构造代码块
    { 
        System.out.println("Person类的第一个代码块被执行");  
    }  


    Person(){  
        System.out.println("无参数构造函数被执行");  
        this.name = "小宝宝";  
    }  
    Person(String name){  
        System.out.println("有name参数构造函数被执行");  
        this.name = name;  
    }  
    public void speak(){  
        System.out.println("名字："+name);  
    }  
}  
  
class ConBlockTest{  
    public static void main(String[] args){  
        Person p1 = new Person();  
        p1.speak();  
        Person p2 = new Person("小科比");  
        p2.speak();  
    }  
}  

 　　结果是

　　我们很显然就看到了在我们创建两个对象时，该代码块都被执行了，而构造函数只是当创建对应对象时被调用。

　　所以构造代码块的作用就是：给所有对象进行相同部分的初始化。

　　而我们的构造方法是对对应的对象进行有针对性的独特的初始化。

　　那么构造代码块的构造函数哪个先执行呢？我们看代码：

class Person  {  
    private String name;  
  
    {//第一个构造代码块  
        System.out.println("Person类的第1个代码块被执行");  
    }  
  
    Person()  {  
        System.out.println("无参数构造函数被执行");  
        this.name = "小宝宝";  
    }  
    Person(String name)  {  
        System.out.println("有name参数构造函数被执行");  
        this.name = name;  
    }  
    public void speak()  {  
        System.out.println("名字："+name);  
    }  
  
    {//第二个构造代码块  
        System.out.println("Person类的第2个代码块被执行");  
    }  
}  

　　结果是，

　　

　　我们看到两个不同位置的构造代码块都在构造函数被执行之前就已经执行了，所以说构造代码块优先于构造函数执行。

 　　所以，当我们需要把所有对象都有相同的初始化时，我们可以使用构造代码块来实现，比如上面的例子中，人一出生都会哭，那么我们就可以用构造代码块来初始哭这个功能：

class Person{  
    private String name;  
    {  
        cry();  
    }  
    Person(){  
        this.name = "小宝宝";  
    }  
    Person(String name){  
        this.name = name;  
    }  
    public void cry(){  
        System.out.println("哇哇");  
    }  
    public void speak(){  
        System.out.println("名字："+name);  
    }  
}  

　　这样我们就把所有对象哭的功能封装到了一个构造代码块中，在创新对象是会优先执行，很好的实现了我们想要的功能。

 

3、什么是静态代码块呢？

　　说白了，就是用static关键字修饰的代码块。

class StaticBlock  {  
    static  {  
        System.out.println("静态代码块被执行");  
    }  
    
    void myPrint()  {  
        System.out.println("myPrint方法执行");  
    }  
}  
  
class StaticBlockTest{  
    public static void main(String[] args){  
        new StaticBlock().myPrint();  
    }  
}  

　　运行结果是，

　　从结果我们看到了我们调用的myPrint函数被调用执行了，并且在此函数被调用之前，静态代码块就已经被执行。

　　这就是我们要说的特别之处，静态代码块是特殊的代码块，它被static关键字修饰，并且拥有静态的所有特征，最主要的是它有一个比较自然独特的特点：我们之前说，静态随着类的加载而加载，而静态代码块随着着类的加载而执行，只要类被加载，那么该静态代码块就会被执行，并且只执行一次。

 　　再来，

class StaticBlock{  
    static{  
        System.out.println("静态代码块被执行");  
    }  
    
    void myPrint(){  
        System.out.println("myPrint方法执行");  
    }  
}  
  
class StaticBlockTest{  
    public static void main(String[] args){  
        new StaticBlock().myPrint();  
        new StaticBlock().myPrint();  
    }  
}  

 　　结果是，

　　我们看到，静态代码块只执行了一次，而我们的myPrint方法被调用了两次执行了两次。所以当类加载时，静态方法就已经加载并且执行一次。

　　通过上面的例子让我们明确了静态代码块的实际作用：用于给类进行初始化。

　　这就相当于我们之前学习的构造函数，构造函数是用于给对象进行初始化，而静态代码块是用来给类进行初始化。

　　这里我们也许会有疑问，既然构造函数能够进行初始化，那么我们为什么还要用静态代码块来初始化呢，其实不是所有的类都能创建对象，因为有些类有可能不需要被创建对象的，比如我们在一个类中定义的全部是静态成员，那么创建对象就没有意义。

 　　我们再看一个静态代码块的用法，我们看下面的代码：

class StaticBlock{  
    static int num;  
    static  {  
        num = 10;  
        num = num * 3;  
    }  
    void myPrint(){  
        System.out.println("num = "+num);  
    }  
}  
  
class StaticBlockTest{  
    public static void main(String[] args){  
        new StaticBlock().myPrint();  
    }  
}  

 　　结果是

　　从结果我们直接可以看到，我们在静态代码块中对静态变量进行了多次运算和赋值，所以当我们需要对静态变量进行多次运算时我们可以运用静态代码块。

　　不过这个在开发中用的并不多，在一些底层的框架开发中会专门用到。

 

总结

　　静态代码块，然后如果有对象，构造代码块执行，再构造函数。

静态代码块：
　　特点：1、随着类的加载而执行。
　　　　    2、只执行一次。
　　作用：用于给类初始化(有的类不用构造函数，而需要初始化)。
构造代码块： 在类中的代码块
　　特点：1、在创建对象时执行，每创建一个对象，就执行一次。
　　　　    2、在创建对象时执行,在静态代码块后执行，且在构造函数前执行。
　　作用：可以给所有的对象进行初始化。
局部代码块： 在函数中的代码块
　　作用：限定函数中的局部变量的生命周期。

class StructureCode  {  
    private String name;  
    static int num;  
    //构造代码块
    {  
        System.out.println("我是构造代码块");  
        cry();   //没创建一个对象就执行一次cry(),代替下边两个构造函数中的cry()  
    }  
    //静态代码块
    static  
    {  
        num=10;  
        num*=num;  
        System.out.println("我是静态代码块");  
    }  
    StructureCode()  
    {  
        name="baby";  
        System.out.println("我是构造函数");  
        // cry();  
    }  
    StructureCode(String name) //构造函数是给对应的对象初始化  
    {  
        this.name=name;  
        System.out.println("我是构造函数");  
        // cry();  
    }  
    private void cry()  
    {  
        System.out.println("哇哇");  
    }  
    public void show()  
    {         
        //局部代码块</span>    
        {  
            int i=55;  
        }  
        System.out.println("上边是局部代码块");  
    }  
}  
  
class StaticDemo1{  
    public static void main(String args [])  {  
        StructureCode structureCode = new StructureCode("小强");  
    }  
}