Using Java reflection mechanism for method overloading?

Use the reflection mechanism to implement method overloading in Java: Obtain methods through reflection: Use the getMethod() method to obtain the method object, specify the method name and parameter type. Calling method: Use the invoke() method to call the method, specifying the caller object and parameter values.

Using Java reflection mechanism for method overloading

Method overloading in Java allows creation of objects with the same name but different parameter lists multiple methods. These overloaded methods can be called at runtime by using the reflection mechanism.

Reflection mechanism

The reflection mechanism allows programs to inspect and modify classes, methods, and fields at runtime. To use reflection, you need to use the classes in the java.lang.reflect package.

Get the method

To get the method, you can use the getMethod() method and specify the name and parameter type of the method:

Method method = Class.forName("MyClass").getMethod("myMethod", new Class<?>[] { String.class });

Calling a method

When calling a method, you need to specify the caller object of the method and the value to be passed as a parameter:

method.invoke(myClassObject, "myParameter");

Practical case

The following example demonstrates how to use the reflection mechanism to call an overloaded method:

public class MethodOverloading {
    public void myMethod(String param) {
        System.out.println("Method with String parameter: " + param);
    }

    public void myMethod(int param) {
        System.out.println("Method with int parameter: " + param);
    }

    public static void main(String[] args) {
        MethodOverloading obj = new MethodOverloading();

        Class<?> cls = obj.getClass();
        try {
            // 调用带 String 参数的方法
            Method method1 = cls.getMethod("myMethod", new Class<?>[] { String.class });
            method1.invoke(obj, "Hello");

            // 调用带 int 参数的方法
            Method method2 = cls.getMethod("myMethod", new Class<?>[] { int.class });
            method2.invoke(obj, 100);
        } catch (NoSuchMethodException | IllegalAccessException | InvocationTargetException e) {
            e.printStackTrace();
        }
    }
}

Output

Method with String parameter: Hello
Method with int parameter: 100

The above is the detailed content of Using Java reflection mechanism for method overloading?. For more information, please follow other related articles on the PHP Chinese website!