Java基础:反射机制重点回顾

语言: CN / TW / HK

theme: smartblue

持续创作,加速成长!这是我参与「掘金日新计划 · 6 月更文挑战」的第10天,点击查看活动详情

一、基本概念

主要是指程序可以访问、检测和修改它本身状态或行为的一种能力, 并能根据自身行为的状态和结果,调整或修改应用所描述行为的状态和相关的语义。Java 中,反射是一种强大的工具。它使您能够创建灵活的代码,这些代码可以在 运行时装配,无需在组件之间进行源代码链接。反射允许我们在编写与执行时,使我们的程序代码能够接入装载到 JVM 中的类的内部信息,而不是源代码中选定的类协作的代码。这使反射成为构建灵活的应用的主要工具。

  • 通过java中的反射机制可以操作字节码文件(读取和修改)
  • ==反射机制相关的类在java.lang.reflect.*;包下==

反射机制相关的重要的类:

    java.lang.Class:代表整个字节码,代表一个类型,代表整个类。
    java.lang.reflect.Method:代表字节码中的方法字节码。代表类中的方法。
    java.lang.reflect.Constructor:代表字节码中的构造方法字节码。代表类中的构造方法
    java.lang.reflect.Field:代表字节码中的属性字节码。代表类中的成员变量(静态变量+实例变量)。

二、在java中获取Class的三种方式

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

1.静态方法 2.参数是一个字符串 3.字符串是一个完整的包名 4.完整类名必须有包名,jana.lang也要写

java 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();

```java 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;(Class c = String.class;)

java //第三种方式: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类的无参构造方法,无参构造必须存在!如果没有这个无参数构造方法会出现"实例化"异常。

示例代码(1): User类: java public class User { public User() { System.out.println("无参数构造方法"); } } 测试类: ```java 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();
    }
}

}

``` 运行结果:

java 无参数构造方法 [email protected] 无参数构造方法 [email protected]

反射机制灵活性:可以做到不同对象的实例化,

资源绑定器:

java.util包下提供了一个资源绑定器,便于获取属性配置文件的内容,使用此方法时,属性文件必须在类路径下并且属性配置文件必须以.properties结尾。

示例代码:(2):

```java import java.util.ResourceBundle;

public class ResourceBundleText { public static void main(String[] args) { ResourceBundle bundle=ResourceBundle.getBundle("classinfo2"); String className=bundle.getString("className"); System.out.println(className); } } ``` 属性配置文件内容: 在这里插入图片描述 运行结果:

java ben.User

三、Field类详解

Field类常用方法:

(1)类<?> getDeclaringClass() 返回表示的类或接口声明的 Field对象表示的领域 类对象。 (2)int getModifiers() 返回的 Field对象表示的场java语言修饰符为整数。 (3)String getName() 返回的 Field对象表示的字段的名称。 (4)类<?> getType() 返回一个 类对象标识声明类型的 Field对象表示的场。 (5)String toString() 返回一个描述这个 Field字符串。

==反射Student类中的Field属性== 示例代码(3): Student类: ```java public class Student { //Field:字段 public int id ; private String name; protected int age; boolean sex; public static final double MATH_PI=301415926; }

``` 测试类:

```java 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();
    }
}

``` 运行结果:

```java 完整类型: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 ``` 反射机制进行反编译Student类 !! 示例代码(4):

```java import ben.Student;

import java.io.File; import java.lang.reflect.Field; import java.lang.reflect.Modifier; / 反射机制进行反编译!! / public class ReflectText06 { public static void main(String[] args) { try { StringBuilder s=new StringBuilder();

        Class studentClass=Class.forName("ben.Student");
       // Class studentClass=Class.forName("java.util.Date");
        s.append(Modifier.toString(studentClass.getModifiers())+"\t"+"class"+"\t"+studentClass.getSimpleName()+"{\n");
        Field[] fields=studentClass.getDeclaredFields();
        for (Field field:fields){
            s.append("\t");
            s.append(Modifier.toString(field.getModifiers()));
            s.append(" ");
            s.append(field.getType().getSimpleName());
            s.append(" ");
            s.append(field.getName());
            s.append(":\n");
        }
            s.append("}");
        System.out.println(s);

    } catch (ClassNotFoundException e) {
        e.printStackTrace();
    }
}

}

``` 运行结果:

java public class Student{ public int id: private String name: protected int age: boolean sex: public static final double MATH_PI: }

四、通过反射机制访问java对象的属性

给属性复制:set获取属性的值:get

示例代码(5): Student类: ```java public class Student { //Field:字段 public int id ; private String name; protected int age; boolean sex; public static final double MATH_PI=301415926; }

测试类: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();
    }
}

}

``` 运行结果:

java 2222 jack

五、通过反射机制调对象的方法

java Object invoke(Object obj, Object... args) 调用底层的方法,这 方法对象表示,对指定对象的指定参数。

示例代码(6): UserService类

java 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"); } } 测试类:

```java 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();
    }
}

}

``` 运行结果:

java 登陆成功 true

反射机制具有通用性,将可变化的内容放到配置文件中,无需改变java代码,只需修改配置文件

可变长参数

例如: int...args这是可变长参数 语法:类型... 1.可变长参数个数为0-N个 2. 可变长参数在参数列表中必须在最后一个位置上,而且可变长度参数只能有一个 3.可变长度参数可以是一个数组

示例代码(7):

```java public class ArgsText { public static void main(String[] args) { m(); m(1, 2); m(1, 2, 3);

    m2(1, "abc");
    m2(2, "cbv", "mcm");
    m2(3, "ncb", "mcn", "mnshs");


    m3("ab", "cd", "abc");
    String[] str = {"a", "b", "c", "d"};
    m3(str);
}

public static void m(int... args) {
    System.out.println("可变长参数方法");
}

public static void m2(int a, String... args) {

}

public static void m3(String... args) {
    for (int i = 0; i < args.length; i++) {
        System.out.println(args[i]);
    }
}

}

```