java中反射知识点总结

package Demo;

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

public class Test {

    public static void main(String[] args) {
        Class clazz;
        try {
            //01:clazz = Class.forName("Demo.Student");
            //02:clazz=Student.class;
            clazz=new Student().getClass().getSuperclass();//03:并获取父类
            System.out.println(clazz);
            //获取基本数据类型的类 byte short int long float double boolean char
            clazz=Byte.TYPE;
            //输出byte
            System.out.println(clazz);
            clazz=Short.TYPE;
            clazz=Integer.TYPE;
            clazz=Long.TYPE;
            clazz=Float.TYPE;
            clazz=Double.TYPE;
            clazz=Boolean.TYPE;
            clazz=Character.TYPE;
            
            //获取基本数据类型本身的类 class java.lang.Byte
            clazz=Byte.class;
            System.out.println(clazz);
            clazz=Short.class;
            clazz=Integer.class;
            clazz=Long.class;
            clazz=Float.class;
            clazz=Double.class;
            clazz=Boolean.class;
            clazz=Character.class;
            
            //获取数组对应的类  例如下为class  java.lang.String
            String [] name=new String[8];
            clazz=String[].class;
            System.out.println(clazz);
            
            
            
            
            //获取类中的构造方法
            //获取public级别的构造方法
            clazz=Class.forName("Demo.Student");
            //Constructor[] constructors=clazz.getConstructors();
            /*for (Constructor constructor : constructors) {
                System.out.println(constructor);
            }*/
            
            //获取所有的构造方法
            Constructor[] constructors=clazz.getDeclaredConstructors();
            for (Constructor constructor : constructors) {
                System.out.println(constructor);
            }
            
            //获取单个public级别的构造方法
            Constructor c=clazz.getConstructor(Integer.TYPE);
            
            //获取各种级别的某个构造方法
            c=clazz.getDeclaredConstructor(String.class);
            
            
            
            
            
            
            
            
            
            //使用某个构造方法创建对象
            c.setAccessible(true);
            Object object=c.newInstance("小李");//相当于上转型对象
            System.out.println(object);
            
            //直接使用类创建对象，局限与无参
            Object obj=clazz.newInstance();
            System.out.println(obj);
            //获取对应构造方法的参数对应的类数组
            Class [] types=c.getParameterTypes();
            for (Class type : types) {
                //System.out.println(type);
            }
            
            //获取构造方法所在的类
            Object class1=c.getDeclaringClass();
            //System.out.println(class1);
            
            //获取构造方法的访问权限
            int result=c.getModifiers();
            String authority=Modifier.toString(result);
            //System.out.println(authority);
            
            //获取构造方法的名字
            String constructorName=c.getName();
            //System.out.println(constructorName);
            


            
            
            
            
            
            
            
            
            //获取public级别的方法  并且会获取到继承的public的方法
            Method [] methhods=clazz.getMethods();
            for (Method method : methhods) {
                //System.out.println(method.getName());
            }
        
            //获取本类中的所有的方法
            Method [] methods1=clazz.getDeclaredMethods();
            for (Method method : methods1) {
                //System.out.println(method.getName());
            }
            
            
            //调用类中的方法
                        //获取某个方法
            Method m=clazz.getDeclaredMethod("getName", String.class,Integer.TYPE,int [].class);
                        //以下代表为调用了这个方法，并且传入了参数
            m.setAccessible(true);//一般这个方法是私有的才会设置
            //m.invoke(clazz.getConstructor(Integer.TYPE).newInstance(15), "liyinxia",15,new int[] {0,1,2,3});
            
            //获取方法所在的类
            Class class2 = m.getDeclaringClass();
            //System.out.println(class2);
            
            //获取方法的访问权限
            /*int res=m.getModifiers();
            String authorityName=Modifier.toString(res);
            System.out.println(authorityName);*/
            
            //获取方法的名字
            /*String name3=m.getName();
            System.out.println(name3);*/
            
            //获取方法的参数
            /*Object [] parameterTypes=m.getParameterTypes();
            for (Object parameterType : parameterTypes) {
                System.out.println(parameterType);
            }*/
            
            
            //获取方法的返回值类型
            Class returnType=m.getReturnType();
            //System.out.println(returnType);
            
            //返回由Method对象表示方法抛出异常类型对应Class对象组成的数组
            Class [] exceptionTypes = m.getExceptionTypes();
            System.out.println("异常的个数"+exceptionTypes.length);
            /*for (Class exceptionType : exceptionTypes) {
                System.out.println(exceptionType);
            }*/
            
            
            
            
            //获取属性
            Field shuXing=clazz.getField("name");
            
            Object instance=clazz.getDeclaredConstructor().newInstance();
            //设置属性的值
            shuXing.set(instance, "xiaowang");
            //获取属性的值
            String name4=(String) shuXing.get(instance);
            System.out.println(name4);
            
            
            
        } catch (NoSuchMethodException e) {
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (InstantiationException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (IllegalArgumentException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (InvocationTargetException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (NoSuchFieldException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (SecurityException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        
    }
}

以上代码已经非常详细的讲述了反射所具有的使用方法。。。。。。。。。仔细研究，其实也很简单，主要要理解反射存在的意义。

反射：是一种新的操作类中的构造方法，成员变量，普通方法的机制。