(2.1.1.1) JVM内容：Class及其生命周期

最新推荐文章于 2022-06-14 18:00:17 发布

fei20121106

最新推荐文章于 2022-06-14 18:00:17 发布

阅读量855

点赞数

分类专栏： 2.1-Java之基本知识

2.1-Java之基本知识专栏收录该内容

69 篇文章 0 订阅

订阅专栏

3.2 需要注意newInstance()方法

一、class文件格式

Java 字节码可以跨不同的虚拟机在不同的平台上执行，这些字节码按照class文件格式的规范组成了class文件，从而为Java语言跨平台执行奠定了基石；不同的语言都可以根据class文件格式生成可以在JVM上执行的字节码，这又给Java平台带来了新的血液。
class 文件是Java程序二进制的精确定义。每一个class文件都是对一个Java 类或者接口的描述。因为有着同一的格式，无论在何种平台上产生，也无论是在何种平台上运行，class文件的定义都能够被Java虚拟机正确地读取。下面先看看class文件的格式：

```
ClassFile {
    u4 magic;                                     //魔数，固定值为0xCAFEBABE，用来判断当前文件是能被Java虚拟机处理的Class文件
    u2 minor_version;                             //副版本号
    u2 major_version;                             //主版本号
    u2 constant_pool_count;                       //常量池计数器
    cp_info constant_pool[constant_pool_count-1]; //常量池
    u2 access_flags;                              //类和接口层次的访问标志
    u2 this_class;                                //类索引
    u2 super_class;                               //父类索引
    u2 interfaces_count;                          //接口计数器
    u2 interfaces[interfaces_count];              //接口表
    u2 fields_count;                              //字段计数器
    field_info fields[fields_count];              //字段表
    u2 methods_count;                             //方法计数器
    method_info methods[methods_count];           //方法表
    u2 attributes_count;                          //属性计数器
    attribute_info attributes[attributes_count];  //属性表
}
```

一个典型的class文件分为：MagicNumber，Version，Constant_pool，Access_flag，This_class，Super_class，Interfaces，Fields，Methods 和Attributes这十个部分。

1.1 示例

```
public class Hello{
      private int test;
      public int test(){
            return test;
        }
}

ca fe ba be 00 00 00 32 00 12 0a 00 04 00 0e 09
00 03 00 0f 07 00 10 07 00 11 01 00 04 74 65 73
74 01 00 01 49 01 00 06 3c 69 6e 69 74 3e 01 00
03 28 29 56 01 00 04 43 6f 64 65 01 00 0f 4c 69
6e 65 4e 75 6d 62 65 72 54 61 62 6c 65 01 00 03
28 29 49 01 00 0a 53 6f 75 72 63 65 46 69 6c 65
01 00 0a 48 65 6c 6c 6f 2e 6a 61 76 61 0c 00 07
00 08 0c 00 05 00 06 01 00 05 48 65 6c 6c 6f 01
00 10 6a 61 76 61 2f 6c 61 6e 67 2f 4f 62 6a 65
63 74 00 21 00 03 00 04 00 00 00 01 00 02 00 05
00 06 00 00 00 02 00 01 00 07 00 08 00 01 00 09
00 00 00 1d 00 01 00 01 00 00 00 05 2a b7 00 01
b1 00 00 00 01 00 0a 00 00 00 06 00 01 00 00 00
01 00 01 00 05 00 0b 00 01 00 09 00 00 00 1d 00
01 00 01 00 00 00 05 2a b4 00 02 ac 00 00 00 01
00 0a 00 00 00 06 00 01 00 00 00 03 00 01 00 0c
00 00 00 02 00 0d
```

详细分析请参看：[JVM之字节码——Class文件格式](https://www.cnblogs.com/avivahe/p/5747113.html)

二、Class 的生命周期

【图】

一个类的生命周期：

1. **<font color = red>加载（Loading），由类加载器执行，查找字节码，并创建一个Class对象（只是创建）；</font>**
2. 链接（Linking）
   - 验证字节码
   - 为静态域分配存储空间（只是分配，并不初始化该存储空间）
   - 解析该类创建所需要的对其它类的应用；
3. 初始化（Initialization），首先执行静态初始化块static{}，初始化静态变量，执行静态方法（如构造方法）。
4. 使用
5. 卸载

> 需要区分加载和初始化的区别，加载了一个类的.class文件，不以为着该Class对象被初始化，事实上，一个类的初始化包括3个步骤：加载、链接、初始化

2.1 动态加载

- 不管使用什么样的类加载器，类，都是在第一次被用到时，动态加载到JVM的。这句话有两层含义：
   1. Java程序在运行时并不一定被完整加载，只有当发现该类还没有加载时，才去本地或远程查找类的.class文件并验证和加载；
   2. 当程序创建了第一个对类的静态成员的引用（如类的静态变量、静态方法、构造方法——构造方法也是静态的）时，才会加载该类。

2.2 链接（Linking）

Java在加载了类之后，需要进行链接的步骤，链接简单地说，就是将已经加载的java二进制代码组合到JVM运行状态中去。它包括3个步骤：

1. 验证（Verification）
   - 验证是保证二进制字节码在结构上的正确性，具体来说，工作包括检测类型正确性，接入属性正确性（public、private），检查final class 没有被继承，检查静态变量的正确性等。
2. 准备（Preparation）
   - 准备阶段主要是创建静态域，分配空间，给这些域设默认值
   - 需要注意的是两点：一个是在准备阶段不会执行任何代码，仅仅是设置默认值，二个是这些默认值是这样分配的，原生类型全部设为0，如：float:0f,int 0, long 0L, boolean:0（布尔类型也是0），其它引用类型为null。
3. 解析（Resolution），解析的过程就是对类中的接口、类、方法、变量的符号引用进行解析并定位，解析成直接引用（符号引用就是编码是用字符串表示某个变量、接口的位置，直接引用就是根据符号引用翻译出来的地址），并保证这些类被正确的找到。
   - 解析的过程可能导致其它的类被加载。需要注意的是，根据不同的解析策略，这一步不一定是必须的，有些解析策略在解析时递归的把所有引用解析，这是early resolution，要求所有引用都必须存在；还有一种策略是late resolution，这也是Oracle 的JDK所采取的策略，即在类只是被引用了，还没有被真正用到时，并不进行解析，只有当真正用到了，才去加载和解析这个类。

2.3 初始化

根据java虚拟机规范，所有java虚拟机实现必须在每个类或接口被java程序首次主动使用时才初始化。主动使用有以下6种：

- 创建类的实例
- 访问某个类或者接口的静态变量，或者对该静态变量赋值（如果访问静态编译时常量(即编译时可以确定值的常量)不会导致类的初始化）
- 调用类的静态方法
- 反射（Class.forName(xxx.xxx.xxx)）
- 初始化一个类的子类（相当于对父类的主动使用），不过直接通过子类引用父类元素，不会引起子类的初始化（参见示例6）
- Java虚拟机被标明为启动类的类（包含main方法的）

三、静态块

static{}是在第一次初始化时执行，且只执行一次

- 不实例化，只执行forName初始化时，仍然会执行static{}子句，但不执行构造方法，因此输出的只有Initializing，没有Building。
- 用类字面常量 .class和Class.forName都可以创建对类的应用，但是不同点在于，用Gum.class创建Class对象的应用时，不会自动初始化该Class对象（static子句不会执行）
- 编译时常量。回到完整的类Toy，如果直接输出：System.out.println(Toy.price)，会发现static子句和构造方法都没有被执行，这是因为Toy中，常量price被static final限定，这样的常量叫做编译时常量，对于这种常量，不需要初始化就可以读取。
- 编译时常量必须满足3个条件：static的，final的，常量。

3.1 实验1：初始化与构造函数的差异

注意：在《Java编程思想》中，说static{}子句是在类第一次加载时执行且执行一次（可能是笔误或翻译错误，因为此书的例子显示static是在第一次初始化时执行的），《Java深度历险》中说 static{}是在第一次实例化时执行且执行一次，这两种应该都是错误的，static{}是在第一次初始化时执行，且只执行一次；用下面的代码可以判定出来：

```
public class Toy {
        private String name;

        public static final int price=10;
        
        static {
                System.out.println("Initializing");
        }

        Toy() {
                System.out.println("Building");
        }
        Toy(String name) {
                this.setName(name);
        }

        public static String playToy(String player) {
                String msg = buildMsg(player);
                System.out.println(msg);
                return msg;
        }
        private String buildMsg(String player) {
                String msg = player + " plays " + name;
                return msg;
        }
}
  // 对上面的类，执行下面的代码：
  Class c = Class.forName("myblog.rtti.Toy");
  // c.newInstance();
  
```

可以看到，不实例化，只执行forName初始化时，仍然会执行static{}子句，但不执行构造方法，因此输出的只有Initializing，没有Building。


``` 
class Toy {
        static {
                System.out.println("Initializing");// 静态子句，只在类第一次被加载并初始化时执行一次，而且只执行一次
        }

        Toy() {
                System.out.println("Building");// 构造方法，在每次声明新对象时加载
        }
}
```

对上面的程序段，第一次调用Class.forName("Toy")，将执行static子句；如果在之后执行new Toy()都只执行构造方法。

3.2 需要注意newInstance()方法

``` 
Class cc = Class.forName("Toy");//获得类（注意，需要使用含包名的全限定名）
Toy toy=(Toy)cc.newInstance(); //相当于new一个对象，但Gum类必须有默认构造方法（无参）
```

3.3 类字面常量

用类字面常量 .class和Class.forName都可以创建对类的应用，但是不同点在于，用Gum.class创建Class对象的应用时，不会自动初始化该Class对象（static子句不会执行）

``` 
public class TestToy {
        public static void main(String[] args) {
                // try {
                // Class c = Class.forName("myblog.classloader.Toy");
                // } catch (ClassNotFoundException e) {
                // e.printStackTrace();
                // }
                Class c = Toy.class; // 不会输出任何值
        }
}
```

**使用Toy.class是在编译期执行的，因此在编译时必须已经有了Toy的.class文件，不然会编译失败，这与 Class.forName("myblog.classloader.Toy")不同，后者是运行时动态加载。**

但是，如果该main方法是直接写在Toy类中，那么调用Toy.class，会引起初始化，并输出Initializing，原因并不是Toy.class引起的，而是该类中含有启动方法main，该方法会导致Toy的初始化。

3.4 编译时常量

回到完整的类Toy，如果直接输出：System.out.println(Toy.price)，会发现static子句和构造方法都没有被执行，这是因为Toy中，常量price被static final限定，这样的常量叫做编译时常量，对于这种常量，不需要初始化就可以读取。

编译时常量必须满足3个条件：static的，final的，常量。

下面几种都不是编译时常量，对它们的应用，都会引起类的初始化：

``` 
static int a;

final  int b;

static final  int c= ClassInitialization.rand.nextInt(100);

static final  int d;
static {
    d=5;
}
```

3.5 static块的本质

``` 
class StaticBlock {
        static final int c = 3;

        static final int d;

        static int e = 5;
        static {
                d = 5;
                e = 10;
                System.out.println("Initializing");
        }

        StaticBlock() {
                System.out.println("Building");
        }
}

public class StaticBlockTest {
        public static void main(String[] args) {
                System.out.println(StaticBlock.c);
                System.out.println(StaticBlock.d);
                System.out.println(StaticBlock.e);
        }
}
```

这段代码的输出是什么呢？Initialing在c、d、e之前输出，还是在之后？e输出的是5还是10？

```
3
Initializing
5
10
```

答案是3最先输出，Intializing随后输出，e输出的是10，为什么呢？

原因是这样的：输出c时，由于c是编译时常量，不会引起类初始化，因此直接输出，输出d时，d不是编译时常量，所以会引起初始化操作，即static块的执行，于是d被赋值为5，e被赋值为10，然后输出Initializing，之后输出d为5，e为10。

但e为什么是10呢？原来，JDK会自动为e的初始化创建一个static块（参考：http://www.java3z.com/cwbwebhome/article/article8/81101.html?id=2497），所以上面的代码等价于：

``` 
class StaticBlock {
        static final int d;

        static int e;
        
        static {
           e=5; 
        }

        static {
            d = 5;
            e = 10;
            System.out.println("Initializing");
        }

        StaticBlock() {
            System.out.println("Building");
        }
}    
```

可见，按顺序执行，e先被初始化为5，再被初始化为10，于是输出了10。

3.6 初始化顺序

当访问一个Java类或接口的静态域时，只有真正声明这个域的类或接口才会被初始化

``` 
/**
 * 例子来源于《Java深度历险》第二章
 * @author 张广
 *
 */
class B {
        static int value = 100;
        static {
                System.out.println("Class B is initialized");// 输出
        }
}

class A extends B {
        static {
                System.out.println("Class A is initialized"); // 不输出
        }
}

public class SuperClassTest {
        public static void main(String[] args) {
                System.out.println(A.value);// 输出100
        }
}
```

在该例子中，虽然通过A来引用了value，但value是在父类B中声明的，所以只会初始化B，而不会引起A的初始化。

四、RTTI

并不是所有的Class都能在编译时明确，因此在某些情况下需要在运行时再发现和确定类型信息（比如：基于构建编程，），这就是RTTI（Runtime Type Information，运行时类型信息）。

在java中，有两种RTTI的方式，一种是传统的，即假设在编译时已经知道了所有的类型；还有一种，是利用反射机制，在运行时再尝试确定类型信息。

- 传统的RTTI有3种实现方式：
   - 向上转型或向下转型（upcasting and downcasting），在java中，向下转型（父类转成子类）需要强制类型转换
   - Class对象（用了Class对象，不代表就是反射，如果只是用Class对象cast成指定的类，那就还是传统的RTTI）
   - instanceof或isInstance()
- 反射有时候也被称为内省（Introspection），事实上，反射，就是一种内省的方式，Java不允许在运行时改变程序结构或类型变量的结构，但它允许在运行时去探知、加载、调用在编译期完全未知的class，可以在运行时加载该class，生成实例对象（instance object），调用method，或对field赋值。这种类似于“看透”了class的特性被称为反射（Reflection），我们可以将反射直接理解为：可以看到自己在水中的倒影，这种操作与直接操作源代码效果相同，但灵活性高得多。

传统的RTTI与反射最主要的区别，在于RTTI在编译期需要.class文件，而反射不需要

4.1 传统RTTI

```
public interface IToy {
        public String playToy(String player) throws Exception;
}

public class AbstractToy implements IToy {
        @Override
        public String playToy(String player) throws Exception {
                System.out.println(player + " plays abstract toy");
                return "";
        }
}

public class Toy extends AbstractToy {

        private String name;

        public String color;

        protected int size;

        public static final int price = 10;

        static {
                System.out.println("Loading");
        }

        public Toy() {// 构造方法一定要声明为public类型，不然用getConstructors无法得到
                System.out.println("Initialing");
                setName("myToy");
                color = "red";
                size = 5;
        }

        public Toy(String name, String color, int size) {
                this.setName(name);
                this.color = color;
                this.size = size;
        }

        public String getName() {
                return name;
        }

        public void setName(String name) {
                this.name = name;
        }

        @Override
        public String playToy(String player) throws Exception {
                String msg = buildMsg(player);
                System.out.println(msg);
                return msg;
        }

        private String buildMsg(String player) {
                String msg = player + " plays " + name;
                return msg;
        }
}
```

传统的RTTI与反射最主要的区别，在于RTTI在编译期需要.class文件，而反射不需要

传统的RTTI使用转型或Instance形式实现，但都需要指定要转型的类型，比如：

```
public void rtti(Object obj){
    Toy toy = Toy(obj);
    // Toy toy = Class.forName("myblog.rtti.Toy")
    // obj instanceof Toy
}
```

注意其中的obj虽然是被转型了，但在编译期，就需要知道要转成的类型Toy，也就是需要Toy的.class文件。

相对的，反射完全在运行时在通过Class类来确定类型，不需要提前加载Toy的.class文件。

4.2 反射

那到底什么是反射（Reflection）呢？反射有时候也被称为内省（Introspection），事实上，反射，就是一种内省的方式，Java不允许在运行时改变程序结构或类型变量的结构，但它允许在运行时去探知、加载、调用在编译期完全未知的class，可以在运行时加载该class，生成实例对象（instance object），调用method，或对field赋值。这种类似于“看透”了class的特性被称为反射（Reflection），我们可以将反射直接理解为：可以看到自己在水中的倒影，这种操作与直接操作源代码效果相同，但灵活性高得多。

关于Java的反射API，没必要去记忆，可以在任何JDK API中查询即可：

Class类：http://www.ostools.net/uploads/apidocs/jdk-zh/java/lang/Class.html

reflect包：http://www.ostools.net/uploads/apidocs/jdk-zh/java/lang/reflect/package-summary.html

```
public class ToyReflection {
        public static void printInfo(String info, Object obj) {
                if (obj.getClass().isArray()) {
                        System.out.println(info + ": ");
                        int length = Array.getLength(obj);
                        System.out.println("Array Size: " + length);
                        for (int i = 0; i < length; i++) {
                                System.out.print("Array[" + i + "]: " + Array.get(obj, i) + ", ");
                        }
                        if (length != 0)
                                System.out.println();
                }
                System.out.println(info + ": " + obj.toString());
        }

        public static void main(String[] args) {

                try {
                        // 获得类对象
                        Class<?> c = Class.forName("myblog.rtti.Toy");
                        printInfo("获得类对象", c);

                        // 获得超类
                        Class<?> superClass = c.getSuperclass();
                        printInfo("获得超类", superClass);

                        // 获得所有父接口
                        Class<?>[] interfaces = c.getInterfaces();
                        printInfo("获得所有父接口", interfaces);

                        // 实例化
                        Toy toy = (Toy) c.newInstance();
                        printInfo("实例化", toy);

                        // 获得访问属性为public的构造方法
                        Constructor<?>[] constructors = c.getConstructors();
                        printInfo("获得构造方法", constructors);

                        // 获得指定参数的构造方法
                        Constructor<?> constructor = c.getDeclaredConstructor(String.class, String.class, int.class);
                        printInfo("获得指定构造方法", constructor);

                        // 获得方法，getMethod只能获得public方法，包括父类和接口继承的方法
                        Method method = c.getMethod("playToy", String.class);
                        printInfo("获得公有方法", method);

                        // 调用方法
                        method.invoke(toy, "张三");

                        // 获得修饰符，包括private/public/protect,static
                        String modifier = Modifier.toString(method.getModifiers());
                        printInfo("获得修饰符", modifier);

                        // 获得参数类型
                        Class<?>[] paramTypes = method.getParameterTypes();
                        printInfo("获得参数类型", paramTypes);

                        // 获得返回值类型
                        Class<?> returnType = method.getReturnType();
                        printInfo("获得返回值类型", returnType);

                        // 获得异常类型
                        Class<?>[] excepTypes = method.getExceptionTypes();
                        printInfo("获得异常类型", excepTypes);

                        // 调用私有方法，getDeclaredMethod获得类自身的方法，包括public,protect,private方法
                        Method method2 = c.getDeclaredMethod("buildMsg", String.class);
                        method2.setAccessible(true);
                        String result = (String) method2.invoke(toy, "李四");
                        printInfo("获得私有方法", result);

                        // 获得全部属性
                        Field[] fields = c.getFields();
                        printInfo("获得全部属性", fields);

                        // 获得类自身定义的指定属性
                        Field field = c.getDeclaredField("name");
                        printInfo("获得自身属性", field);

                        // 获得类及其父类，父接口定义的public属性
                        Field field2 = c.getField("color");
                        printInfo("获得公有属性", field2);

                        // 获得权限修饰符，包括private/public/protect,static,final
                        String fieldModifier = Modifier.toString(field.getModifiers());
                        printInfo("获得权限修饰符", fieldModifier);

                        // 操作数组
                        int[] exampleArray = { 1, 2, 3, 4, 5 };
                        // 获得数组类型
                        Class<?> componentType = exampleArray.getClass().getComponentType();
                        printInfo("数组类型", componentType.getName());
                        // 获得长度
                        printInfo("数组长度", Array.getLength(exampleArray));
                        // 获得指定元素
                        printInfo("获得数组元素", Array.get(exampleArray, 2));
                        // 修改指定元素
                        Array.set(exampleArray, 2, 6);
                        printInfo("修改数组元素", exampleArray);

                        // 获得当前的类加载器
                        printInfo("获得当前类加载器", toy.getClass().getClassLoader().getClass().getName());
                } catch (ClassNotFoundException e) {
                        e.printStackTrace();
                } catch (InstantiationException e) {
                        e.printStackTrace();
                } catch (IllegalAccessException e) {
                        e.printStackTrace();
                } catch (SecurityException e) {
                        e.printStackTrace();
                } catch (NoSuchMethodException e) {
                        e.printStackTrace();
                } catch (IllegalArgumentException e) {
                        e.printStackTrace();
                } catch (InvocationTargetException e) {
                        e.printStackTrace();
                } catch (NoSuchFieldException e) {
                        e.printStackTrace();
                }

        }
}
```

通过上面的代码，可以清晰的理解如何“在水中看到自己”，不过需要注意的有几点：

1. 在java的反射机制中，getDeclaredMethod得到的是全部方法，getMethod得到的是公有方法；
2. 反射机制的setAccessible可能会破坏封装性，可以任意访问私有方法和私有变量；
3. setAccessible并不是将private改为public，事实上，public方法的accessible属性也是false的，setAccessible只是取消了安全访问控制检查，所以通过设置setAccessible，可以跳过访问控制检查，执行的效率也比较高。参考：http://blog.csdn.net/devilkin64/article/details/7766792

反射机制给予Java开发很大的灵活性，但反射机制本身也有缺点，代表性的缺陷就是反射的性能，一般来说，通过反射调用方法的效率比直接调用的效率要至少慢一倍以上。

参考文献

- [JVM之字节码——Class文件格式](https://www.cnblogs.com/avivahe/p/5747113.html)
- Java-RTTI与反射机制--详细：http://blog.csdn.net/dahaizisheng/article/details/1762327
- Java反射详解：http://www.cnblogs.com/rollenholt/archive/2011/09/02/2163758.html
- RTTI和反射机制：http://blog.sina.com.cn/s/blog_5ea2d6840100v9bu.html
- Java中的RTTI和反射机制：http://blog.csdn.net/a81895898/article/details/8457623
- Java反射性能测试：http://blog.csdn.net/l_serein/article/details/6219897

fei20121106

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
(2.1.1.1) JVM内容：Class及其生命周期

目录1.1 示例二、Class 的生命周期2.1 动态加载2.2 链接（Linking）2.3 初始化三、静态块3.1 实验1：初始化与构造函数的差异3.2 需要注意newInstance()方法3.3 类字面常量3.4 编译时常量3.5 static块的本质3.6 初始化顺序四、RTTI4.1 传统RTTI4.2 反射参考文献一...
复制链接

扫一扫

专栏目录