java反射机制

一、基本概念

（1）Java反射机制的核心是在程序运行时动态加载类并获取类的详细信息，从而操作类或对象的属性和方法。本质是JVM得到class对象之后，再通过class对象进行反编译，从而获取对象的各种信息。

（2）Java属于先编译再运行的语言，程序中对象的类型在编译期就确定下来了，而当程序在运行时可能需要动态加载某些类，这些类因为之前用不到，所以没有被加载到JVM。通过反射，可以在运行时动态地创建对象并调用其属性，不需要提前在编译期知道运行的对象是谁。

二、获取Class的三种方式 

 第一种：Class c = Class.forName("完整类名")

Class c1=null;
Class c2=null;
try {
    c1=Class.forName("java.lang.String");//c1代表String类型
    c2=Class.forName("java.util.Date"); //Date类型
    Class c3=Class.forName("java.lang.Integer");//Integer类型
    Class c4=Class.forName("java.lang.System");//System类型
} catch (ClassNotFoundException e) {
    e.printStackTrace();
}

第二种：Class c = 对象.getClass()

        String s="abc";
        Class x=s.getClass();//x代表String.class字节码文件，x代表String类型
        System.out.println(c1==x);//true（==判断两个对象的内存地址）

        Date date=new Date();
        Class y=date.getClass();
        System.out.println(c2==y);

第三种：Class c = int.class

//第三种方式：java中任何一个类型，包括基本数据类型，都有class属性
        Class z=String.class;//x代表String
        Class k=Date.class;//k代表Date
        Class f=int.class;//f代表int类型
        Class e=double.class;//e代表double类型

获取到class后，通过newinstance方法完成对象的创建。newinstance方法调用user类的无参构造方法。无参构造必须存在。

public class User {
    public User() {
        System.out.println("无参数构造方法");
    }
}

import ben.User;


public class ReflectText02 {
    public static void main(String[] args) {
        //不使用反射机制
        User user = new User();
        System.out.println(user);
        
        //反射机制创建对象
        try {
            //通过反射机制获取Class,通过Class实例化对象
            Class c = Class.forName("ben.User");//c代表User类型
            //newInstance方法会调用User类的无参构造方法，完成对象的创建
           
            Object obj = c.newInstance();
            System.out.println(obj);
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        } catch (InstantiationException e) {
            e.printStackTrace();
        }
    }
}

无参数构造方法
ben.User@10f87f48
无参数构造方法
ben.User@b4c966a

 通过class获取field

public class Student {
    //Field:字段
    public int id ;
    private String name;
    protected int age;
    boolean sex;
    public static final double MATH_PI=301415926;
}

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


public class ReflectText05 {
    public static void main(String[] args) {
        try {
            Class studenClass=Class.forName("ben.Student");

            String className=studenClass.getName();
            System.out.println("完整类型："+className);
            String simpleName=studenClass.getSimpleName();
            System.out.println("简单类名："+simpleName);
            System.out.println("==============================");
           
            //获取类中的Filed
            Field[] fileds=studenClass.getFields();
            System.out.println(fileds.length);//1
           
            //取出这个Field
            Field f=fileds[0];
            String fieldName=f.getName();
            System.out.println(fieldName);
            
            //取出所有的Field
            Field[] fs=studenClass.getDeclaredFields();
            System.out.println(fs.length);//4
            System.out.println("=========================");
           
            for (Field field: fs){
                //获取属性的修饰符列表
                int i=field.getModifiers();
                System.out.println(i);

                String modfiersString= Modifier.toString(i);
                System.out.println(modfiersString);
              
                //获取属性的类型
                Class fieldType=field.getType();
                //String fNum=fieldType.getName();
                String fNum=fieldType.getSimpleName();
                System.out.println(fNum);
              
                //获取属性名字
                System.out.println(field.getName());
               // System.out.println(field);
            }
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
    }

结果 

完整类型：ben.Student
简单类名：Student
==============================
2
id
5
=========================
1
public
int
id
2
private
String
name
4
protected
int
age
0

boolean
sex
25
public static final
double
MATH_PI

 getModifiers()方法的输出

修饰符	对应的int类型
public	1
private	2
protected	4
static	8
final	16
synchronized	32
volatile	64
transient	128
native	256
interface	512
abstract	1024
strict	2048

 访问java对象的属性

import java.lang.reflect.Field;

public class ReflectText07 {
    public static void main(String[] args) {
        try {
            Class studentClass=Class.forName("ben.Student");
            Object obj=studentClass.newInstance();//obj就是Student对象。（无参构造）
            //获取no属性（根据属性的名称获取Field）
            Field noField=studentClass.getDeclaredField("id");
            //给obj对象的no属性赋值
            noField.set(obj,2222 );//给no属性赋值2222
            //读取值
            System.out.println( noField.get(obj));


            Field nameFiled=studentClass.getDeclaredField("name");
            //打破封装，反射机制缺点
            nameFiled.setAccessible(true);
            //赋值
            nameFiled.set(obj,"jack");
            //获取
            System.out.println(nameFiled.get(obj));
            
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        } catch (InstantiationException e) {
            e.printStackTrace();
        } catch (NoSuchFieldException e) {
            e.printStackTrace();
        }
    }
}

核心代码是feild.set(obj,"")

222

jack

通过invoke()调对象的方法 

public class UserService {
    public boolean login(String name, String password) {
        if ("admin".equals(name) && "123".equals(password)) {
            return true;
        }
        return false;
    }
    public void logout(){
        System.out.println("退出系统成功！1");
    }
}

import ben.UserService;

import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;


public class ReflectText08 {
    public static void main(String[] args) {
        UserService userService=new UserService();
        boolean loginSuccess=userService.login("admin","123");
       // System.out.println(loginSuccess);
        System.out.println(loginSuccess?"登陆成功":"登陆失败");

        try {
            Class userServiceClass =Class.forName("ben.UserService");
            //创建对象
            Object obj=userServiceClass.newInstance();
            //获取login方法
            Method loginMethod=userServiceClass.getDeclaredMethod("login", String.class, String.class);
            //调用方法 
            Object retValue=loginMethod.invoke(obj,"admin","123");
            System.out.println(retValue);
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        } catch (InstantiationException e) {
            e.printStackTrace();
        } catch (NoSuchMethodException e) {
            e.printStackTrace();
        } catch (InvocationTargetException e) {
            e.printStackTrace();
        }
    }
}