Java------reflection反射

Java------reflection反射

基本概念

• 反射机制

1. 反射机制指的是可以于在运行时加载、探知、使用编译期间完成未知的类
2. 程序在运行状态中，可以动态加载一个只有名称的类，对于任意一个已加载的类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意一个方法和属性；
3. 加载完类之后，在堆内存中就产生一个Class类型的对象（一个类只有一个Class对象），这个对象就包含了完整的类的结构信息。我们可以通过这个对象看到类的结构。这个对象就像一面镜子，透过这个镜子看到类的结构，所以，我们形象的称之为：反射

• 先定义一个User类
  里边包含属性，方法，构造器

package com.briup.reflection.test;

public class User {

	private int id;
	private String name;
	private int age;
	
	public User() {
		super();
	}

	public User(int id, String name, int age) {
		super();
		this.id = id;
		this.name = name;
		this.age = age;
	}

	public int getId() {
		return id;
	}

	public void setId(int id) {
		this.id = id;
	}

	public String getName() {
		return name;
	}

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

	public int getAge() {
		return age;
	}

	public void setAge(int age) {
		this.age = age;
	}
	
	
}

• 获取Class对象的三种方法

package com.briup.reflection;

import com.briup.reflection.test.User;

/**
 * 测试java.lang.Class对象的获取方式
 * @author Vijay
 *
 */
@SuppressWarnings("all")
public class Demo01 {

	public static void main(String[] args) {
		
		String path = "com.briup.reflection.test.User";
		try {
			
			//方法一 
			//使用Class类的forName("类完整路径")方法获取：
			//如果我们有一个类的完整路径，就可以使用 Class.forName(“类完整的路径”) 来得到相应的 Class
			//这个方法只能用于引用类型，所谓类的完整路径是：包名.类名
			Class clazz1 = Class.forName(path);
			Class clazz2 = Class.forName(path);
			
			//方法二
			//使用Object.getClass ()方法----引用类型的对象的获取方式
			//如果我们已经拿到了一个对象，可以使用这个对象的 getClass() 方法获得一个 Class 对象(不过这仅限于引用类型的对象)：
			User user = new User();
			Class clazz3 = user.getClass();
			
			//方法三
			//使用类的class成员属性
			//如果我们当前没有某个类的对象，无法使用 getClass() 方法来获取Class对象，那还可以使用 类名.class 来获取 Class对象：
			//这种方式不仅能用于引用类型，基本类型也可以。数组也是可以的：
			Class clazz4 = String.class;
			Class clazz5=int.class;
			Class clazz6=int[][].class;
			
		} catch (ClassNotFoundException e) {
			e.printStackTrace();
		}
	}
}

• 用反射获取类的信息

package com.briup.reflection;

import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;

import javax.activation.FileDataSource;

/**
 * 用反射获取类的信息
 * @author Vijay
 *
 */
public class Demo02 {

	public static void main(String[] args) {
		
		String path = "com.briup.reflection.test.User";
		try {
			
			Class clazz = Class.forName(path);
			
			//获取类的名字
			System.out.println(clazz.getName());//获得包名+类名
			System.out.println(clazz.getSimpleName());//获得类名
			
			//获取属性
			Field[] field =  clazz.getDeclaredFields();
			for (Field fields : field) {
				System.out.println("属性:"+fields);
			}
			
			//获取方法信息
			Method[] method = clazz.getDeclaredMethods();//获取全部方法
			Method m = clazz.getDeclaredMethod("setName", String.class);//获取参数为String的方法
			for (Method methods : method) {
				System.out.println("方法:"+methods);
			}
			
			//获取构造器信息
			Constructor[] constructor = clazz.getDeclaredConstructors();
			for (Constructor constructors : constructor) {
				System.out.println("构造器:"+constructors);
			}
			
		} catch (Exception e) {
			e.printStackTrace();
		}
	}
}

• 操作通过反射获得的信息

package com.briup.reflection;

import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;

import com.briup.reflection.test.User;

/**
 * 操作通过反射获得的信息
 * @author Vijay
 *
 */
public class Demo03 {

	public static void main(String[] args) {
		String path = "com.briup.reflection.test.User";
		try {
			
			Class<User> clazz = (Class<User>) Class.forName(path);
			
			//通过反射API调用构造方法，构造对象
			User u1 = clazz.newInstance(); //调用了User的无参构造器
			System.out.println(u1);
			//调用有参构造器
			Constructor<User> c = clazz.getDeclaredConstructor(int.class,String.class,int.class);
			User u2 = c.newInstance(1001,"hwj",23);
			System.out.println(u2.getName());
			
			//通过反射API调用方法
			User u3 = clazz.newInstance();
			Method m = clazz.getDeclaredMethod("setName", String.class);
			m.invoke(u3, "郇文杰");
			System.out.println(u3.getName());
			
			//通过反射API操作属性
			User u4 = clazz.newInstance();
			Field f = clazz.getDeclaredField("name");
			f.setAccessible(true);	//这个属性不需要安全检查，可以直接访问
			f.set(u4, "张梓溪");	//通过反射直接写属性
			System.out.println(u4.getName());	//通过反射直接读属性的值
			
		} catch (Exception e) {
			e.printStackTrace();
		}
	}
}