认识反射

认识反射

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

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

类名，就可以获取到整个类的所有信息。

     反射的使用场景:

1. jdbc加载数据库驱动
2. Servlet的web.xml配置
3. Spring框架

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

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

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

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

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

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

package com.wangxing.test1;

public class TestMain {

	public static void main(String[] args) {
		/*
		//得到反射对象
		//1.通过实例对象得到反射对象  [getClass()]
		Student stu=new Student();
		Class  stuclass=stu.getClass();
		//2通过Class类的forname(类名【包名+类名】)
		try {
			Class  stuclass2=Class.forName("com.wangxing.test1.Student");
		} catch (ClassNotFoundException e) {
			e.printStackTrace();
		}
		*/
		
		//通过反射对象得到实例对象 [newInstance()]
		//Student stu=new Student();
		//stu.test1();
		try {
			Class  stuclass2=Class.forName("com.wangxing.test1.Student");
			Student  stu=(Student)stuclass2.newInstance();
			stu.test1();
		} catch (Exception e) {
			e.printStackTrace();
		}
		
	}

}

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

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

13.4反射的应用

       父类：

package com.wangxing.test1;

public class Person {

}

       接口：

package com.wangxing.test1;

public interface MyTestInterface {

}

      子类且实现接口：

package com.wangxing.test1;
public class Student extends Person implements MyTestInterface{
	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.test1;

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

//通过反射得到与Student类一样的java类
public class TestMain2 {
	public static String  testName(String classname){
		return classname.substring(classname.lastIndexOf(".")+1);
	}
	public static void main(String[] args)throws Exception {
		Class  stuclass2=Class.forName("com.wangxing.test1.Student");
		//得到Student类的包名
		String  pagename=stuclass2.getPackage().getName();
		String packageinfo="package "+pagename+";";
		System.out.println(packageinfo);
		//得到Student类的定义信息
		String classxiushifu=Modifier.toString(stuclass2.getModifiers());
		String leiming=testName(stuclass2.getName());
		String supername=testName(stuclass2.getSuperclass().getName());
		Class interfacearr[]=stuclass2.getInterfaces();
		StringBuilder interinfo=new  StringBuilder();
		for(Class inter:interfacearr){
			String intername=testName(inter.getName());
			interinfo.append(intername+",");
		}
		interinfo.deleteCharAt(interinfo.length()-1);
		String classinfo=classxiushifu+" class "+leiming+" extends "+
		supername+" implements "+interinfo.toString()+"{";
		System.out.println(classinfo);
		//得到类中的成员变量
		Field fieldarr[]=stuclass2.getDeclaredFields();
		for(Field  field:fieldarr){
			String fieldxiu=Modifier.toString(field.getModifiers());
			String fieldleixing=testName(field.getType().getName());
			String fieldname=field.getName();
			String fieldinfo=fieldxiu+" "+fieldleixing+" "+fieldname+";";
			System.out.println("\t"+fieldinfo);
		}
		//得到类中的构造方法
		Constructor constructorarr[]=stuclass2.getConstructors();
		for(Constructor con:constructorarr){
			String conxiu=Modifier.toString(con.getModifiers());
			String conname=testName(con.getName());
			StringBuilder  canshu=new StringBuilder();
			Class conptype[]=con.getParameterTypes();
			if(conptype.length!=0){
			for(Class  typeclass:conptype){
				String typename=testName(typeclass.getName());
				canshu.append(typename+" name,");
			}
			canshu.deleteCharAt(canshu.length()-1);
			}
			String  coninfo=conxiu+" "+conname+"("+canshu.toString()+"){}";
			System.out.println("\t"+coninfo);
		 }
		//得到实例方法
		Method  methodarr[]=stuclass2.getDeclaredMethods();
		for(Method  meth:methodarr){
			String mothxiu=Modifier.toString(meth.getModifiers());
			String tereturn=testName(meth.getReturnType().getName());
			String methname=meth.getName();
			StringBuilder  canshu=new StringBuilder();
			Class mathodptype[]=meth.getParameterTypes();
			if(mathodptype.length!=0){
			for(Class  typeclass:mathodptype){
				String typename=testName(typeclass.getName());
				canshu.append(typename+" args,");
			}
			canshu.deleteCharAt(canshu.length()-1);
			}
			String methodinfo=mothxiu+" "+tereturn+" "+methname+"("+canshu.toString()+") 
                {}";
			System.out.println("\t"+methodinfo);
		}
		System.out.println("}");
	}
}