访问方法（反射）

文章目录

前言

        为了实现在某类中随时可以调用其他类的方法，java.lang.reflect包中提供了Method方法类来实现该效果。每一个Method对象代表着一个方法，利用Methoc对象可以操纵相应的方法。

一、访问成员方法的方法

        Method类型的对象是指以成员方法为对象的变量。在我们获取成员方法时，根据需要指定Method类型对象是否为数组。

        实操展示：

        原调用方法的类 ：

public class Demo {
    public int add(int a,int b){
        System.out.println(a+"+"+b+"="+(a+b));
        return a+b;
    }
    private int minus(int a,int b){
        System.out.println(a+"-"+b+"="+(a-b));
        return a-b;
    }
}

        调用该方法的类：

import java.lang.reflect.*;
public class See{
    Demo demo = new Demo();
    Class class1=demo.getClass();
    Method method[] =class1.getDeclaredMethods();
    //获取demo类中所有的方法，返回形式为method类数组
}

         以上就是使用获取成员方法的方法，获取某类的成员方法的步骤了。先实例化该目标类，然后再获取该类的Class对象，最后使用上述表格中的方法即可。目的是在运行过程中，动态地获取和调整类的方法参数。

二、Method类

1.常用方法

2.实操展示

        实例：创建一个Demo类，在该类中创建多个不同的方法；创建See类，通过使用上述的方法获取到该类的所有方法的所有信息；创建Use类，通过使用上述方法和invoke()方法来调用，调参方法并且进行使用。

        Demo类：

public class Demo {
    //add()方法
    public int add(int a,int b){
        System.out.println(a+"+"+b+"="+(a+b));
        return a+b;
    }

    //minus方法
    private int minus(int a,int b){
        System.out.println(a+"-"+b+"="+(a-b));
        return a-b;
    }
    
    //insert方法
    public String insert(String str1,String str2){
        char char1[] = str1.toCharArray();
        char char2[] = str2.toCharArray();
        StringBuilder end = new StringBuilder();
        for(int i=0;i<=(char1.length+char2.length);i++){
            if (i<char1.length) {
                end.append(char1[i]);
            }
            if(i<char2.length){
                end.append(char2[i]);
            }
        }
        System.out.println(str1+"和"+str2+"插空排序的结果为："+end);
        return end.toString();
    }

    //nul方法
    public void nul(String...strings){
        StringBuilder result = new StringBuilder();
        for(int i=0;i<strings.length;i++){
            result.append(strings[i]);  
        }
        String string =result.toString();
        System.out.println("连接的字符串为："+string);
    }
    //综上四个方法
}

        See类：

import java.lang.reflect.*;
public class See{
    public static void main(String[] args) {
        Demo demo = new Demo();
        Class class1=demo.getClass();
        Method method[] =class1.getDeclaredMethods();
        try{ 
            for(int i=0;i<method.length;i++){
                //成员方法的名称
                System.out.println("该成员方法的名称："+method[i].getName());
                //成员方法的引用参数
                System.out.println("该成员方法的引用参数为：");
                Class parameterTypes[] = method[i].getParameterTypes();
                for(Class c:parameterTypes){
                    System.out.println(c);
                }
                //成员方法的返回类型
                System.out.println("成员方法的返回变量类型："+method[i].getReturnType());
                //成员方法的权限修饰符
                System.out.println("成员变量的修饰符权限："+Modifier.toString(method[i].getModifiers()));
                //成员方法可能报错的异常
                System.out.println("成员方法可能报错的异常:");
                Class class2[] = method[i].getExceptionTypes();
                for(Class c1:class2){
                    System.out.println(c1);
                }
                //查看该构造方法是否允许带有可变数量的参数
                boolean b=method[i].isVarArgs();
                System.out.println("查看该构造方法是否允许带有可变数量的参数："+b);
                System.out.println("------------------------------");
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

        运行结果：  

        如图所示，See类中使用了上述表格中的方法，显示了Demo类中有关各个方法的相关信息，方法名称、引用参数、返回变量、权限修饰符、异常报错等等。 

        Use类：

import java.lang.reflect.*;
public class Use {
    public static void main(String[] args) {
        Demo demo = new Demo();
        Class class1 = demo.getClass();
        Method method[] = class1.getDeclaredMethods();
        for(int i=0;i<method.length;i++){
            try {
                if(method[i].getName().equals("add")){
                    System.out.println("调用了Demo类的add()方法");
                    method[i].invoke(demo, 100,150);
                    
                }else if(method[i].getName().equals("minus")){
                    System.out.println("调用了Demo类的minus()方法");
                    method[i].invoke(demo, 100,350);
                          
                }else if(method[i].getName().equals("insert")) {
                    System.out.println("调用了Demo类的insert()方法");
                    method[i].invoke(demo, "aceg","BDFH");
                }else if(method[i].getName().equals("nul")){
                    System.out.println("调用了Demo类的nul()方法");
                    method[i].invoke(demo, new Object[]{new String[]{"你好", "，", "世界", "!"}});
                }
                        
                System.out.println("-------------------------------------");
            } catch (Exception e) {
                System.out.println("try-catch捕捉到异常，使用setAccessible()方法更改成员变量权限");
                method[i].setAccessible(true);
                try {
                    System.out.println("修改权限后，调用了Demo类的minus()方法");
                    method[i].invoke(demo,100,350);
                    System.out.println("-------------------------------------");
                } catch (Exception e2) {
                    e2.printStackTrace();
                }  
            }
        }
    }
}

        运行结果： 

         如图所示，Use类通过equals方法判断method数组中各个对应的方法，然后使用invoke()方法，输入被调用的类的实例化对象，调整方法引用参数，运行方法。有了异常后更改方法的权限，运行catch语句代码。

总结

        以上就是今天要讲的内容，本文仅仅简单介绍了访问成员方法的使用，而Method类提供了大量能使我们便捷地实时处理数据的方法，该类处于java.lang.reflect包下，指正和补充的内容欢迎在评论区中留言。