Java——反射机制（下）

BerglingYY

已于 2022-04-03 17:50:50 修改

阅读量674

点赞数

分类专栏： JAVA笔记文章标签： java

于 2022-04-03 15:38:27 首次发布

本文链接：https://blog.csdn.net/weixin_62838185/article/details/123916173

版权

JAVA笔记专栏收录该内容

61 篇文章 9 订阅

订阅专栏

本文详细介绍了Java反射机制，包括反射Method、构造方法、调用方法和构造方法的反编译。通过实例展示了如何获取类的方法和构造器，并使用反射进行方法调用和对象创建。此外，还讲解了如何获取类的父类和实现的接口，揭示了反射在代码通用性和动态性方面的优势。

摘要由CSDN通过智能技术生成

反射Method

用户登录类

package lit.jxxxy.ry15.java.thread.service;

/**
 * @author 华为
 */
public class UserService {

    /**
     *Login Method
     * @param name UserName
     * @param password  UserPassword
     * @return  True-Success / False-Fail
     */
    public boolean login(String name, String password){

        if("admin".equals(name) && "638721".equals(password)){
            return true;
        }
        return false;
    }

    /**
     * Exit
     */
    public void logout(){
        System.out.println("System exits!");
    }
}

package com.bjpowernode.java.reflect;

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

/*
作为了解内容（不需要掌握）：
    反射Method
 */
public class ReflectTest08 {
    public static void main(String[] args) throws Exception{

        // 获取类了
        Class userServiceClass = Class.forName("lit.jxxxy.ry15.java.thread.service.UserService");

        // 获取所有的Method（包括私有的！）
        Method[] methods = userServiceClass.getDeclaredMethods();
        //System.out.println(methods.length); // 2

        // 遍历Method
        for(Method method : methods){
            // 获取修饰符列表
            System.out.println(Modifier.toString(method.getModifiers()));
            // 获取方法的返回值类型
            System.out.println(method.getReturnType().getSimpleName());
            // 获取方法名
            System.out.println(method.getName());
            // 方法的修饰符列表（一个方法的参数可能会有多个。）
            Class[] parameterTypes = method.getParameterTypes();
            for(Class parameterType : parameterTypes){
                System.out.println(parameterType.getSimpleName());
            }
        }
    }
}

反编译Method（了解）

    public static void main(String[] args) throws Exception{
        StringBuilder s = new StringBuilder();
        //Class userServiceClass = Class.forName("com.bjpowernode.java.service.UserService");
        Class userServiceClass = Class.forName("java.lang.String");
        s.append(Modifier.toString(userServiceClass.getModifiers()) + " class "+userServiceClass.getSimpleName()+" {\n");

        Method[] methods = userServiceClass.getDeclaredMethods();
        for(Method method : methods){
            //public boolean login(String name,String password){}
            s.append("\t");
            s.append(Modifier.toString(method.getModifiers()));
            s.append(" ");
            s.append(method.getReturnType().getSimpleName());
            s.append(" ");
            s.append(method.getName());
            s.append("(");
            // 参数列表
            Class[] parameterTypes = method.getParameterTypes();
            for(Class parameterType : parameterTypes){
                s.append(parameterType.getSimpleName());
                s.append(",");
            }
            // 删除指定下标位置上的字符
            s.deleteCharAt(s.length() - 1);
            s.append("){}\n");
        }

        s.append("}");
        System.out.println(s);
    }

反射机制调用方法

调用方法
要素分析：
要素1：对象userService
要素2：login方法名
要素3：实参列表
要素4：返回值

不使用反射机制，怎么调用方法


        // 创建对象
        UserService userService = new UserService();
        // 调用方法
        boolean loginSuccess = userService.login("admin","123");

使用反射机制来调用一个对象的方法

        Class userServiceClass = Class.forName("lit.jxxy.rg.java.service.UserService");
        // 创建对象
        Object obj = userServiceClass.newInstance();
        // 获取Method
        Method loginMethod = userServiceClass.getDeclaredMethod("login", String.class, String.class);
        //调用方法
        Object retValue = loginMethod.invoke(obj, "admin","123123");
        System.out.println(retValue);

分析四要素：
loginMethod方法
obj对象
"admin","123" 实参
retValue 返回值

反射机制，让代码很具有通用性，可变化的内容都是写到配置文件当中，
将来修改配置文件之后，创建的对象不一样了，调用的方法也不同了，
但是java代码不需要做任何改动。这就是反射机制的魅力。

反射Costructor

反编译一个类的Constructor构造方法。

public class Vip {
    int no;
    String name;
    String birth;
    boolean sex;

    public Vip() {
    }

    public Vip(int no) {
        this.no = no;
    }

    public Vip(int no, String name) {
        this.no = no;
        this.name = name;
    }

    public Vip(int no, String name, String birth) {
        this.no = no;
        this.name = name;
        this.birth = birth;
    }

    public Vip(int no, String name, String birth, boolean sex) {
        this.no = no;
        this.name = name;
        this.birth = birth;
        this.sex = sex;
    }

    @Override
    public String toString() {
        return "Vip{" +
                "no=" + no +
                ", name='" + name + '\'' +
                ", birth='" + birth + '\'' +
                ", sex=" + sex +
                '}';
    }
}

反编译（了解）

/*
反编译一个类的Constructor构造方法。
 */
public class ReflectTest11 {
    public static void main(String[] args) throws Exception{
        StringBuilder s = new StringBuilder();
        Class vipClass = Class.forName("java.lang.String");
        s.append(Modifier.toString(vipClass.getModifiers()));
        s.append(" class ");
        s.append(vipClass.getSimpleName());
        s.append("{\n");

        // 拼接构造方法
        Constructor[] constructors = vipClass.getDeclaredConstructors();
        for(Constructor constructor : constructors){
            //public Vip(int no, String name, String birth, boolean sex) {
            s.append("\t");
            s.append(Modifier.toString(constructor.getModifiers()));
            s.append(" ");
            s.append(vipClass.getSimpleName());
            s.append("(");
            // 拼接参数
            Class[] parameterTypes = constructor.getParameterTypes();
            for(Class parameterType : parameterTypes){
                s.append(parameterType.getSimpleName());
                s.append(",");
            }
            // 删除最后下标位置上的字符
            if(parameterTypes.length > 0){
                s.deleteCharAt(s.length() - 1);
            }
            s.append("){}\n");
        }

        s.append("}");
        System.out.println(s);
    }
}

反射机制调用构造方法

不使用反射机制怎么创建对象

        Vip v1 = new Vip();
        Vip v2 = new Vip(110, "zhangsan", "2001-10-11", true);

使用反射机制

        // 使用反射机制创建对象
        Class c = Class.forName("lit.jxxy.rg.java.bean.Vip");
        // 调用无参数构造方法
        Object obj = c.newInstance();
        System.out.println(obj);

        // 第一步：先获取到这个有参数的构造方法
        Constructor con = c.getDeclaredConstructor(int.class, String.class, String.class,boolean.class);
        // 第二步：调用构造方法new对象
        Object newObj = con.newInstance(110, "jackson", "1990-10-11", true);
        System.out.println(newObj);

        // 获取无参数构造方法
        Constructor con2 = c.getDeclaredConstructor();
        Object newObj2 = con2.newInstance();
        System.out.println(newObj2);

获取父类和父接口

重点：给你一个类，怎么获取这个类的父类，已经实现了哪些接口

        // String举例
        Class stringClass = Class.forName("java.lang.String");

        // 获取String的父类
        Class superClass = stringClass.getSuperclass();
        System.out.println(superClass.getName());

        // 获取String类实现的所有接口（一个类可以实现多个接口。）
        Class[] interfaces = stringClass.getInterfaces();
        for(Class in : interfaces){
            System.out.println(in.getName());
        }