javase-reflect-210709-03

javase-reflect-210709-03

• 可变参数长度
• 反射获取Method-01
• 反射获取Method-02
• 通过反射调用方法
• UserService.java

---

可变参数长度

ReflectMethodTest01.java

package bgy_reflect_method_210709_01;
/*
    可变长度参数
    int... args 就是可变长度参数

    1. 可变长度参数要求的参数个数是：0~N个
    2. 可变长度参数在参数列表中必须在最后一个位置上
    3. 可变长度参数可以当做一个数组来看
 */
public class ReflectMethodTest01 {
    public static void main(String[] args) {
        test();

        test(10);
        test(10,"10",10);

        // 如果方法名相同，参数个数一样，参数类型不同，会报错
        // 它不知道调用哪个test
//        test("aaa");

        // 编译器报错，参数类型保持一致
//        test(true);


        t(1,2,3,4,5,6);

        // 也可以传一个数组
        int[] numbers = {10,20,30,40};
        t(numbers);
    }

    public static void test(int... args){
        System.out.println("test方法执行了");
    }

    // int... 必须放在最后一个
    public static void test(int c1,String c2,int... args){
        System.out.println("test方法执行了");
    }

//    public static void test(String... args){
//        System.out.println("test方法执行了");
//    }

//    public static void test(int... args,int... args){}

    public static void t(int... args){
        // args有length属性，说明args是一个数组
        // 可以把它当做一个数组来看
        for (int i = 0; i < args.length; i++) {
            System.out.println(args[i]);
        }
    }
}

---

反射获取Method-01

ReflectMethodTest02.java

package bgy_reflect_method_210709_01;

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

/*
    反射Method（方法）
 */
public class ReflectMethodTest02 {
    public static void main(String[] args) throws Exception {

        // 获取类
        Class userServiceClass = Class.forName("bgy_reflect_method_210709_01.UserService");
        // 获取所有的Method（包括私有的）
        Method[] methods = userServiceClass.getDeclaredMethods();
        System.out.println("fields长度为："+methods.length);
        // 遍历Method
        for (Method method : methods) {
            // 获取修饰符
            System.out.println(Modifier.toString(method.getModifiers()));
            // 获取返回类型
            System.out.println(method.getReturnType());
            // 获取方法名
            System.out.println(method.getName());
            // 获取方法参数的修饰符列表，因为方法参数可能会有多个
            Class[] parameterTypes = method.getParameterTypes();
            for (Class parameterType : parameterTypes){
                System.out.println(parameterType.getSimpleName());
            }

            // 换行，控制台看者舒服
            System.out.println();
        }
    }
}

---

反射获取Method-02

ReflectMethodTest03.java

package bgy_reflect_method_210709_01;
/*
    获取Method
 */

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

public class ReflectMethodTest03 {
    public static void main(String[] args) throws Exception {
        // 追加用
        StringBuffer s = new StringBuffer();

        // 获取类
        Class userService = Class.forName("bgy_reflect_method_210709_01.UserService");
//        Class userService = Class.forName("java.lang.String");

        // 追加UserService头儿
        s.append(Modifier.toString(userService.getModifiers())+" class "+ userService.getSimpleName()+"{\n");

        // 获取 Method
        Method[] userServiceDeclaredMethods = userService.getDeclaredMethods();
        // 遍历追加
        for (Method method : userServiceDeclaredMethods){
            // 获取修饰符，并追加
            String methodModifier = Modifier.toString(method.getModifiers());
            s.append("\t");
            s.append(methodModifier);

            // 获取返会类型，并追加
            s.append(" ");
            Class returnType = method.getReturnType();
            String methodSimpleName = returnType.getSimpleName();
            s.append(methodSimpleName);

            // 获取方法名，并追加
            s.append(" ");
            s.append(method.getName());
            s.append("(");

            // 获取方法参数，并追加
            Class[] parameterTypes = method.getParameterTypes();
            for (Class parameterType : parameterTypes){
                s.append(parameterType.getSimpleName());
                s.append(",");
            }

            // 删除最后一个 “  ， ”
            if (parameterTypes.length >0){
                s.deleteCharAt(s.length()-1);
            }

            s.append("){};");
            s.append("\n");
        }

        // 追加UserService尾巴儿
        s.append("}");

        System.out.println(s);
    }
}

---

通过反射调用方法

package bgy_reflect_method_210709_01;
/*
    通过反射调用方法
    重要

    反射机制，让代码具有通用性，可变化的内容都写到配置文件中去
    将来修改配置文件，=创建的对象就不一样了，调用方法也不一样了
    代码不需要任何改变
 */

import java.lang.reflect.Method;

public class ReflectMethodTest04 {
    public static void main(String[] args) throws  Exception {
        /*
            1.
            不通过反射调用方法

            调用要素：
                要素1：userService对象
                要素2：login方法名
                要素3：实参列表
                要素4：返回值
         */
        UserService userService = new UserService();
        System.out.println(userService.login("admin","admin"));

        /*
            2.
            通过反射调用方法
         */
        // 获取对象
        Class userServiceClass = Class.forName("bgy_reflect_method_210709_01.UserService");
        // 创建对象
        Object obj = userServiceClass.newInstance();
        // 获取Method
        Method loginMethod = userServiceClass.getDeclaredMethod("login", String.class, String.class);
        // 调用要素
        // 要素1：loginMethod方法
        // 要素2：obj对象
        // 要素3：”admin“，”admin“实参
        // 要素4：resultValue 返回值
        Object resultValue = loginMethod.invoke(obj,"admin","admin");
        System.out.println(resultValue);
    }
}

---

UserService.java

package bgy_reflect_method_210709_01;

public class UserService {

    /**
     * 登录方法
     * @param name
     * @param password
     * @return true表示登录成功，false表示登录失败
     */
    public boolean login(String name,String password){
        if (name.equals("admin") && password.equals("admin")) {
            return true;
        }
        return false;
    }


    /**
     * 系统退出
     */
    public void logout(){
        System.out.println("系统已经安全退出");
    }

    public static void test(int a,String b,double c){
        System.out.println("测试有多个修饰符和多个参数");
    }

}