java反射与new_Java反射理解

Java反射理解

Java类型信息

RTTI(运行时类型识别)源于《Thinking in Java》一书，其作用是在运行时识别一个对象的类型和类的信息。这里分两种:编译期的：也叫传统的”RRTI”，它假定我们在编译期已知道了所有类型(在没有反射机制创建和使用类对象时，一般都是编译期已确定其类型，如new对象时该类必须已定义好)，

另外一种是运行期的：利用反射机制它允许我们在运行时发现和使用类型的信息。

在Java中用来表示运行时类型信息的对应类就是Class类，Class类也是一个实实在在的类，存在于JDK的java.lang包中。

Class对象

Class类被创建后的对象就是Class对象，Class对象表示的是自己手动编写类的类型信息，比如创建一个Apple类，那么，JVM就会创建一个Apple对应Class类的Class对象，该Class对象保存了Apple类相关的类型信息。

实际上在Java中每个类都有一个Class对象，每当我们编写并且编译一个新创建的类就会产生一个对应Class对象并且这个Class对象会被保存在同名.class文件里(编译后的字节码文件保存的就是Class对象)，那为什么需要这样一个Class对象呢？是这样的，当我们new一个新对象或者引用静态成员变量时，Java虚拟机(JVM)中的类加载器子系统会将对应Class对象加载到JVM中，然后JVM再根据这个类型信息相关的Class对象创建我们需要实例对象或者提供静态变量的引用值。但是，我们定义的一个类，无论创建多少个实例对象，在JVM中都只有一个Class对象与其对应，即：在内存中每个类有且只有一个相对应的Class对象，如图：

几点结论：Class类也是类的一种，其创建后的对象称作class对象

手动编写的类被编译后会产生一个Class对象，其表示的是创建的类的类型信息，而且这个Class对象保存在同名.class的文件中(字节码文件)，比如创建一个Apple类，编译Apple类后就会创建其包含Apple类相关类型信息的Class对象，并保存在Apple.class字节码文件中

每个通过关键字class标识的类，无论创建多少个实例对象，在内存中有且只有一个与之对应的Class对象来描述其类型信息

Class类只有私有构造函数，因此对应Class对象只能有JVM创建和加载

JDK文档也有说明:

/** Private constructor. Only the Java Virtual Machine creates Class objects.* This constructor is not used and prevents the default constructor being* generated.*/

private Class(ClassLoader loader) {

// Initialize final field for classLoader. The initialization value of non-null // prevents future JIT optimizations from assuming this final field is null. classLoader = loader;

}Class类的对象作用是运行时提供或获得某个对象的类型信息，这点对于反射技术很重要

Class对象加载及获取方式

Class对象的加载

Class对象是由JVM加载的

实际上所有的类都是在对其第一次使用时动态加载到JVM中的，当程序创建第一个对类的静态成员引用时，就会加载这个被使用的类(实际上加载的就是这个类的字节码文件)。注：使用new创建类的新实例对象也会被当作对类的静态成员的引用(构造函数也是类的静态方法)

由此看来Java程序在它们开始运行之前并非被完全加载到内存的，其各个部分是按需加载，所以在使用该类时，类加载器首先会检查这个类的Class对象是否已被加载(类的实例对象创建时依据Class对象中类型信息完成的)，如果还没有加载，默认的类加载器就会先根据类名查找.class文件(编译后Class对象被保存在同名的.class文件中)，在这个类的字节码文件被加载时，它们必须接受相关验证，以确保其没有被破坏并且不包含不良Java代码(这是java的安全机制检测)，完全没有问题后就会被动态加载到内存中，此时相当于Class对象也就被载入内存了(毕竟.class字节码文件保存的就是Class对象)，同时也就可以根据这个类的Class对象来创建这个类的所有实例对象。下面通过一个简单例子来说明Class对象被加载的时机问题:

public class SweetShop {

public static void print(Object obj) {

System.out.println(obj);

}

public static void main(String[] args) {

print("inside main");

new Candy();

print("After creating Candy");

try {

Class.forName("better_write.Learn_reflection.Gum");

} catch(ClassNotFoundException e) {

print("Couldn't find Gum");

}

print("After Class.forName(\"better_write.Learn_reflection.Gum\")");

new Cookie();

print("After creating Cookie");

}

}

class Candy {

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

}

class Gum {

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

}

class Cookie {

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

}

输出:

inside main

Loading Candy

After creating Candy

Loading Gum

After Class.forName("better_write.Learn_reflection.Gum")

Loading Cookie

After creating Cookie

从结果来看，new一个Candy对象和Cookie对象，构造函数将被调用，属于静态方法的引用，Candy类的Class对象和Cookie的Class对象肯定会被加载(毕竟Candy、Cookie实例对象的创建依据他们对应的Class对象)。

forName方法是Class类的一个static成员方法(所有的Class对象都源于这个Class类，因此Class类中定义的方法将适应所有Class对象)这里通过forName方法，我们可以获取到Gum类对应的Class对象引用。从打印结果看，调用forName方法将会导致Gum类被加载(前提是Gum类从来没有被加载过)。

总结：某个类的Class对象是随着JVM加载该类过程中一起被加载到内存的

类加载过程

图示:

加载：类加载过程的一个阶段，通过一个类的完全限定查找此类字节码文件，并利用字节码文件创建一个Class对象

链接：验证字节码的安全性和完整性，准备阶段正式为静态域分配存储空间，注意此时只是分配静态成员变量的存储空间，不包含实例成员变量，如果必要的话，解析这个类创建的对其他类的所有引用；

初始化：类加载最后阶段，若该类具有超类，则对其进行初始化，执行静态初始化器和静态初始化成员变量。

获取字面常量的Class引用时，触发的应该是加载阶段，因为在这个阶段Class对象已创建完成，获取其引用并不困难，而无需触发类的最后阶段初始化。通过例子来验证这个过程

public class ClassInitialization {

public static Random rand = new Random(47);

public static void main(String[] args) throws Exception {

//字面常量获取方式获取Class对象 Class initable = Initable.class;

System.out.println("After creating Initable ref");

//不触发类初始化 System.out.println(Initable.staticFinal);

//会触发类初始化 System.out.println(Initable.staticFinal2);

//会触发类初始化 System.out.println(Initable2.staticNonFinal);

//forName方法获取Class对象 Class initable3 = Class.forName("better_write.Learn_reflection.Initable3");

System.out.println("After creating Initable3 ref");

System.out.println(Initable3.staticNonFinal);

}

}

class Initable {

//编译期静态常量 static final int staticFinal = 47;

//非编期静态常量 static final int staticFinal2 =

ClassInitialization.rand.nextInt(1000);

static {

System.out.println("Initializing Initable");

}

}

class Initable2 {

//静态成员变量 static int staticNonFinal = 147;

static {

System.out.println("Initializing Initable2");

}

}

class Initable3 {

//静态成员变量 static int staticNonFinal = 74;

static {

System.out.println("Initializing Initable3");

}

}

输出:

After creating Initable ref

47

Initializing Initable

258

Initializing Initable2

147

Initializing Initable3

After creating Initable3 ref

74

从输出结果来看，可以发现，通过字面常量获取方式获取Initable类的Class对象并没有触发Initable类的初始化，同时发现调用Initable.staticFinal变量时也没有触发初始化，这是因为staticFinal属于编译期静态常量，在编译阶段通过常量传播优化的方式将Initable类的常量staticFinal存储到了一个称为NotInitialization类的常量池中，在以后对Initable类常量staticFinal的引用实际都转化为对NotInitialization类对自身常量池的引用，所以在编译期后，对编译期常量的引用都将在NotInitialization类的常量池获取，这也就是引用编译期静态常量不会触发Initable类初始化的重要原因。但在之后调用了Initable.staticFinal2变量后就触发了Initable类的初始化，注意staticFinal2虽然被static和final修饰，但其值在编译期并不能确定，因此staticFinal2并不是编译期常量，使用该变量必须先初始化Initable类。Initable2和Initable3类中都是静态成员变量并非编译期常量，引用都会触发初始化。至于forName方法获取Class对象，肯定会触发初始化，小结论：获取Class对象引用的方式3种，通过继承自Object类的getClass方法，Class类的静态方法forName以及字面常量的方式”.class”

其中实例类的getClass方法和Class类的静态方法forName都将会触发类的初始化阶段，而字面常量获取Class对象的方式则不会触发初始化

初始化是类加载的最后一个阶段，也就是说完成这个阶段后类也就加载到内存中(Class对象在加载阶段已被创建)，此时可以对类进行各种必要的操作了(如new对象，调用静态成员等)，注意在这个阶段，才真正开始执行类中定义的Java程序代码或者字节码。

关于类加载的初始化阶段，在虚拟机规范严格规定了有且只有5种场景必须对类进行初始化使用new关键字实例化对象时、读取或者设置一个类的静态字段(不包含编译期常量)以及调用静态方法的时候，必须触发类加载的初始化过程(类加载过程最终阶段)

使用反射包(java.lang.reflect)的方法对类进行反射调用时，如果类还没有被初始化，则需先进行初始化，这点对反射很重要

当初始化一个类的时候，如果其父类还没进行初始化则需先触发其父类的初始化

当Java虚拟机启动时，用户需要指定一个要执行的主类(包含main方法的类)，虚拟机会先初始化这个主类

当使用JDK 1.7 的动态语言支持时，如果一个java.lang.invoke.MethodHandle 实例最后解析结果为REF_getStatic、REF_putStatic、REF_invokeStatic的方法句柄，并且这个方法句柄对应类没有初始化时，必须触发其初始化(这是1.7的新增的动态语言支持，其关键特征是它的类型检查的主体过程是在运行期而不是编译期进行的)

RTTI与反射

RTTI必须在编译期就知道所有类型

反射不必在编译期就知道所有的类型，它可以在运行过程中使用动态加载的类，而这个类不必在编译期就已经知道。反射主要由java.lang.reflect类库的Field、Method、Constructor类支持。这些类的对象都是JVM在运行时进行创建，用来表示未知的类。

对于RTTI而言，编译器在编译时打开和检查.class文件；对于反射而言，.class文件在编译时是不可获取的，所以在运行时打开和检查.class文件

反射

AVA反射机制是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意一个方法和属性；这种动态获取的信息以及动态调用对象的方法的功能称为Java语言的反射机制。

要想解剖一个类，必须先要获取到该类的字节码文件对象。而解剖使用的就是Class类中的方法。所以先要获取到每一个字节码文件对应的Class类型的对象

反射就是把Java类中的各种成分映射成一个个的Java对象

例如： 一个类有：成员变量、方法、构造方法、包等等信息，利用反射技术可以对一个类进行解剖，把各个组成部分映射成一个个对象

一般情况下，我们使用某个类时必定知道它是什么类，是用来做什么的。于是我们直接对这个类进行实例化，之后使用这个类对象进行操作:

//正常的调用 Person person = new Person();

person.setWeight(50.45);

反射则是一开始并不知道我要初始化的类对象是什么，自然也无法使用 new 关键字来创建对象了。

这时候，我们使用 JDK 提供的反射 API 进行反射调用：

Class clz = Class.forName("better_write.Learn_reflection.A1.Person");

反射的简单使用:

public class Person {

private double weight;

public double getWeight() {

return weight;

}

public void setWeight(double weight) {

this.weight = weight;

}

}

public class T {

public static void main(String[] args) throws NoSuchMethodException, ClassNotFoundException, IllegalAccessException, InvocationTargetException, InstantiationException {

//正常的调用 Person person = new Person();

person.setWeight(50.45);

System.out.println( person.getWeight());

//使用反射调用 Class clz = Class.forName("better_write.Learn_reflection.A1.Person");

Method setPriceMethod = clz.getMethod("setWeight", double.class);

Constructor Constructor = clz.getConstructor();

Object Obj = Constructor.newInstance();

setPriceMethod.invoke(Obj, 60.33);

Method getMethod = clz.getMethod("getWeight");

System.out.println(getMethod.invoke(Obj));

}

}

参考文章