Java代码块应用

代码块引出

有时我们在使用构造方法时，除了进行属性的初始化外还需要使用一些其他的语句，以便更好的实现程序的功能，比如添加一些输出语句；

class Java01{
   public static void main(String args[]){
   //创建对象实例，调用构造方法
   Person person = new Person("小黄",19,'男');
   }
}
class Person{
  private String name;
  private int age;
  private char sex;
  //构造方法重载并进行输出
  public Person(String name){
  this.name = name;
  System.out.println("此构造方法被调用了");
  }
  public Person(String name,int age){
  this.name = name;
  this.age = age;
  System.out.println("此构造方法被调用了");
  }
  public Person(String name,int age,char sex){
  this.name = name;
  this.age = age;
  this.sex = sex;
  System.out.println("此构造方法被调用了");
  }
}
 
   

此代码的运行结果为:

此构造方法被调用了

如上代码使用了构造方法重载，在初始化属性的同时进行了语句的输出。

但是缺点我们可以一眼看出来，就是在构造方法中有多个相同的输出语句,代码显得冗余。

为了加强代码的重用性,我们可以使用代码块进行简化：

public class Java01 {
    public static void main(String margs[]){
        //创建对象实例，进行构造方法和代码块的调用
        Person person = new Person("小黄",19,'男');
    }
}
class Person{
    private String name;
    private int age;
    private char sex;
    //使用普通代码块
    {
       System.out.printin("此构造方法被调用了“);
    }
    public Person(){}
    public Person(String name){
        this.name = name;
    }
    public Person(String name,int age){
        this.name = name;
        this.age = age;
    }
    public Person(String name,int age,char sex){
        this.name = name;
        this.age = age;
        this.sex = sex;
    }
}

如上代码把相同的输出语句 抽取到代码块中，提高了代码的重用性。

运行结果相同。 

代码块语法

语法结构：

(static){
//代码块语句；
}（；）

1：修饰符，可选，有的话只能是static；

（加了static的叫静态代码块，没有static的叫非静态代码块）

2：括号里也可以加任何逻辑控制语句；

3：末尾的分号可以写，也可以不写；

4：代码块相当于构造方法的补充，所以也可以进行初始化。

代码块调用顺序

1：先调用静态代码块初始化；

（如果有多个静态代码块，则按它们的定义顺序调用）

2：然后调用普通代码块初始化；

（如果有多个普通代码块，则按它们定义的顺序调用）

3：最后调用构造方法进行初始化；

总结：调用优先级：静态代码块>普通代码块>构造方法。

代码示例：

public class Java01 {
    public static void main(String margs[]){
        Person person = new Person("小黄",19,'男');
    }
}
class Person{
    private String name;
    private int age;
    private char sex;
    public Person(){}
    public Person(String name){
        this.name = name;
    }
    public Person(String name,int age){
        this.name = name;
        this.age = age;
    }
    //在构造方法中进行输出
    public Person(String name,int age,char sex){
        this.name = name;
        this.age = age;
        this.sex = sex;
        System.out.println("此构造方法被调用了。");
    }
    //使用静态代码块
    static{
        System.out.println("此静态代码块被调用了。");
    }
    //使用普通代码块
    {
        System.out.println("此普通代码块被调用了。");
    }
}

输出结果：

此静态代码块被调用了。
此普通代码块被调用了。
此构造方法被调用了。

代码块调用次数

1：静态代码块：静态代码块随着类的加载被执行，只会被执行一次；

2：普通代码块每创建一个对象就执行一次；

补充——类的加载时间：

@  创建对象实例时；

@  使用类的静态成员时；

@  创建子类对象实例时会先加载父类；

代码示例：

public class Java01 {
    public static void main(String margs[]){
        //创建两个对象实例
        Person person = new Person("小黄",19,'男');
        Person person1 = new Person("小红",19,'女');
        //使用静态变量输出
        System.out.println(person.toString() + " 电话号码：" + Person.call);
    }
}
class Person{
    private String name;
    private int age;
    private char sex;
    static int call;
    public Person(){}
    public Person(String name){
        this.name = name;
    }
    public Person(String name,int age){
        this.name = name;
        this.age = age;
    }
    public Person(String name,int age,char sex){
        this.name = name;
        this.age = age;
        this.sex = sex;
        System.out.println("此构造方法被调用了。");
    }
    static{
        System.out.println("此静态代码块被调用了。");
    }
    {
        System.out.println("此普通代码块被调用了。");
    }
    public String toString(){
        return "姓名：" + name + " 年龄：" + age + " 性别：" + sex;
    }
}

输出结果：

此静态代码块被调用了。
此普通代码块被调用了。
此构造方法被调用了。
此普通代码块被调用了。
此构造方法被调用了。
姓名：小黄 年龄：19 性别：男 电话号码：0

由以上代码可知：重复new同一个类的对象，或者使用同一个类的静态变量，main方法都只会进行一次类加载，因此静态代码块只会执行一次；

但是普通代码块不受类加载的限制，每new一次对象实例就会执行一次。

总结：静态代码块和普通代码块的区别：

	修饰符	执行顺序	执行次数
静态代码块	static	优先执行	随着类加载执行一次
普通代码块	无	在静态代码块之后执行	每创建一个对象就执行一次

补充

1：代码块又称初始化块，属于类中的成员（类的一部分），类似于方法，将逻辑语句封装在方法体中，通过{}包围起来；

2：代码块和方法不同，但可以看成构造方法的补充，没有方法名，没有返回值，没有参数，只有方法体，而且不用通过对象和类显式调用，而是加载类时或创建对象时隐式调用；