反射Java

发射的概念:

Java发射机制是在运行中，对任意一个类，都可以之到这个类的所有属性与方法，对于任意一个类，都可以调用它的任意一个发发和属性，这种动态获取信息和动态调用对象的方法的功能是Java的反射机制。

要解析一个类，先要获取这个类的字节码文件对象，而解析就是使用类中的方法，所以就先要获得每个字节码文件对应的对象

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

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

加载执行的时候：Class对象由来原来的Class文件存入内存中，并创建一个Class对象

.java文件-->.class文件这个过程是Java的编译

而反射是反编译就是将.class文件-->.java文件 就是编译成一个JavaBean

在这里我们先创建一个Person类

public class Person {

	public String name;
	
	private int age;
	public    String a;
	
	
	
	
	public Person() {
		super();
		// TODO Auto-generated constructor stub
	}

	
	
	public Person(String name, int age, String a) {
		super();
		this.name = name;
		this.age = age;
		this.a = a;
	}



	//无参无返回
	public void  m1() {
		System.out.println("a");
	}
	
	//无参有返回
	public String m2() {
		return "m2";
	}
	
	//有参无返回
	public void m3(Integer i,String str) {
		System.out.println(i);
		System.out.println(str);
	}
	
	//有参有返回
	private String m4(Integer i,String str) {
		return i+str;
	}
}

测试类：

获取类的对象  

	/*
		 * 获取类的对象
		 */
		// 1
		 Class<Person> p= Person.class;
		// 2对象来获取class
		 Person p=new Person();
		// 获取全路径限定名
		 System.out.println(p.getClass());
		// 3得到类的对象
		Class c = Class.forName("com.reflect.Person");
		System.out.println(c);
		// 4
		Class c = Person.class.getClassLoader().loadClass("com.reflect.Person");
		System.out.println(c);

		// 5 得到父类
		Class c = Person.class.getSuperclass();
		System.out.println(c);

		// 6
		Class c = Integer.class;
		System.out.println(c);

第二种后的类的对象（常用）

Class c = Class.forName("com.reflect.Person");
		 //全限定名
		 System.out.println(c.getName());
		 //类名
		 System.out.println(c.getSimpleName());
		 //包名
		 System.out.println(c.getPackage());

属性：公共的属性

Field f= c.getField("name");
		 //得到名称
		 System.out.println(f.getName());
		 //得到修饰符
		 System.out.println(f.getModifiers());
		 //得到数据类型
		 System.out.println(f.getType());
		 //得到Person的对象
		 //newInstance 实例化一个对象
		 Object person= c.newInstance();
		 //赋值
		 f.set(person, "李四");
		// 取值
		 System.out.println(f.get(person));

全部属性：

 Field[] fields = c.getDeclaredFields();
		 Object person = null;
		 for (Field f : fields) {
		 f.setAccessible(true);
		 person = c.newInstance();
		 if ("name".contains(f.getName())) {
		 f.set(person, "李四");
		 }else if("age".contains(f.getName())) {
		 f.set(person, 14);
		 }
		 System.out.println(f.get(person));
		 }

方法：

	//实例化对象
		Class c = Class.forName("com.reflect.Person");
		Object o = c.newInstance();
		//无参无返回
		 Method m1= c.getMethod("m1", null);
		 //调用
		 m1.invoke(o, null);
		 
		 
		//无参有返回
		 Method m2= c.getMethod("m2", null);
		 System.out.println(m2.invoke(o, null));
		
		//有参无返回
		 Method m3=c.getMethod("m3", Integer.class,String.class);
		 m3.invoke(o, 2,"A");
		//有参有返回
		 Method m4=c.getMethod("m4", Integer.class,String.class);
		 System.out.println(m4.invoke(o, 2,"A"));

构造方法：

 Class c = Class.forName("com.reflect.Person");
		// 无参
		 Constructor cto= c.getConstructor(null);
		 System.out.println(cto);
		// 所有
		 Constructor[] ctos= c.getConstructors();
		 for (Constructor constructor : ctos) {
			 //获取构造犯法的名称
		 System.out.println(constructor.getName());
	}

下面是一个方法的图：