Java反射----简单的聊聊java反射

1.什么是动态语言跟静态语言

要准确理解反射的概念，首先需要知道什么是动态语言与静态语言。动态语言：在运行的时候，可以改变程序自身结构，比如C#，JavaScript，python，比如改变变量类型，删除函数，引进一些代码。静态语言：c，Java，C++，运行时结构不可改变。Java可以通过反射变成准动态语言，让编程更加灵活。

2.关于Class

Java反射Reflection允许java程序在执行期间借助于ReflectionAPI获取任何类的内部信息，并能够直接操作内部属性及方法。在JVM中，加载完类之后，在堆内存方法区中，就产生了一个Class类型的对象（一个类只有一个对应的Class对象），这个对象包含了对应类的完整的类结构信息（属性，方法构造器实现的接口等等，），我们可以通过这个对象看到类的结构。这个对象就像是一面镜子，所以我们形象的称之为：反射。Class类是Java反射的源头，实际上，反射从程序运行结果来看也很好理解，即：通过对象反射求出类的名称。

Class本身是一个类，Class对象只能由系统建立对象，一个加载的类在JVM中只会有一个Class实例，一个Class对象对应的是一个加载到JVM中的一个.class文件。通过Class可以完整地得到一个类中的所有被加载的结构。每个类的实例都会记得自己是由哪个Cass生成的。Class类是Reflection的根源，针对任何类想要去做反射操作，首先需要获得相应的Class对象。

3.从内存上分析什么是Class

Java内存分为堆，栈，方法区（特殊的堆）。堆：存放new的对象和数组，可以被所有的线程共享，不会存放别的对象引用。栈：存放基本变量类型（会包含这个基本类型的具体数值），引用对象的变量（会存放这个引用在堆里面的具体地址）。方法区：可以被所有的线程共享，包含了所有的class和static变量。类的加载过程：当程序使用某个类时，如果该类还未被加载到内存中，则系统会通过如下三个步骤来对该类进行初始化：Load类的加载（将类编译后的.class文件读入内存，并为之创建一个class对象，此过程由类加载器完成）---类的连接（Link，将类的二进制数据合并到JRE中）---Initialize类的初始化（JVM负责对类进行初始化）。

4.类的主动引用与被动引用

类的主动引用（一定会发生类的初始化）下面4种。new,调用静态成员（方法或变量），反射，有该类的子类产生上面步骤，注意是先加载父类，再加载子类。类的被动引用（不会发生类的初始化）当访问一个静态域时；通过子类引用父类的静态成员，不会引起子类的初始化，但是会引起父类的初始化；访问final修饰的常量。

5.示例：

示例一：

//获取Class对象测试。
public class GetClassObjectTest {
	public static void main(String[] args) throws ClassNotFoundException {
		
		//Test1:通过forName("类的全路径")获取User的Class对象
		Class class1 = Class.forName("User");//这里需要抛出一个异常
		System.out.println(class1.toString());
		//一个类加载之后只有一个class对象，所以hash值应该是唯一的。
		System.out.println(class1.hashCode());
		Class class2 = Class.forName("User");
		System.out.println(class2.hashCode());
		Class class3 = Class.forName("User");
		System.out.println(class3.hashCode());
		
		//Test2：通过User对象来获取User的Class对象，哪怕这里是通过User的不同对象
		User user = new User();
		Class class4 = user.getClass();
		System.out.println(class4.hashCode());
		
		//test3：通过类的全路径名.class获得
		Class class5 = User.class;//注意这里的User是类的全路径
		System.out.println(class5.hashCode());
		
		//通过类的class对象获得父类类型
		Class class6 = class5.getSuperclass();
		System.out.println(class6);
		System.out.println(class6.hashCode());
		
		//通过反射创建一个对象
		try {
			Object user2 = class6.newInstance();//User类中必须要一个无参构造器
			System.out.println(user2);
		} catch (InstantiationException | IllegalAccessException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		
	}
}

//pojo
class User {
	private String name;
	
	public User() {}

	public User(String name) {
		this.name = name;
	}

	public String getName() {
		return name;
	}

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

	@Override
	public String toString() {
		return "User [name=" + name + "]";
	}
	
}

运行结果：

class User
2018699554
2018699554
2018699554
2018699554
2018699554
class java.lang.Object
1311053135
java.lang.Object@70dea4e

示例二：

public class Test {

	static {
		System.out.println("带有main方法的静态代码块");
	}
	public static void main(String[] args) {
		
		//类的主动引用（一定会发生类的初始化）下面4种。
		//new,调用静态成员（方法或变量），反射，有该类的子类产生上面步骤，
		//注意是先加载父类静态代码块，再加载子类静态代码块。
		System.out.println(A.m);//这行代码会指向01 02步骤
		//03.A类在堆中new一个A类对象。
		//04这个对象会指向A类的class，并获取到类加载的时候类的数据
		A a  = new A();
		
		System.out.println(a.m);
	}
}

class B {
	static {
		System.out.println("父类静态代码块");
	}
}

class A extends B {

	//关于A类的加载步骤：
	//01.将类的数据（静态变量，静态方法，常量池，代码...)加载到方法区，所有A类的对象都会共享这些数据。
	//02.加载完01之后再堆中生成一个类的class对象。
	static {
		System.out.println("子类静态代码块初始化");
		m = 300;
	}
	//静态代码块在类加载之初就会被合并从上到下执行加载到方法区中
	static int m = 100;
	
	public A() {
		System.out.println("A类的无参构造方法");
	}
}

运行截图：

带有main方法的静态代码块
父类静态代码块
子类静态代码块初始化
100
A类的无参构造方法
100

6.总结：

反射优缺点：优点:反射可以实现动态创建对象和编译，体现出很大的灵活性。缺点：反射是一门解释性操作，这类操作消耗的性能总是慢于直接执行相同的操作。

反射相关的主要API：java.lang.reflect.Method:代表类的方法；java.lang.reflect.Field：代表类的成员变量；java.lang.reflect.Constructor：代表类的构造器。

通过反射可以做什么：在运行时构造任意一个类；某些外挂的机制；生成动态代理；在运行时处理注解；框架的重要机制······