Class类和Class.forName()使用总结

结合着反射的内容，发现有很多知识点以前没理清楚，mark一下Class和类加载Class.forName().

1. Class类简介

Java程序在运行时，Java运行时系统一直对所有的对象进行所谓的运行时类型标识。这项信息纪录了每个对象所属的类。虚拟机通常使用运行时类型信息选准正确方法去执行，用来保存这些类型信息的类是Class类。Class类封装一个对象和接口运行时的状态，当装载类时，Class类型的对象自动创建。

Class 没有公共构造方法。Class 对象是在加载类时由Java 虚拟机以及通过调用类加载器中的 defineClass 方法自动构造的，因此不能显式地声明一个Class对象。

虚拟机为每种类型管理一个独一无二的Class对象。也就是说，每个类（型）都有一个Class对象。运行程序时，Java虚拟机(JVM)首先检查是否所要加载的类对应的Class对象是否已经加载。如果没有加载，JVM就会根据类名查找.class文件，并将其Class对象载入。

基本的 Java 类型（boolean、byte、char、short、int、long、float 和 double）和关键字 void 也都对应一个 Class 对象。

每个数组属于被映射为 Class 对象的一个类，所有具有相同元素类型和维数的数组都共享该 Class 对象。

一般某个类的Class对象被载入内存，它就用来创建这个类的所有对象。

1.1 Class对象的获取

1、调用Object类的getClass()方法来得到Class对象，这也是最常见的产生Class对象的方法。例如：
1
2
MyObject x; Class c1 = x.getClass();
2、使用Class类的中静态forName()方法获得与字符串对应的Class对象。例如：
1
Class c2 = Class.forName("MyObject")
,Employee必须是接口或者类的名字。
3、获取Class类型对象的第三个方法非常简单。如果T是一个Java类型，那么T.class就代表了匹配的类对象。例如
1
2
3
Class cl1 = Manager.class; Class cl2 = int.class; Class cl3 = Double[].class;
注意：Class对象实际上描述的只是类型，而这类型未必是类或者接口。例如上面的int.class是一个Class类型的对象。由于历史原因，数组类型的getName方法会返回奇怪的名字。

1.2 Class类的常用方法

getName()

一个Class对象描述了一个特定类的属性，Class类中最常用的方法getName以 String 的形式返回此 Class 对象所表示的实体（类、接口、数组类、基本类型或 void）名称。
newInstance()
Class还有一个有用的方法可以为类创建一个实例，这个方法叫做newInstance()。例如：
x.getClass.newInstance()，创建了一个同x一样类型的新实例。newInstance()方法调用默认构造器（无参数构造器）初始化新建对象。
getClassLoader()

返回该类的类加载器。
getComponentType()

返回表示数组组件类型的 Class。
getSuperclass()

返回表示此 Class 所表示的实体（类、接口、基本类型或 void）的超类的 Class。
isArray()

判定此 Class 对象是否表示一个数组类

1.3 Class的一些使用技巧

forName和newInstance结合起来使用，可以根据存储在字符串中的类名创建对象。例如
1
Object obj = Class.forName(s).newInstance();
虚拟机为每种类型管理一个独一无二的Class对象。因此可以使用==操作符来比较类对象。例如：
1
if(e.getClass() == Employee.class)...

2. Class.forName()方法

Class.forName：返回与给定的字符串名称相关联类或接口的Class对象。

Class.forName是一个静态方法，同样可以用来加载类。该方法有两种形式：Class.forName(String name, boolean initialize, ClassLoader loader)和 Class.forName(String className)。第一种形式的参数 name表示的是类的全名；initialize表示是否初始化类；loader表示加载时使用的类加载器。第二种形式则相当于设置了参数 initialize的值为 true，loader的值为当前类的类加载器。


static Class<?>	forName(String className) Returns the Class object associated with the class or interface with the given string name.
static Class<?>	forName(String name, boolean initialize, ClassLoader loader) Returns the Class object associated with the class or interface with the given string name, using the given class loader.

说明：

publicstatic Class<?> forName(String className)

Returns the Class object associated withthe class or interface with the given string name. Invokingthis method is equivalent to:Class.forName(className,true, currentLoader)

where currentLoader denotes the definingclass loader of the current class.

For example, thefollowing code fragment returns the runtime Class descriptor for theclass named java.lang.Thread:

Class t =Class.forName(“java.lang.Thread”)

A call to forName(“X”) causes theclass named X to beinitialized.

Parameters:

className - the fully qualifiedname of the desired class.

Returns:

the Class object for the classwith the specified name.

从官方给出的API文档中可以看出:

Class.forName(className)实际上是调Class.forName(className,true,this.getClass().getClassLoader()).

第二个参数，是指Class被loading后是不是必须被初始化。

可以看出，使用Class.forName（className）加载类时则已初始化。

所以Class.forName(className)可以简单的理解为：获得字符串参数中指定的类，并初始化该类。

2.1 任何class都要装载在虚拟机上才能运行

 forName这句话就是<font color="FF0000">装载类</font>用的(new是根据加载到内存中的类创建一个实例，要分清楚)。

至于什么时候用，可以考虑一下这个问题，给你一个字符串变量，它代表一个类的包名和类名，你怎么实例化它？
1
2
A a = (A) Class.forName("pacage.A").newInstance(); A a = new A();
是一样的效果。
jvm在装载类时会执行类的静态代码段，要记住静态代码是和class绑定的，class装载成功就表示执行了你的静态代码了，而且以后不会再执行这段静态代码了。
Class.forName(xxx.xx.xx)的作用是要求JVM查找并加载指定的类，也就是说JVM会执行该类的静态代码段。

动态加载和创建Class 对象，比如想根据用户输入的字符串来创建对象

1
2
3

String str = 用户输入的字符串;
Class t = Class.forName(str);  
t.newInstance();

2.2 在初始化一个类，生成一个实例的时候，newInstance()方法和new关键字除了一个是方法，一个是关键字外，最主要有什么区别？

创建对象的方式不一样，前者是使用类加载机制，后者是创建一个新类。
那么为什么会有两种创建对象方式？

这主要考虑到软件的可伸缩、可扩展和可重用等软件设计思想。 Java中工厂模式经常使用newInstance()方法来创建对象，因此从为什么要使用工厂模式上可以找到具体答案。例如：
1
2
class c = Class.forName(“Example”); factory = (ExampleInterface) c.newInstance();
其中ExampleInterface是Example的接口，可以写成如下形式：
1
2
3
String className = "Example"; class c = Class.forName(className); factory = (ExampleInterface) c.newInstance();
进一步可以写成如下形式：
1
2
3
String className = readfromXMlConfig;//从xml 配置文件中获得字符串 class c = Class.forName(className); factory = (ExampleInterface) c.newInstance();
上面代码已经不存在Example的类名称，它的优点是，无论Example类怎么变化，上述代码不变，甚至可以更换Example的兄弟类Example2 , Example3 , Example4……，只要他们继承ExampleInterface就可以。
从JVM的角度看，我们使用关键字new创建一个类的时候，这个类可以没有被加载。但是使用newInstance()方法的时候，就必须保证：
- 这个类已经加载
- 这个类已经连接
而完成上面两个步骤的正是Class的静态方法forName()所完成的，这个静态方法调用了启动类加载器，即加载 java API的那个加载器。

现在可以看出，newInstance()实际上是把new这个方式分解为两步，即首先调用Class加载方法加载某个类，然后实例化。这样分步的好处是显而易见的。我们可以在调用class的静态加载方法forName时获得更好的灵活性，提供给了一种降耦的手段。

2.3 Class.forName和ClassLoader的区别

java中class.forName()和classLoader都可用来对类进行加载。

class.forName()前者除了将类的.class文件加载到jvm中之外，还会对类进行解释，执行类中的static块

classLoader只干一件事情，就是将.class文件加载到jvm中，不会执行static中的内容,只有在newInstance才会去执行static块。

Class.forName(name, initialize, loader)带参函数也可控制是否加载static块。并且只有调用了newInstance()方法采用调用构造函数，创建类的对象。

java类加载分三步：

加载
Jvm把class文件字节码加载到内存中，并将这些静态数据装换成运行时数据区中方法区的类型数据，在运行时数据区堆中生成一个代表这个类的java.lang.Class对象，作为方法区类数据的访问入口。
*注：方法区不仅仅是存放方法，它存放的是类的类型信息。
链接：执行下面的校验、准备和解析步骤，其中解析步骤是可选的
- 校验：检查加载的class文件的正确性和安全性
- 准备：为类变量分配存储空间并设置类变量初始值，类变量随类型信息存放在方法区中,生命周期很长，使用不当和容易造成内存泄漏。
  
  注：类变量就是static变量；初始值指的是类变量类型的默认值而不是实际要赋的值
- 解析：jvm将常量池内的符号引用转换为直接引用
初始化：执行类变量赋值和静态代码块

方法对比

Classloder.loaderClass(String name)
其实该方法内部调用的是：Classloder. loadClass(name, false)
方法：Classloder. loadClass(String name, boolean resolve)
- 参数name代表类的全限定类名
- 参数resolve代表是否解析，resolve为true是解析该类
Class.forName(String name)
其实该方法内部调用的是：Class.forName(className, true, ClassLoader.getClassLoader(caller))
方法：Class.forName0(String name, boolean initialize, ClassLoader loader)
- 参数name代表全限定类名
- 参数initialize代表是否初始化该类，为true是初始化该类
- 参数loader代表对应的类加载器

//Class.forName(String className)  这是1.8的源码
public static Class<?> forName(String className) throws ClassNotFoundException {
    Class<?> caller = Reflection.getCallerClass();
    return forName0(className, true, ClassLoader.getClassLoader(caller), caller);
}
//注意第二个参数，是指Class被loading后是不是必须被初始化。 不初始化就是不执行static的代码即静态代码

区别

Class.forName得到的class是已经初始化完成的

Classloder.loaderClass得到的class是还没有链接的

代码演示

package com.reflect;

public class Line {
    static {
        System.out.println("静态代码块执行: loading line");
    }
}

package com.reflect;

public class Point {
    static {
        System.out.println("静态代码块执行: loading point");
    }
}

package com.reflect;

public class ClassloaderAndForNameTest {
    public static void main(String[] args) {
        String wholeNameLine = "com.reflect.Line";
        String wholeNamePoint = "com.reflect.Point";
        System.out.println("下面是测试Classloader的效果");
        testClassloader(wholeNameLine, wholeNamePoint);
        System.out.println("----------------------------------");
        System.out.println("下面是测试Class.forName的效果");
        testForName(wholeNameLine, wholeNamePoint);
    }

    /**
     * classloader
     * @param wholeNameLine
     * @param wholeNamePoint
     */
    private static void testClassloader(String wholeNameLine, String wholeNamePoint) {
        Class<?> line;
        Class<?> point;
        ClassLoader loader = ClassLoader.getSystemClassLoader();
        try {
            line = loader.loadClass(wholeNameLine);
            point = loader.loadClass(wholeNamePoint);
            System.out.println("line " + line.getName());
            System.out.println("point " + point.getName());
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
    }

    /**
     * Class.forName
     * @param wholeNameLine
     * @param wholeNamePoint
     */
    private static void testForName(String wholeNameLine, String wholeNamePoint) {
        try {
            Class<?> line = Class.forName(wholeNameLine);
            Class<?> point = Class.forName(wholeNamePoint);
            System.out.println("line   " + line.getName());
            System.out.println("point   " + point.getName());
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }

    }
}

输出结果：

下面是测试Classloader的效果
line com.reflect.Line
point com.reflect.Point
----------------------------------
下面是测试Class.forName的效果
静态代码块执行: loading line
静态代码块执行: loading point
line   com.reflect.Line
point   com.reflect.Point

根据运行结果，可以看到，classloader并没有执行静态代码块，如开头的理论所说。

而下面的Class.forName则是夹在完之后，就里面执行了静态代码块，可以看到，2个类，line和point的静态代码块执行结果是一起的，然后才是各自的打印结果。

也说明上面理论是OK的。

接下来修改下Line的代码，添加了几个静态的方法和变量。

package com.reflect;

public class Line {
    static {
        System.out.println("静态代码块执行: loading line");
    }

    public static String s = getString();

    private static String getString() {
        System.out.println("给静态变量赋值的静态方法执行：loading line");
        return "mask";
    }

    public static void test() {
        System.out.println("普通静态方法执行：loading line");
    }

    {
        System.out.println("普通代码块");
    }

    public Line() {
        System.out.println("构造方法执行");
    }

}

输出结果：

下面是测试Classloader的效果
line com.reflect.Line
point com.reflect.Point
----------------------------------
下面是测试Class.forName的效果
静态代码块执行: loading line
给静态变量赋值的静态方法执行：loading line
静态代码块执行: loading point
line   com.reflect.Line
point   com.reflect.Point

除了，静态代码块的执行外，竟然还有一个静态方法被执行，就是给静态变量赋值的静态方法被执行了.

3. 应用场景

3.1 场景一：加载数据库驱动

利用了类加载和静态代码块绑定的特点

使用new加载注册

static void registerDriver(Driver driver) : 注册与给定的驱动程序 DriverManager

1 2	`DriverManager.registerDriver(new Driver()); Connection conn = DriverManager.getConnection("jdbc:mysql:///db3", "root", "root");`

而通常都是通过反射，加载与注册驱动类，解耦合（不直接依赖）

1 2	`Class.forName("com.mysql.jdbc.Driver"); Connection conn = DriverManager.getConnection("jdbc:mysql:///db3", "root", "root");`

为什么在我们加载数据库驱动包的时候有的却没有调用newInstance( )方法呢？(即有的jdbc连接数据库的写法里是Class.forName(xxx.xx.xx);而有一些Class.forName(xxx.xx.xx).newInstance()，为什么会有这两种写法呢？)

刚才提到，Class.forName() 的作用是要求JVM查找并加载指定的类，如果在类中有静态初始化器的话，JVM必然会执行该类的静态代码段。

而在JDBC规范中明确要求这个Driver类必须向DriverManager注册自己，即任何一个JDBCDriver的Driver类的代码都必须类似如下:

com.mysql.jdbc.Driver类中存在静态代码块

static {
	try {
  		java.sql.DriverManager.registerDriver(new Driver());
  	} catch (SQLException E) {
  		throw new RuntimeException("Can't register driver!");
  	}
}

既然在静态初始化器的中已经进行了注册，所以我们在使用JDBC时只需要Class.forName(XXX.XXX);就可以了。

3.2 场景二: 使用AIDL与电话管理Servic进行通信

获取类对象，通过反射实现代理

Method method = Class.forName("android.os.ServiceManager").getMethod("getService",String.class);
// 获取远程TELEPHONY_SERVICE的IBinder对象的代理
IBinder binder =(IBinder) method.invoke(null, new Object[] { TELEPHONY_SERVICE});
// 将IBinder对象的代理转换为ITelephony对象
ITelephonytelephony = ITelephony.Stub.asInterface(binder);
// 挂断电话
telephony.endCall();

参考资料

https://blog.csdn.net/fengyuzhengfan/article/details/38086743 ↩
JDK1.8_API…/docs/api/java/lang/Class.html ↩
http://www.ibm.com/developerworks/cn/java/j-lo-classloader/ ↩
https://blog.csdn.net/riemann_/article/details/86769805 ↩

Java JVM

本博客所有文章除特别声明外，均采用 CC BY-SA 4.0 协议，转载请注明出处！

GC并发标记的问题 Previous

Java初始化发生时机 Next