Java类初始化顺序 主动使用才初始化

package mytests;

/**
 * 加载方法不等于执行方法，初始化变量则会赋值
 *             类加载顺序应为 加载静态方法-初始化静态变量-执行静态代码块
 *             实例化时 先加载非静态方法-实例化非静态变量-执行构造代码块-执行构造函数
 * @author panteng
 *
 */
public class StaticTest {
    static{
        System.out.println("--静态块1-- 1 = ");
        k = 1;
        System.out.println("--静态块1-- 2 = ");
    }
    /**第一个加载*/
    public static int k = -1;
    /**第二个加载，因为是new一个实例，
     * 首先初始化j 打印出  1:j i=0 n=0
     * 执行构造块     打印出  2:构造快 i=1 n=1
     * 执行构造方法 打印出  3:t1 i=2 n=2
     * 实例化完成
     */
    static{
        System.out.println("--静态块2-- k=" + k);
        k = 2;
        System.out.println("--静态块2-- k=" + k);
    }
    public static StaticTest t1 = new StaticTest("t1");
    /**第三个加载 过程同上
     * 首先初始化j 打印出  4:j i=3 n=3
     * 执行构造块     打印出  5:构造快 i=4 n=4
     * 执行构造方法 打印出  6:t2 i=5 n=5
     */
    public static StaticTest t2 = new StaticTest("t2");
    /**第四个加载
     * 打印出  7:i i=6 n=6
     */
    public static int i = print("i");
    /**
     * 第五个加载
     */
    public static int n = 99;
    /**
     * 此变量在类加载的时候并不初始化，在实例化类的时候初始化
     */
    public int j = print("j");

    {
        print("构造快");
    }
    /**
     * 第六个加载 此时，n已经被初始化  所以打印出
     * 8:静态块 i=7 n=99
     */
    static{
        print("静态块");
    }
    //-----------以上属于类加载---------------------
    /**
     * 实例化过程：
     *         首先加载非静态方法集；
     *         初始化非静态变量：9:j i=8 n=100
     *         执行构造块：10:构造快 i=9 n=101
     *         执行构造方法:11:init i=10 n=102
     * 实例化完成
     */

    /**
     * 执行构造函数  实例化完成
     * @param str
     */
    public StaticTest(String str) {
        System.out.println((++k) + ":" + str + " i=" + i + " n=" + n);
        ++n;
        ++i;
    }
    /**
     * 这个应该是最先加载 但是，加载不等于执行
     * 因为如果不加载此函数，静态变量是无法初始化的
     * @param str
     * @return
     */
    public static int print(String str) {
        System.out.println((++k) + ":" + str + " i=" + i + " n=" + n);
        ++i;
        return ++n;
    }

    public static void main(String[] args) {
        /**首先加载类，然后实例化：
         * 类加载过程：
         *         首先加载所有的静态方法，但不执行；
         *         然后按照静态变量的顺序开始初始化
         *         静态变量初始化完毕后执行静态构造块（不执行构造块）
         *         此时类加载完毕
         * 实例化过程：
         *         加载非静态方法
         *         初始化非静态变量
         *         执行构造代码块
         *         执行构造函数
         *         此时实例化完毕
         */
        StaticTest t = new StaticTest("init");
    }

}

package mytests;

/**
 * @Description 被动引用，子类不会初始化
 * @Company zzz
 * @author zww1
 * @version 2019年05月05日
 */

class Dfather{
    static int count = 1;
    {
        System.out.println("父类：构造块");
        System.out.println("父类count = " + count);
        count++;
    }
    static{
        System.out.println("父类：静态块");
        System.out.println("Initialize class Dfather");
    }
}

class Dson extends Dfather{
    {
        System.out.println("子类：构造块");
        System.out.println("子类count = " + count);
    }
    static{
        System.out.println("子类：静态块");
        System.out.println("Initialize class Dson");
    }
}

public class Extenstest1 {
    public static void main(String[] args) {
        int x = Dson.count;//被动引用，子类不会初始化
    }
}

package mytests;

/**
 * @Description 静态变量只初始化一次，位置不同结果也不同
 * @Company zzz
 * @author zww1
 * @version 2019年05月05日
 */
public class ClassloadSort1 {

    public static void main(String[] args) {
        Singleton.getInstance();
        System.out.println("Singleton value1:" + Singleton.value1);
        System.out.println("Singleton value2:" + Singleton.value2);

        Singleton2.getInstance2();
        System.out.println("Singleton2 value1:" + Singleton2.value1);
        System.out.println("Singleton2 value2:" + Singleton2.value2);
    }
}

class Singleton {
    static {
        System.out.println(Singleton.value1 + "\t" + Singleton.value2 + "\t" + Singleton.singleton);
        //System.out.println(Singleton.value1 + "\t" + Singleton.value2);
    }
    private static Singleton singleton = new Singleton();
    public static int value1 = 5;
    public static int value2 = 3;

    private Singleton() {
        System.out.println("= singleton 构造方法 = ");
        value1++;
        value2++;
    }

    public static Singleton getInstance() {
        return singleton;
    }

    int count = 10;

    {
        System.out.println("count = " + count);
    }
}

class Singleton2 {
    static {
        System.out.println(Singleton2.value1 + "\t" + Singleton2.value2 + "\t" + Singleton2.singleton2);
    }
    public static int value1 = 5;
    public static int value2 = 3;
    private static Singleton2 singleton2 = new Singleton2();
    private String sign;

    int count = 20;
    {
        System.out.println("count = " + count);
    }

    private Singleton2() {
        System.out.println("= singleton2 构造方法 = ");
        value1++;
        value2++;
    }

    public static Singleton2 getInstance2() {
        return singleton2;
    }
}

0    0    null
count = 10
= singleton 构造方法 = 
Singleton value1:5
Singleton value2:3
0    0    null
count = 20
= singleton2 构造方法 = 
Singleton2 value1:6
Singleton2 value2:4