Java学习总结（十四）——java反射机制，利用反射动态创建对象

• "]";
  }

}

获取Class类对象测试类
package org.reflect.Class;

import java.lang.reflect.Modifier;
public class ClassDemo {

public static void main(String[] args) {
    Student stu=new Student();
    Class<?> c1=stu.getClass();//方式一
    Class<Student> c2= Student.class;//方式二
    Class<?> c3=null;
    try {
        c3=Class.forName("org.reflect.Class.Student");   // 方式三
    } catch (ClassNotFoundException e) {
        e.printStackTrace();
    }
    System.out.println("方式一获取的Class对象为："+c1.getSimpleName());
    System.out.println("方式二获取的Class对象为："+c2);
    System.out.println("方式三获取的Class对象为："+c3);
    int mod=c1.getModifiers();//获取修饰符所对应的整数
    String modifier=Modifier.toString(mod);//获取修饰符
    System.out.println(c1+"类所用的修饰符为："+modifier);
}

}

运行结果：
方式一获取Class类对象：Student
方式二获取Class类对象：reflect.Student
方式三获取Class类对象：reflect.Student
Student类的修饰符：public
6.使用Class类获取类的结构信息
（1）获取类的Class对象：

（2）获取Filed对象

（3）获取Method对象

（4）获取Constructor对象

代码示例（示例均已上述Student类为基础）
例1（获取Filed对象）
package org.reflect.Filed;
import java.lang.reflect.Field;
import java.lang.reflect.Modifier;
public class FiledDemo {

public static void main(String[] args) {
    Class<Student> cl=Student.class;//获取代表Student类的Class对象
    Field[] fields=cl.getDeclaredFields();//获取属性对象，返回数组
    System.out.println(cl.getSimpleName()+"类中声明的属性有：");
    for(Field f:fields){
        String filedName=f.getName();//获取属性名
        Class<?> filedType=f.getType();//获取属性类型
        int mod=f.getModifiers();//获取修饰符对应整数
        String modifier=Modifier.toString(mod);//获取修饰符
        System.out.println(modifier+" "+filedType.getSimpleName()+" "+filedName);
    }
}

}

运行结果：
Student类中声明的属性有：
private String name
private int age
private double score
例2（获取Method对象）
package method;

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

public class MethodDemo {

public static void main(String[] args) {
    try {
        Class<?> cls=Class.forName("method.Student");
        Method[] methods=cls.getDeclaredMethods();
        for(Method method:methods){
            String methodName=method.getName();   // 获取方法名称
            Class<?> returnType=method.getReturnType();  // 获取方法的返回值类型
            String modStr=Modifier.toString(method.getModifiers());   // 获取方法的修饰符
            Class<?>[] paramTypes=method.getParameterTypes();   // 获取参数类型
            System.out.print(modStr+" "+returnType.getSimpleName()+" "+methodName+"(");
            if(paramTypes.length==0){
                System.out.print(")");
            }
            for(int i=0;i<paramTypes.length;i++){   // 遍历形式参数类型
                if(i==paramTypes.length-1){
                    System.out.print(paramTypes[i].getSimpleName()+" args"+i+")");
                }else{
                    System.out.print(paramTypes[i].getSimpleName()+" args"+i+",");
                }
            }
            System.out.println();
        }
    } catch (Exception e) {
        e.printStackTrace();
    }

}

}

运行结果：
public void eat(String args0,String args1)
public int getAge()
public void setAge(int args0)
public double getScore()
public void setScore(double args0)

7.使用反射动态创建对象
（1）方法一：
使用Class的newInstance()方法，仅适用于无参构造方法

（2）方法二：
方法二：调用Constructor的newInstance()方法，适用所有构造方法

例3（获取Constructor对象）
package org.reflect.Constructor;

import java.lang.reflect.Constructor;

public class ConstructorDemo {

public static void main(String[] args) {
    Class<Student> cl=Student.class;//获取Class对象，代表Student类
    try {
        Constructor<Student> con=cl.getDeclaredConstructor(String.class,int.class,double.class);//获取散参构造方法
        Student stu=con.newInstance("张无忌",23,96.7);
        System.out.println(stu);
    } catch (Exception e) {
        e.printStackTrace();
    } 
}

}
运行结果：
Student [name=张无忌, age=23, score=96.7]
例4（动态创建方法）：
package method;

import java.lang.reflect.Method;

public class InvokeMethod {

public static void main(String[] args) {
    Class<Student> cls=Student.class;
    try {
        Student stu=cls.newInstance();   // 通过反射机制实例化对象,使用此newInstance()方法，要求类中必须包含一个无参构造方法
        Method setNameMethod=cls.getMethod("setName",String.class);
        setNameMethod.invoke(stu,"风清扬");   // 使用stu对象调用setName(String name)方法，传入"风清扬"参数
        Method getNameMethod=cls.getMethod("getName");
        System.out.println(getNameMethod.invoke(stu));  // 使用stu对象调用getName()方法，返回一个值
    } catch (Exception e) {
        e.printStackTrace();
    } 

}

}
运行结果：
风清扬