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

一．Java反射机制
1.什么是反射：反射就是把Java类中的各种成份影射成一个个的Java对象。例：一个类有：成员变量，方法，构造方法等，包等等信息，利用反射技术可以对一个类进行剖析，把各个组成部分影射成一个个对象。
2.Java反射常用类：
（1）Class类—可获取类和类的成员信息
（2）Field类—可访问类的属性
（3）Method—可调用类的方法
（4）Constructor—可调用类的构造方法
3.如何使用反射（基本步骤）：
（1）导入java.lang.reflect.*
（2）获得需要操作的类的Java.lang.Class对象
（3）调用Class的方法获取Field,Method等对象
（4）使用反射API进行操作（设置属性，调用方法）
4.Class类：
（1）Class类是Java反射机制的起源和入口
（2）Class类的实例化对象代表一个正在运行的Java类或接口
·每个类都有自己的Class对象
·用于获取与类相关的各种信息
·提供了获取类信息的相关方法
·Class类继承至Object类
（3）Class类存放类的结构信息
·类名；·父类，接口；·方法，构造方法，属性；·注释
5.获取Class类对象的三种方式：
（1）方法一：
//方法1：对象.getClass()
Student stu=new Student();
Class clazz=stu.getClass();
（2）方法二：
//方法2：类.class
Class clazz= Student.class;
Class clazz=String.class;
方法三：
//方法3：Class.forName()
clazz=Class.forName("java.lang.String");
clazz=Class.forName("java.util.Date");
例（代码）：
学生信息类（bean）

package org.reflect.Class;

public class Student {
    private String name;
    private int age;
    private double score;

    public Student() {
    }

    public Student(String name, int age, double score) {
        this.name = name;
        this.age = age;
        this.score = score;
    }

    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 double getScore() {
        return score;
    }

    public void setScore(double score) {
        this.score = score;
    }

    public void learn() {
        System.out.println(this.name + "正在学习...");
    }

    @Override
    public String toString() {
        return "Student [name=" + name + ", age=" + age + ", score=" + score
                + "]";
    }

}

获取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();
        } 

    }

}

运行结果：
风清扬

转载于:https://blog.51cto.com/13501268/2104207