类的被动使用以及实战

布满荆棘的人生 2022-09-05 00:04 123阅读 0赞

# 一 点睛 #

除了类的主动使用，其他的情况均属于类的被动使用。被动使用不会引起类的初始化。也就是说：并不是在代码中出现的类，就一定会被加载或者初始化。如果不符合主动使用的条件，类就不会初始化。

## 1 静态字段 ##

当通过子类引用父类的静态变量，不会导致子类初始化，只有真正声明这个字段的类才会被初始化。

## 2 数组定义 ##

通过数组定义类引用，不会触发此类的初始化

## 3 引用常量 ##

引用常量不会触发此类或接口的初始化。因为常量在链接阶段就已经被显式赋值了。

## 4 loadClass 方法 ##

调用 ClassLoader 类的 loadClass()方法加载一个类，并不是对类的主动使用，不会导致类的初始化。

# 二 扩展 #

> \-XX:+TraceClassLoading：追踪打印类的加载信息

# 三 实战1 #

## 1 代码 ##

package chapter03.java1;
    
    import org.junit.Test;
    
    /**
    *
    * 关于类的被动使用，即不会进行类的初始化操作，即不会调用<clinit>()
    * 说明：没有初始化的类，不意味着没有加载！
    */
    public class PassiveUse1 {
        /**
         * 1. 当访问一个静态字段时，只有真正声明这个字段的类才会被初始化。
         *    > 当通过子类引用父类的静态变量，不会导致子类初始化
         */
        @Test
        public void test1(){
            System.out.println(Child.num);
            // 输出情况
            // Parent的初始化过程  -> 子类不需要初始化
            // 1
        }
    
        /**
         * 2. 通过数组定义类引用，不会触发此类的初始化
         */
        @Test
        public void test2(){
            Parent[] parents = new Parent[10]; // 不打印 —> 没有初始化，运行时才会加载进来
            System.out.println(parents.getClass()); // class [Lchapter03.java1.Parent;
            System.out.println(parents.getClass().getSuperclass()); // class java.lang.Object
            parents[0] = new Parent(); // Parent的初始化过程    -> 类初始化
            parents[1] = new Parent(); // 不打印 -> 类已经初始化过了
        }
    }
    
    class Parent{
        static{
            System.out.println("Parent的初始化过程");
        }
    
        public static int num = 1;
    }
    
    class Child extends Parent{
        static{
            System.out.println("Child的初始化过程");
        }
    }

## 2 执行 test1 ##

> Parent的初始化过程
> 
> 1

## 3 执行 test2 ##

> class \[Lchapter03.java1.Parent;
> 
> class java.lang.Object
> 
> Parent的初始化过程

# 四 实战2 #

## 1 代码 ##

package chapter03.java1;
    
    import org.junit.Test;
    
    import java.util.Random;
    
    public class PassiveUse2 {
        /**
         * 3. 引用常量不会触发此类或接口的初始化。因为常量在链接阶段就已经被显式赋值了。
         */
        @Test
        public void test1(){
    //        System.out.println(Person.NUM); // test1_1：不会触发 Person 类的初始化
    //        System.out.println(Person.NUM1); // test1_1：触发了 Person 类的初始化
        }
    
        @Test
        public void test2(){
    //        System.out.println(SerialA.ID); // test2_1：接口同理 使用SerialA.ID 不会触发 SerialA 的初始化
    //        System.out.println(SerialA.ID1); // test2_2：接口同理 ID1 会触发 SerialA 的初始化
        }
    
        /**
         * 4. 调用 ClassLoader 类的 loadClass() 方法加载一个类，并不是对类的主动使用，不会导致类的初始化。
         */
        @Test
        public void test3(){
            try {
                // 不会触发 Person 类的初始化，被动使用
                Class clazz = ClassLoader.getSystemClassLoader().loadClass("chapter03.java1.Person");
            } catch (ClassNotFoundException e) {
                e.printStackTrace();
            }
        }
    }
    
    class Person{
        static{
            System.out.println("Person类的初始化");
        }
        public static final int NUM = 1; // 在链接过程的准备环节就被赋值为1了。
        public static final int NUM1 = new Random().nextInt(10); // 此时的赋值操作需要在<clinit>() 中执行
    }
    
    interface SerialA{
        public static final Thread t = new Thread() {
            {
                System.out.println("SerialA的初始化");
            }
        };
    
        int ID = 1;
        int ID1 = new Random().nextInt(10); // 此时的赋值操作需要在<clinit>()中执行
    }

## 2 测试 ##

只运行 test1\_1:

> 1

只运行 test1\_2:

> Person类的初始化
> 
> 1

只运行 test2\_1:

> 1

只运行 test2\_2:

> SerialA的初始化
> 
> 1

运行 test3

> 无打印