Java学习笔记之--------反射

Java的动态性

Java的动态性主要在以下几个功能上体现：反射机制，动态编译，动态执行JavaScript代码，动态字节码操作。

动态语言

程序运行时，可以改变程序结构或者变量类型。动态语言有：Python、ruby、JavaScript等。

C、C++、Java不是动态语言，但是Java有一定的动态性，我们可以利用反射机制、字节码操作获得类似动态语言的特征。Java的动态性让编程更加灵活。

反射机制

反射机制指的是可以运行时加载、探知、使用编译期间完全未知的类。

程序在运行状态中，可以动态加载一个只有名称的类，对于任意一个已加载的类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意一个方法和属性。

例如：Class a = ClassForName("com.test.User");

加载完类之后，在堆内存中，就产生了一个Class类型的对象（一个类只有一个Class对象），这个对象就包含了完整的类的结构信息。我们可以通过这个对象看到类的结构。这个对象就像一面镜子，透过这个镜子看到类的结构，所以，我们形象的称之为：反射。

这里我们需要对类有一定的认识，可以参见下一篇文章：Java学习笔记之--------Class类介绍。已经有一定认识的就不需要看了

反射机制的常见作用

动态加载类、动态获取类的信息（属性、方法、构造器）；

动态构造对象；

动态调用类和对象的任意方法、构造器；

动态调用和处理属性；

获取泛型信息；

处理注解。

反射的优缺点

优点：反射提高了程序的灵活性和扩展性，降低耦合性，提高自适应能力。它允许程序创建和控制任何类的对象，无需提前硬编码目标类。

缺点：1。性能问题:使用反射基本上是一种解释操作，用于字段和方法接入时要远慢于直接代码。因此反射机制主要应用在对灵活性和扩展性要求很高的系统框架上，普通程序不建议使用。2.使用反射会模糊程序内内部逻辑：程序员希望在源代码中看到程序的逻辑，反射等绕过了源代码的技术，因而会带来维护问题。反射代码比相应的直接代码更复杂。而且使用反射后，执行效率也会有所下降。

有关执行效率：setAccessible(true|false)属性，它表示启用或者禁用安全检查的开关，值为true则指示反射的对象在使用时应该取消Java语言访问检查；值为false则指示反射的对象应该实施Java语言访问检查。注意这里并不是true代表可以访问，false代表不能访问。禁止安全检查，可以提高反射的运行速度。

应用一：反射操作泛型

Java采用泛型擦除的机制来引入泛型。Java中的泛型仅仅是给编译器javac使用的，确保数据的安全性和免去强制类型转换的麻烦。但是，一旦编译完成，所有的和泛型有关的类型全部擦除。

为了通过反射操作这些类型以迎合实际开发的需要，Java新增了ParameterizedType，GenericArrayType，TypeVariable和WildcardType几种类型来代表不能被归一到Class类中但是又和原始类型齐名的类型。
          ParameterizedType：表示一种参数化类型，比如Collection<String>；
          GenericArrayType：表示一种元素类型是参数化类型或者类型变量的数组类型；
          TypeVariable：是各种类型变量的公共父接口；
          WildcardType：代表一种通配符类型表达式，比如?,? extends Number,? super Integer（wildcard的意思就是通配符）。

应用二：反射操作注解

可以通过反射API：getAnnotations，getAnnotation获得相关的注解信息。我们需要了解一下：通过反射获得类的所有有效注解，通过反射获得类的指定注解，通过反射获得类的属性的注解。

反射应用Demo

实体类User.java：

public class User {
	private int id;
	private int age;
	private String uname;
	public int getId() {
		return id;
	}
	public void setId(int id) {
		this.id = id;
	}
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}
	public String getUname() {
		return uname;
	}
	public void setUname(String uname) {
		this.uname = uname;
	}
	//javabean必须要有无参的构造方法
	public User() {
	}
	public User(int id, int age, String uname) {
		this.id = id;
		this.age = age;
		this.uname = uname;
	}
}

应用反射的API，获取类的信息（名字、属性、方法、构造器等），Demo02：

public class Demo02 {
	public static void main(String[] args) {
		String path = "com.test.reflection.bean.User";
		try {
			Class clazz = Class.forName(path);
			//获取类的名字
			System.out.println(clazz.getName()); //获得包名+类名
			System.out.println(clazz.getSimpleName()); //获取类的名字
			//获取属性信息
			Field[] fields = clazz.getFields(); //只能获得public的field
			Field[] fields2 = clazz.getDeclaredFields(); //获得所有的field
			Field f = clazz.getDeclaredField("uname");
			System.out.println(fields.length);
			System.out.println(fields2.length);
			for (Field temp : fields2){
				System.out.println("属性：" + temp);
			}
			//获取方法信息
			Method[] method = clazz.getDeclaredMethods();
			Method m01 = clazz.getDeclaredMethod("getUname", null);
			   //如果方法有参，则必须传递参数类型对应的class对象
			Method m02 = clazz.getDeclaredMethod("setUname", String.class);
			for (Method m : method){
				System.out.println("方法：" + m);
			}
			//获取构造器信息
			Constructor[] constructors = clazz.getDeclaredConstructors();
			Constructor c1 = clazz.getDeclaredConstructor(null);
			System.out.println("获取构造器：" + c1 );
			Constructor c2 = clazz.getDeclaredConstructor(int.class, int.class, String.class);
			System.out.println("获取构造器：" + c2 );
			for (Constructor c : constructors){
				System.out.println("构造器：" + c );
			}
		} catch (Exception e) {
			e.printStackTrace();
		}
	}
}

运行结果如下图：

通过反射api动态的操作：构造器、方法、属性，Demo03：

public class Demo03 {
	public static void main(String[] args) {
		String path = "com.test.reflection.bean.User";
		try {
			Class clazz = Class.forName(path);
			//通过反射API调用构造方法，构造对象
			User u = (User) clazz.newInstance();  //其实是调用了User的无参构造方法
			System.out.println(u);
			Constructor<User> c = clazz.getDeclaredConstructor(int.class,int.class,String.class);
			User u2 = c.newInstance(10,18,"王小七");
			System.out.println(u2.getUname());
			//通过反射API调用普通方法
			User u3 = (User) clazz.newInstance();
			//u3.setUname("王小七");  以下代码与这句实现的功能相同
			Method method = clazz.getDeclaredMethod("setUname", String.class);
			method.invoke(u3, "王小七");
			System.out.println(u3.getUname());
			//通过反射API操作属性
			User u4 = (User) clazz.newInstance();
			Field f = clazz.getDeclaredField("uname");
			f.setAccessible(true); //这个属性不需要做安全检查了，可以直接访问。
			f.set(u4, "王小四");  //通过反射直接写属性
			System.out.println(u4.getUname());  //通过反射直接读属性
			System.out.println(f.get(u4));

		} catch (Exception e) {
			e.printStackTrace();
		}
	}

运行结果如下图：

通过反射获取泛型信息，Demo05：

public class Demo05 {

	public void test01(Map<String, User> map, List<User> list){
		System.out.println("Demo05.test01");
	}

	public Map<Integer, User> test02(){
		System.out.println("Demo05.test02");
		return null;
	}

	public static void main(String[] args) {
		try {
			//获得指定方法参数泛型信息
			Method m = Demo05.class.getMethod("test01", Map.class, List.class);
			Type[] t = m.getGenericParameterTypes();
			for (Type paramType : t){
				System.out.println("###" + paramType);
				if (paramType instanceof ParameterizedType){
					Type[] genericTypes = ((ParameterizedType) paramType).getActualTypeArguments();
					for (Type genericType : genericTypes){
						System.out.println("泛型类型：" + genericType);
					}
				}
			}

			//获得指定方法返回值泛型信息
			Method m2 = Demo05.class.getMethod("test02", null);
			Type returnType = m2.getGenericReturnType();
			if (returnType instanceof ParameterizedType){
				Type[] genericTypes = ((ParameterizedType) returnType).getActualTypeArguments();
				for (Type genericType : genericTypes){
					System.out.println("返回值，泛型类型：" + genericType);
				}
			}
		} catch (NoSuchMethodException e) {
			e.printStackTrace();
		}
	}
}

运行结果如下图：

对反射的总结就到这里了，此文章为尚学堂视频的笔记+自己总结。