Java中的初始化和清理

初始化与清理

构造函数初始化

• 在java类中存在一个默认构造函数，当创建对象的时候会默认调用实现对象的初始化。

public class Demo {

   private int height = 100;

    /**
     *无参构造器（默认构造器） 如果不进行定义则会自动创建
     */
    public Demo(){
         
    }
    
    
    public Demo(int height){
        this.height  = height;
    }

}

注意：在构造函数中被初始化和在类中变量被初始化的顺序是不一样的，当对象被创建的时候，成员变量就会被初始化。而只有当调用具体的构造函数，构造函数的变量才会被初始化成指定的值。并且当构造函数给成员变量赋值的时候，原始的值会被覆盖。
所以，构造函数可以用来创建对象的时候对指定的成员变量进行赋值。

this关键字

• this关键字代表当前方法所在类的对象的引用
• this可以用来在构造器中调用其他构造器 并且需要放在最开始位置只能调用一次

进一步理解static关键字

• static方法不存在this的方法，在static方法中不能调用非静态方法，但是非静态方法中可以调用静态方法

成员初始化

在java中，为了防止程序员忘记对方法中的局部变量赋值，会强制要求程序员对定义的变量赋值来防止这种错误的发生;而对于类的成员变量来说，并不会强制要求程序员进行赋初始值，都会自动赋予默认值。

构造器初始化

• 在类的内部，变量定义的先后顺序决定了初始化的顺序。无论变量是在方法之间或者构造器之间，都不会影响到初始化的顺序。

public class InitSequence {

      Boy boy = new Boy(16);
      public  InitSequence(){
          boy2 = new Boy(15);
      }

      public  InitSequence(int i){


      }

      Boy boy2 = new Boy();


    public static void main(String[] args) {
        InitSequence initSequence = new InitSequence();
    }
}


public class Boy {

    private Integer age;

    public  Boy(){

    }

    public  Boy(int age){
        this.age = age;
        System.out.println("boy's age is "+ age);
    }
}

静态数据的初始化

• 无论创建多少个对象，静态数据都只占用一份存储区域。static关键字不能作用于局部变量，因此它只能作用于域。对于静态区域以及构造函数是何时进行初始化如下所示：

public class StaticInit {

    public static void main(String[] args) {

        System.out.println("================================");
        new Cat();
        System.out.println("================================");
        new Cat();
        dog.spark(2);
        cat.spark(4);
    }

    static  Dog dog = new Dog();
    static  Cat cat = new Cat();
}

public class Animal {

     public  Animal(String name){
         System.out.println("the animal's  name is "+ name);
     }

     void spark(Integer count){
         System.out.println("the animal spark "+count+"times");
     }
}

public class Dog {

     static  Animal animal = new Animal("tiger");

     public Dog(){
         System.out.println("the dog's name is dd");
     }

     void  spark(int count){
         System.out.println("the dog spark"+count+"times");
     }

     static  Animal animal2 = new Animal("tiger2");

}

public class Cat {
    Animal animal3 = new Animal("tiger3");
    static Animal animal4 = new Animal("tiger4");

    Cat() {
        System.out.println("this is a cat");
        animal4.spark(4);
    }

    void spark(int count) {
        System.out.println("this cat spark " + count + "times");
    }

    static Animal animal5 = new Animal("tiger5");
}


结果:

the animal's  name is tiger
the animal's  name is tiger2
the dog's name is dd
the animal's  name is tiger4
the animal's  name is tiger5
the animal's  name is tiger3
this is a cat
the animal spark 4times
================================
the animal's  name is tiger3
this is a cat
the animal spark 4times
================================
the animal's  name is tiger3
this is a cat
the animal spark 4times
the dog spark2times
this cat spark 4times

由此也可以看出，在java中，初始化的顺序是先初始化静态对象，然后初始化非静态对象（构造函数等对象创建方式），并且对于同一个静态对象只会被初始化一次。

• 静态代码块(对于静态代码块，同样和静态对象一样只会被加载一次，并且加载顺序和代码先后顺序有关)

public class StaticBlock {

    private static int number;

    static {
          Dog dog = new Dog();
    }

    public static void main(String[] args) {
          
    }
}

结果：
the animal's  name is tiger
the animal's  name is tiger2
the dog's name is dd

• 非静态实例初始化（用来初始化对象的每一个非静态变量,一般用来初始化非静态对象或者一些静态变量也可以进行初始化）

public class ConstructorBlock {
    {
        System.out.println("这是构造代码块");
    }

    static Dog dog = new Dog();
    static {

        System.out.println("这是静态块");
    }

    public ConstructorBlock(){
        System.out.println("这是构造函数");
    }

    public static void main(String[] args) {
        ConstructorBlock constructorBlock = new ConstructorBlock();
    }
}

结果:
the animal's  name is tiger
the animal's  name is tiger2
the dog's name is dd
这是静态块
这是构造代码块
这是构造函数

总结:在java中，对于静态代码块，静态变量，构造代码块以及构造函数来说，首先执行的是静态代码块和静态变量按代码顺序进行执行，然后会执行构造代码块，最后才会执行构造函数。对于静态代码块，静态变量来说随着类的加载只会被加载一次，而构造代码块和构造函数每一次创建对象的时候都会执行。