007—JAVA中的类的初始化和实例初始化

类的初始化;
*       作用：给类中的静态成员变量赋值
*       内容：
*           1：静态成员变量显示赋值语句
*           2：静态代码内容
*       注意：
*           类的初始化 会执行一个方法<clinit>将
*               1：静态成员变量显示赋值语句
*              2：静态代码内容、
*          合并到此方法内。
*      即当<clinit>方法执行完毕之后  类的初始化就完毕了

        在进行类的初始化的时候永远只有一个<clinit>中执行
*
*      执行顺序看书写顺序： 从上到下依次执行
*
*      知道使用到类中资源  就会触发类的实例化

 

public class Person {

    static {
        System.out.println("静态代码块一");
    }
    static String name = "张三";
    static int age = 30;
    static {
        System.out.println("静态代码块二");
    }
    public static void show(){
        System.out.println("this is show()");
    }

    public static void main(String[] args) {

    }

}

 

public class Test {
    public static void main(String[] args) {
//        Person.show();
//        System.out.println(Person.name);
    }
}

 1.有继承关系时 调用子类的资源 会导致父类进行初始化

2.在进行子父类初始化时 使用的是一个<clinit> 进行初始化操作

3.类的初始化 只会执行一次

4.类的初始化滞后？ 使用子类调用了从父类继承的静态资源。 只会导致父类初始化 不会导致子类初始化

 子类可以继承父类的静态方法但是不能被重写

 

public class Person {
    static {
        System.out.println("person静态代码块一");
    }
    static int age = setAge();

    private static int setAge() {
        System.out.println("Person setAge 执行了。。。");
        return 0;
    }
    static {
        System.out.println("person静态代码块二");
    }

    public static void showMessage(){
        System.out.println("this is showMessage");
    }
}

public class Student extends Person{
    static {
        System.out.println("Student静态代码块一");
    }
    static int age =setAge();

    public static int setAge(){
        System.out.println("student setAge()");
        return 0;
    }

    static {
        System.out.println("Student静态代码块二");
    }

    public static void show(){
        System.out.println("student show()");
    }



}

public class Test {
    public static void main(String[] args) {
        /*Student.show();
        System.out.println("-----------");
        Student.show();*/

        Student.showMessage();
    }
}

实例初始化

实例初始化：
    目的：给普通成员变量赋值
     ①默认值
     ②显示赋值
     ③代码块赋值
     ④构造器赋值

执行顺序：1永远最前  2,3看书写顺序 4永远最后
    ①②③④
    ①③②④

注意：
    1.会将上述内容合并到<init>方法内
    2.实例初始化new 几次对象就会执行几次

public class Person {
{
        System.out.println("代码块零");
    }
    String name = "张三";

    {
        System.out.println("代码块一");
    }
    public Person(String name ){
        this.name = name;
    }
    int age = 30;
    public Person() {
        System.out.println("无参");
    }
    char sex = '男';
}

public class Test {
    public static void main(String[] args) {
        Person p1 = new Person();
    }
}

例二

有继承的实例初始化：
    0.子类的<init>
    1.默认值
    2.子类构造器super()
    3.父类有独立的<init>
    3.父类代码块
    3.父类显示赋值语句
    4.父类构造器
    4.父类的<init>结束
    5.回到子类的<init>
    6.代码块
    6.显示赋值语句
    7.子类代码块内容
    8.子类的构造器内容
    9.子类的<init>结束

（注意如果父类显示赋值的时候用的是方法，那么一定要确定该方法是否被重写了，如果被重写了，那么执行的是子类的方法）

实例初始化 创建几次对象就会执行几次

public class Person {
    {
        System.out.println("Person 代码块一 1");
    }
    String name = "李白";

    {
        System.out.println("Person 代码块二 2");
    }

    public Person(String name) {
        this.name = name;
    }

    public Person() {
        System.out.println("Person 无参 3");
    }
}

public class Student extends Person{

    int age = 30;
    {
        System.out.println("Student 代码块一 4");
    }
    public Student(){
        super();
        System.out.println("Student 无参  5");
    }
}

public class Test {
    public static void main(String[] args) {
        new Student();
    }
}

例2

public class Person {
    String name = getName();
    public String getName() {
        System.out.println("Person getName() 4 ");
        return null;
    }
    {
        System.out.println("Person 成员代码块1  5");
    }
    int age = getAge();
    public int getAge() {
        System.out.println("Person getAge()  6");
        return 0;
    }
    public Person() {
        System.out.println("Person 无参  7");
    }
}

public class Student extends Person {
    String name = getName();
    public String getName(){
        System.out.println("Student getName() 1");
        return "";
    }
    {
        System.out.println("Student 成员代码块 2");
    }
    public Student() {
        System.out.println("Student 无参 3");
    }

    int num  =getAge();


    public int getAge(){

        System.out.println("Student getAge() 8");
        return 10;
    }
}

public class Test {
    public static void main(String[] args) {
        new Student();
    }
}

先父类后子类的初始化 --> 先父类后子类的实例初始化

父类初始化
    父类的静态代码块内容
    父类的静态成员变量显示赋值语句
子类初始化
   子类的静态代码块内容
   子类的静态成员变量显示赋值语句

父类的实例初始化
   父类的成员代码块
   父类的普通成员变显示赋值语句
   父类的构造器内容
子类的实例初始化
    子类的成员代码块
    子类的普通成员变显示赋值语句
    子类的构造器内容

注意： 如果有方法重写 创建子类对象进行实例化 会执行子类重写的方法

public class Animal {
    static {
        System.out.println("Animal 静态代码块一   1");
    }
    static int age = getAge();

    public static int getAge() {
        System.out.println("Animal static  getAge() 2");
        return 0;
    }
    String name = getName();
    public String getName() {
        System.out.println("Animal getName() 3");
        return "";
    }
    {
        System.out.println("Animal 普通代码块 4");
    }
    public Animal() {
        System.out.println("Animal 无参 5");
    }
}

public class Cat extends Animal{
    static int num = getAge();
    public static int getAge() {
        System.out.println("Cat static  getAge() 6");
        return 0;
    }
    static {
        System.out.println("Cat 静态代码块一  7");
    }
    String name = getName();
    public String getName() {
        System.out.println("Cat   getName()  8");
        return "";
    }
    {
        System.out.println("Cat 普通代码块  9");
    }
    public Cat() {
        System.out.println("Cat 无参....... 10");
    }
}

public class Test {
    public static void main(String[] args) {
        new Cat();


        System.out.println("--------------------");

        new Cat();
    }
}