JAVA016--反射

//1、获取Class对象–所有类型都有Class对象，包括引用类型、基本类型、void类型

//1-1、通过实例对象，获取该实例的Class对象

    //该方式只能用于获取引用类型的Class对象
    //该方式不具备动态效果---在运行之前的加载期间JVM已经产生好了Student的Class对象
    Student stu0 = new Student("zhang3",18);
    Class stuClass0 = stu0.getClass();//getClass方法来自于Object
    int[] array = new int[10];
    Class intArrayClass0 = array.getClass();

//1-2、通过类型名称获取Class对象

    //该方式可以取得所有类型的Class对象
    //该方式不具备动态效果---在运行之前的加载期间JVM已经产生好了Student的Class对象
    Class stuClass1 = Student.class;

// System.out.println(stuClass0 == stuClass1);//一个类的Clas对象只有一个
Class intArrayClass1 = int[].class;
Class intClass0 = int.class;//只能在JDK1.5以后使用
Class intClass1 = Integer.TYPE;//JDK1.5以前使用
// System.out.println(intClass0 == intClass1);
Class voidClass = void.class;

//1-3、通过类型名称的字符串形式，获取Class对象

    //该方式只能获取类类型或接口类型的Class对象
    //唯一一种具备动态性的反射方式---在运行之前的加载期间JVM不知道要用到Student，
    //                           是在运行到这句代码的时候才被通知要加载这个类。
    try {
        Class stuClass2 = Class.forName("com.lovo.bean.Student");

// System.out.println(stuClass2 == stuClass0);
} catch (ClassNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}

//2、探究这个类的信息

//2-0、探究类的申明部分–无需掌握

    String className = stuClass0.getName();//得到类全名
    className = stuClass0.getSimpleName();//得到类的简单类名
    String packageName = stuClass0.getPackage().getName();//得到包对象，然后得到包名
    String modStr = Modifier.toString(stuClass0.getModifiers());//得到修饰符
    String superClassName = stuClass0.getSuperclass().getName();//得到父类的名字
    Class[] allInters = stuClass0.getInterfaces();//得到该类实现的接口
    String interStr = "";//拼接接口名
    for(int i = 0; i < allInters.length; i++){
        interStr += allInters[i].getSimpleName();
        if(i != allInters.length - 1){
            interStr += ",";
        }
    }
    System.out.println("package " + packageName + ";");
    System.out.println(modStr + " class " + className + 
            " extends " + superClassName + " implements " + interStr + "{");

//2-1、属性的探究

    Field[] allPublicFields = stuClass0.getFields();//得到所有的公共属性
    Field[] allFields = stuClass0.getDeclaredFields();//得到所有声明的属性
    //可以根据属性名得到指定的属性
    try {
        Field fieldPublic = stuClass0.getField("name");//得到指定的公共属性
        Field field = stuClass0.getDeclaredField("age");//得到指定的声明了的属性
    } catch (NoSuchFieldException e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
    } catch (SecurityException e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
    }

    for(Field f : allFields){
        String fieldName = f.getName();//属性名
        String typeName = f.getType().getSimpleName();//属性类型
        String fModStr = Modifier.toString(f.getModifiers());//属性修饰符
        System.out.println("\t" + fModStr + " " + typeName + " " + fieldName + ";");
    }
    System.out.println();

//2-2、构造的探究

    Constructor[] allPublicCons = stuClass0.getConstructors();//得到所有公共的构造
    Constructor[] allCons = stuClass0.getDeclaredConstructors();//得到所有申明的构造

    try {
        Constructor conPublic = stuClass0.getConstructor(String.class,int.class);//得到指定的某个公共构造
        Constructor con = stuClass0.getDeclaredConstructor();//得到指定的某个声明构造
    } catch (NoSuchMethodException e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
    } catch (SecurityException e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
    }//得到指定的公共构造

    for(Constructor con : allCons){
        String consName = stuClass0.getSimpleName(); //得到构造名字--就是类名
        String consModstr = Modifier.toString(con.getModifiers());//得到访问修饰符
        Class[] params = con.getParameterTypes();//得到所有的参数
        String paramStr = "";
        for(int i = 0; i < params.length; i++){
            paramStr += params[i].getSimpleName();
            if(i != params.length - 1){
                paramStr += ",";
            }
        }
        System.out.print("\t"+consModstr+" "+consName+"("+paramStr+")");
        Class[] exceptions = con.getExceptionTypes();//得到异常
        if(exceptions != null && exceptions.length != 0){
            String excStr = "";
            for(int i = 0; i < exceptions.length; i++){
                excStr += exceptions[i].getSimpleName();
                if(i != exceptions.length - 1){
                    excStr += ",";
                }
            }
            System.out.print(" throws " + excStr);
        }
        System.out.println("{");
        System.out.println("\t}");
    }
    System.out.println();

//2-3、行为的探究

    Method[] allPublicMethods = stuClass0.getMethods();//得到所有的公共方法
    Method[] allMethods = stuClass0.getDeclaredMethods();//得到所有声明的方法

    try {
        Method methodPublic = stuClass0.getMethod("run");//得到某个指定的公共方法
        Method method = stuClass0.getDeclaredMethod("study",int.class);//得到某个指定的声明方法
    } catch (NoSuchMethodException e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
    } catch (SecurityException e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
    }
    for(Method m : allMethods){
        String methodName = m.getName();//得到方法名
        Class[] params = m.getParameterTypes();//得到所有的参数
        String paramStr = "";
        for(int i = 0; i < params.length; i++){
            paramStr += params[i].getSimpleName();
            if(i != params.length - 1){
                paramStr += ",";
            }
        }
        String returnType = m.getReturnType().getSimpleName();//得到返回类型的名字
        String methodModStr = Modifier.toString(m.getModifiers());
        System.out.print("\t"+methodModStr+" "+returnType+" "+methodName+"("+paramStr+")");
        Class[] exceptions = m.getExceptionTypes();//得到异常
        if(exceptions != null && exceptions.length != 0){
            String excStr = "";
            for(int i = 0; i < exceptions.length; i++){
                excStr += exceptions[i].getSimpleName();
                if(i != exceptions.length - 1){
                    excStr += ",";
                }
            }
            System.out.print(" throws " + excStr);
        }
        System.out.println(";");
    }

    System.out.println("}");

//3、操作探究出来的信息

//3-1、通过探究出来的构造方法，产生实例对象—newInstance()

    try {
        //3-1-1、调用Constructor对象的newInstance方法产生实例对象
        //可以调用任意一个指定的公共构造方法的
        Constructor con = stuClass0.getConstructor(String.class,int.class);
        Student stu = (Student)con.newInstance("zhang3",18);
        //3-1-2、调用Class对象的newInstance方法产生实例对象(使用率最高)
        //只能调用公共无参构造
        Student theStu = (Student)stuClass0.newInstance();

    } catch (NoSuchMethodException e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
    } catch (SecurityException 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();
    }

//3-2、通过探究出来的属性，完成对属性的赋值(set())取值(get())

    try {
        Field theField = stuClass0.getDeclaredField("age");
        /**
         * 只准看，不准用
         */
        theField.setAccessible(true);//设置访问权限为真
        theField.set(stu0, 18);//对属性进行赋值（第一个参数是被赋值的实例对象）
        System.out.println(theField.get(stu0));//对属性进行取值
    } catch (NoSuchFieldException e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
    } catch (SecurityException e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
    } catch (IllegalArgumentException e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
    } catch (IllegalAccessException e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
    }

//3-3、通过探究出来的方法，进行调用—invoke()

    try {
        Method m = stuClass0.getMethod("study", int.class);
        boolean flag = (Boolean)m.invoke(stu0, 5);
        System.out.println("返回的是：" + flag);
    } catch (NoSuchMethodException e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
    } catch (SecurityException 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();
    }

结果为

公共带参构造
package com.lovo.bean;
public final class Student extends java.lang.Object implements Runnable,Serializable{
public String name;
private int age;

public Student(){
}
public Student(String,int){
}

public void run();
public String getName();
public void setName(String);
public boolean study(int) throws Exception;
public void setAge(int);
public int getAge();

}
公共带参构造
公共无参构造
18
我要好好学习!
我要好好学习!
我要好好学习!
我要好好学习!
我要好好学习!
返回的是：false

附加 student源文件代码

package com.lovo.bean;

import java.io.Serializable;

public final class Student implements Runnable,Serializable{

    public String name;

    private int age;

    public Student(){
        System.out.println("公共无参构造");
    }

    public Student(String name, int age){
        System.out.println("公共带参构造");
        this.name = name;
        this.age = age;
    }

    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;
    }

    public boolean study(int a) throws Exception{
        for(int i = 0; i < a; i++){
            System.out.println("我要好好学习!");
        }
        if(a <= 5){
            return false;
        }
        return true;
    }

    @Override
    public void run() {
        // TODO Auto-generated method stub

    }



}