认识反射

1.反射是什么，有什么作用？

      反射---在程序运行的过程中，我们可以得到某个类的对象，可以调用某个类中的任何一个变量/方法，这种动态获取信息的过程就是反射。

      当我们在没有见过某个类的情况下，仅凭一个完整的类名，就可以获取到整个类的所有信息。

      反射的使用场景:

            1.jdbc加载数据库驱动

            2.Servlet的web.xml配置

            3.Spring框架

2.实例对象与反射对象的相互转换？

      实例对象-----就是我们通过类创建的对象

      反射对象-----通过反射机制得到的类对象

      例如:  反射就是一面镜子，镜子前面的你就是实例对象，通过镜子得到的镜子里面的你就是反射对象。

      反射对象是一个Class类型的对象

      Class---不是创建类的关键字，表示一个类，所以反射对象是一个Class类型的对象

      public final class Class<T>

1. 通过实例对象得到反射对象

package com.wangxing;

public class Student extends Person implements MyInterface{
	private String stuname;
	private int stuage;
	public Student(){}
	public Student(String name){
		this.stuname=name;
	}
	public void test1(){
		System.out.println("这是Student类的实例方法");
	}
	public String testString(String args){
		return "hello";
	}
}

package com.wangxing;

public class testFanshe1 {
	public static void main(String age[])throws Exception{
		//得到反射对象
		//1.通过实例对象得到反射对象[getClass()]
		Student student=new Student();
		Class fanshe1=student.getClass();
		
		//2.通过Class类的forname(类名【包名+类名】);
		Class fanshe2=Class.forName("com.wangxing.Student");
	}
}

      2.通过反射对象得到实例对象

package com.wangxing;

public class testFanshe1 {
	public static void main(String age[])throws Exception{
                //得到反射对象
		//1.通过实例对象得到反射对象[getClass()]
		Student student=new Student();
		Class fanshe1=student.getClass();
		
		//2.通过Class类的forname(类名【包名+类名】);
		Class fanshe2=Class.forName("com.wangxing.Student");
		
		//通过反射对象得到实例对象[newInstance()]
		Student stu=new Student();
		stu.test1();
		
		Object student1=fanshe1.newInstance();
		Student student2=(Student)student1;
		student2.test1();
		
		
		
		
	}
}

3.通过反射对象得到构造方法\成员变量\成员方法

Constructor<?>[]	getConstructors() 得到构造方法
Field[]	getDeclaredFields() 得到成员变量
Method[]	getDeclaredMethods() 得到成员方法
Class<?>[]	getInterfaces() 得到接口。
Class<? super T>	getSuperclass() 得到父类。
Package	getPackage() 得到包对象。
int	getModifiers() Java语言修饰符 Modifier的toString(int mod)
String	getName() 得到类名称
Class<?>	getType()得到变量的数据类型
Class<?>[]	getParameterTypes()得到参数类型
Class<?>	getReturnType()得到方法返回值类型

4.反射的应用

package com.wangxing;

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

//通过反射得到与Student类一样的java类
public class TestFanshe2 {
	public static String jiequString(String string){
		
		return string.substring(string.lastIndexOf(".")+1);
	}
	
	public static void main(String agrs[])throws Exception{
		//得到反射对象
		Class student=Class.forName("com.wangxing.Student");
		//得到包名
		String packname=student.getPackage().getName();
		System.out.println("package "+packname+"\n");
		
		//得到类
		//1.得到修饰类的修饰符
		//getModifiers()方法的返回值是int类型
		//使用Modifier类的toString方法将int转换为String
		String xiushifu=Modifier.toString(student.getModifiers());
		//2.得到类名
		String classname=jiequString(student.getName());
		//3.得到父类名称
		String superd=jiequString(student.getSuperclass().getName());
		//4.得到实现的接口
		Class inter[]=student.getInterfaces();
		StringBuilder interinfo=new StringBuilder();
		for(Class name:inter){
			String face=jiequString(name.getName());
			interinfo.append(face+",");
		}
		StringBuilder stringbuilder=interinfo.deleteCharAt(interinfo.length()-1);
		String interfacename=stringbuilder.toString();
		System.out.println(xiushifu+" calss "+classname+" extends "+
				superd+" implements "+interfacename+"{");
		
		//得到类中的成员变量和修饰符
		Field field[]=student.getDeclaredFields();
		for(Field name:field){
			//得到修饰符
			String blxiushifu=Modifier.toString(name.getModifiers());
			//得到变量的数据类型
			String type=jiequString(name.getType().getName());
			//得到成员变量
			String chengyuan=name.getName();
			System.out.println("\t"+blxiushifu+" "+type+" "+chengyuan+";");
		}
		//定义空String
		//String string="";
		//得到类中的构造方法
		Constructor gouzaomoth[]=student.getConstructors();
		for(Constructor name:gouzaomoth){
			//得到构造方法的修饰符
			String gzxiushifu=Modifier.toString(name.getModifiers());
			//得到构造方法名称
			String gzname=jiequString(name.getName());
			//创建StringBuilder
			StringBuilder canshu=new StringBuilder();
			//得到构造方法的参数类型
			Class type[]=name.getParameterTypes();
			if(type.length!=0){
				for(Class name2:type){
					String typename=jiequString(name2.getName());
					
					canshu.append(typename+" name,");
				}
				canshu.deleteCharAt(canshu.length()-1);
			}
			String string=canshu.toString();
			System.out.println("\t"+gzxiushifu+" "+gzname+"("+string+"){}");
		}
		
		
		//得到实例方法
		Method method[]=student.getDeclaredMethods();
		
		for(Method name:method){
			//得到方法的修饰符
			String xiushi=Modifier.toString(name.getModifiers());
			//得到方法的返回值
			String fanhui=jiequString(name.getReturnType().getName());
			//得到方法名称
			String methodsname=jiequString(name.getName());
			StringBuilder methodcs=new StringBuilder();
			//得到方法的参数
			Class canshu[]=name.getParameterTypes();
			if(canshu.length!=0){
				for(Class name2:canshu){
					String csType=jiequString(name2.getName());
					methodcs.append(csType+" args,");
				}
				methodcs.deleteCharAt(methodcs.length()-1);
				
			}
			String csType=methodcs.toString();
			System.out.println("\t"+xiushi+" "+fanhui+" "+methodsname+"("+csType+"){}");
		}
		System.out.println("}");
	}
}