메소드 이름을 문자열로 제공했을 때 Java 메소드를 어떻게 호출합니까?


684

두 개의 변수가있는 경우 :

Object obj;
String methodName = "getName";

의 클래스를 모른 채 obj식별 된 메소드를 어떻게 호출 할 수 methodName있습니까?

호출되는 메소드에는 매개 변수가 없으며 String리턴 값이 있습니다. 그것은의 자바 빈에 대한 게터 .


답변:


972

엉덩이에서 코딩하면 다음과 같습니다.

java.lang.reflect.Method method;
try {
  method = obj.getClass().getMethod(methodName, param1.class, param2.class, ..);
} catch (SecurityException e) { ... }
  catch (NoSuchMethodException e) { ... }

매개 변수는 필요한 매우 구체적인 방법을 식별합니다 (사용 가능한 오버로드가 여러 개인 경우 메서드에 인수가없는 경우 methodName).

그런 다음 호출하여 해당 메소드를 호출합니다.

try {
  method.invoke(obj, arg1, arg2,...);
} catch (IllegalArgumentException e) { ... }
  catch (IllegalAccessException e) { ... }
  catch (InvocationTargetException e) { ... }

다시 말하지만,에 인수가 .invoke없으면 생략하십시오 . 하지만 그래 Java Reflection 에 대해 읽어보기


2
Java가 유형 삭제를 사용한다는 사실에 약간 화가 났지만 적어도 Reflection이 나를 다시 격려한다는 사실을 알고 있습니다. C #에서 알려진 getter 및 setter 또는 속성에 대한 기본 지원은 현재 누락 된 것입니다.
7hi4g0

120
공평하지 않다 -1. Henrik은 아마도 스쿼시 예외를 옹호하지 않고 단지 반성을 나타내려고하기 때문에 아무것도 작성하지 않았습니다.
그린

70
몇 가지 잠재적 인 예외를 보여주기위한 것입니다. 이 글을 쓴다면 ... catch (Exception e) {...
mikbanUtah

1
에 대한 "변수가 초기화되지 않았을 수 있습니다" methodmethod.invoke(obj, arg1, arg2,...);있습니다. 는 method = null;문제를 해결하지만 답변에 언급하는 것은 나쁜 생각이 아닙니다.
Amin

2
@ DeaMon1 Java 메소드는 "종료 코드"를 사용하지 않지만 메소드가 무언가 invoke를 리턴하면 리턴 된 모든 것을 리턴합니다. 메소드 실행 중 예외가 발생하면 예외가에서 래핑됩니다 InvocationTargetException.
ThePyroEagle

194

리플렉션에서 메소드 호출 을 사용하십시오 .

Class<?> c = Class.forName("class name");
Method method = c.getDeclaredMethod("method name", parameterTypes);
method.invoke(objectToInvokeOn, params);

어디:

  • "class name" 수업의 이름입니다
  • objectToInvokeOn Object 유형이며 메소드를 호출하려는 오브젝트입니다.
  • "method name" 호출하려는 메소드의 이름입니다.
  • parameterTypes유형 Class[]이며 메소드가 취하는 매개 변수를 선언합니다.
  • params유형 Object[]이며 메소드에 전달할 매개 변수를 선언합니다.

쿨, 나는 당신이 getDeclaredMethod ()에 맞다고 생각합니다. 아마도 getMethod ()보다 'safer'일 것입니다 ..
brasskazoo

22
잘못된. 예, getDeclaredMethod는 개인 및 보호 된 메소드와 함께 작동합니다. 그러나 수퍼 클래스에 정의 된 메소드 (상속 된 메소드)에서는 작동하지 않습니다. 따라서 원하는 작업에 따라 크게 달라집니다. 대부분의 경우 메소드가 정의 된 정확한 클래스에 관계없이 작동하기를 원합니다.
jrudolph

"클래스"파일을 어디에 두어야합니까? 이클립스 IDE에 대한 설명
Dr.jacky

수업 경로에 @ Mr.Hyde.
Stijn de Witt

호출하는 메소드가 매개 변수를 전혀 허용하지 않으면 어떻게 method.invoke () 안에 넣어야합니까? 빈 객체 배열이어야하는 경우 두 번째 매개 변수를 제공 해야하는 것 같습니다.
Igor

101

Java 7에서 간단한 코드 예제를 원하는 사람들에게 :

Dog 수업:

package com.mypackage.bean;

public class Dog {
    private String name;
    private int age;

    public Dog() {
        // empty constructor
    }

    public Dog(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public void printDog(String name, int age) {
        System.out.println(name + " is " + age + " year(s) old.");
    }
}

ReflectionDemo 수업:

package com.mypackage.demo;

import java.lang.reflect.*;

public class ReflectionDemo {

    public static void main(String[] args) throws Exception {
        String dogClassName = "com.mypackage.bean.Dog";
        Class<?> dogClass = Class.forName(dogClassName); // convert string classname to class
        Object dog = dogClass.newInstance(); // invoke empty constructor

        String methodName = "";

        // with single parameter, return void
        methodName = "setName";
        Method setNameMethod = dog.getClass().getMethod(methodName, String.class);
        setNameMethod.invoke(dog, "Mishka"); // pass arg

        // without parameters, return string
        methodName = "getName";
        Method getNameMethod = dog.getClass().getMethod(methodName);
        String name = (String) getNameMethod.invoke(dog); // explicit cast

        // with multiple parameters
        methodName = "printDog";
        Class<?>[] paramTypes = {String.class, int.class};
        Method printDogMethod = dog.getClass().getMethod(methodName, paramTypes);
        printDogMethod.invoke(dog, name, 3); // pass args
    }
}

산출: Mishka is 3 year(s) old.


이 방법으로 매개 변수를 사용하여 생성자를 호출 할 수 있습니다.

Constructor<?> dogConstructor = dogClass.getConstructor(String.class, int.class);
Object dog = dogConstructor.newInstance("Hachiko", 10);

또는 제거 할 수 있습니다

String dogClassName = "com.mypackage.bean.Dog";
Class<?> dogClass = Class.forName(dogClassName);
Object dog = dogClass.newInstance();

하고

Dog dog = new Dog();

Method method = Dog.class.getMethod(methodName, ...);
method.invoke(dog, ...);

제안 읽기 : 새 클래스 인스턴스 작성


1
가장 좋은 대답은 여기입니다. 완전하고 간결한
Reuben JaMes Aveño Gruta

1
정답입니다.
Dhara Patel

어디에서 Method물건 을 얻 습니까?
parlad

반사 pkg에서.

55

이와 같이 메소드를 호출 할 수 있습니다. 더 많은 가능성이 있지만 (반사 API 확인) 가장 간단한 방법입니다.

import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;

import org.junit.Assert;
import org.junit.Test;

public class ReflectionTest {

    private String methodName = "length";
    private String valueObject = "Some object";

    @Test
    public void testGetMethod() throws SecurityException, NoSuchMethodException, IllegalArgumentException,
            IllegalAccessException, InvocationTargetException {
        Method m = valueObject.getClass().getMethod(methodName, new Class[] {});
        Object ret = m.invoke(valueObject, new Object[] {});
        Assert.assertEquals(11, ret);
    }



}

7
OP가 자신의 질문에 "매개 변수 없음"을 지정했다는 사실을 인정한 유일한 답은 +1입니다.
John Fitzpatrick

16

먼저하지 마십시오. 이런 종류의 코드는 피하십시오. 코드가 잘못되어 안전하지 않은 경향이 있습니다 ( Java Programming Language에 대한 보안 코딩 지침, 버전 2.0 섹션 6 참조 ).

그렇게해야한다면, 리플렉션보다 java.beans를 선호하십시오. 콩은 반사를 감싸서 비교적 안전하고 일반적인 접근을 허용합니다.


11
동의하지 않습니다. 이러한 코드를 안전하게 작성하는 것은 매우 쉽고 여러 언어로 작성했습니다. 예를 들어, 허용 가능한 메소드 세트를 만들 수 있으며 메소드 이름이 세트에있는 경우에만 메소드를 호출 할 수 있습니다. 더 안전한 (아직도 여전히 간단하지는 않지만) 각 허용 된 메소드를 특정 상태로 제한하고 스레드 / 인터페이스 / 사용자 / 그러한 기준에 맞지 않는 한 메소드를 호출 할 수 없습니다.
JSON

그러한 문제에 대해 절대 그렇게 범주화되지 마십시오. 지금은 사용자가 웹 인터페이스를 사용하여 임의의 개체에 대한 임의의 작업을 정의 할 수 있도록 간단한 프로그램을 만들고 있습니다. 나는 그것이 실제로 안전하지 않다는 것을 알고 있지만 구성이 수신되면 적절한 테스트가 수행되고 프로그래머가 아닌 사람이 작업을 쉽게 구성 할 수 있으며 프로그램에 사용자 정의 클래스를 일반 코드에 연결할 수있는 기능을 제공합니다. GUI를 업데이트하지 않고도 웹 인터페이스를 통해 사용할 메소드를 구성 할 수 있도록 리플렉션을 사용합니다.
DGoiko

14

동료의 답변을 완성하려면 다음 사항에주의를 기울이십시오.

  • 정적 또는 인스턴스 호출 (한 경우 클래스의 인스턴스가 필요하지 않고 다른 경우에는 존재 하거나 존재하지 않을 수 있는 기존 기본 생성자 에 의존해야 할 수도 있음)
  • 공개 또는 비공개 메소드 호출 (후자의 경우 doPrivileged 블록 내의 메소드에서 setAccessible을 호출해야합니다 . 다른 findbugs는 행복하지 않습니다 )
  • 수많은 자바 시스템 예외를 되돌리려면 더 관리 가능한 하나의 적용 예외로 캡슐화하십시오 (따라서 아래 코드의 CCException)

다음은 이러한 점을 고려한 오래된 java1.4 코드입니다.

/**
 * Allow for instance call, avoiding certain class circular dependencies. <br />
 * Calls even private method if java Security allows it.
 * @param aninstance instance on which method is invoked (if null, static call)
 * @param classname name of the class containing the method 
 * (can be null - ignored, actually - if instance if provided, must be provided if static call)
 * @param amethodname name of the method to invoke
 * @param parameterTypes array of Classes
 * @param parameters array of Object
 * @return resulting Object
 * @throws CCException if any problem
 */
public static Object reflectionCall(final Object aninstance, final String classname, final String amethodname, final Class[] parameterTypes, final Object[] parameters) throws CCException
{
    Object res;// = null;
    try {
        Class aclass;// = null;
        if(aninstance == null)
        {
            aclass = Class.forName(classname);
        }
        else
        {
            aclass = aninstance.getClass();
        }
        //Class[] parameterTypes = new Class[]{String[].class};
    final Method amethod = aclass.getDeclaredMethod(amethodname, parameterTypes);
        AccessController.doPrivileged(new PrivilegedAction() {
    public Object run() {
                amethod.setAccessible(true);
                return null; // nothing to return
            }
        });
        res = amethod.invoke(aninstance, parameters);
    } catch (final ClassNotFoundException e) {
        throw new CCException.Error(PROBLEM_TO_ACCESS+classname+CLASS, e);
    } catch (final SecurityException e) {
        throw new CCException.Error(PROBLEM_TO_ACCESS+classname+GenericConstants.HASH_DIESE+ amethodname + METHOD_SECURITY_ISSUE, e);
    } catch (final NoSuchMethodException e) {
        throw new CCException.Error(PROBLEM_TO_ACCESS+classname+GenericConstants.HASH_DIESE+ amethodname + METHOD_NOT_FOUND, e);
    } catch (final IllegalArgumentException e) {
        throw new CCException.Error(PROBLEM_TO_ACCESS+classname+GenericConstants.HASH_DIESE+ amethodname + METHOD_ILLEGAL_ARGUMENTS+String.valueOf(parameters)+GenericConstants.CLOSING_ROUND_BRACKET, e);
    } catch (final IllegalAccessException e) {
        throw new CCException.Error(PROBLEM_TO_ACCESS+classname+GenericConstants.HASH_DIESE+ amethodname + METHOD_ACCESS_RESTRICTION, e);
    } catch (final InvocationTargetException e) {
    throw new CCException.Error(PROBLEM_TO_ACCESS+classname+GenericConstants.HASH_DIESE+ amethodname + METHOD_INVOCATION_ISSUE, e);
    } 
    return res;
}

12
Object obj;

Method method = obj.getClass().getMethod("methodName", null);

method.invoke(obj, null);

개체는 최소한 값 / 값을 가져야합니다.
Lova Chittumuri

이것은 내가 필요한 것에 정말 효과적이었습니다. 나는 이미 인스턴스화 된 클래스를 가지고 있었고 메소드를 가져와야했습니다. 예외에 대한 캐치를 추가하는 것이 좋습니다. 그러나 그렇지 않으면 완벽하게 작동했습니다. null 예외를 피하는 방법은 nullable을 사용하는 것이지만 매우 제한된 범위의 메서드 이름 (문자 그대로 1에서 4까지의 카운터)을 사용하고 있다고 생각합니다.
Jain Waldrip

12
//Step1 - Using string funClass to convert to class
String funClass = "package.myclass";
Class c = Class.forName(funClass);

//Step2 - instantiate an object of the class abov
Object o = c.newInstance();
//Prepare array of the arguments that your function accepts, lets say only one string here
Class[] paramTypes = new Class[1];
paramTypes[0]=String.class;
String methodName = "mymethod";
//Instantiate an object of type method that returns you method name
 Method m = c.getDeclaredMethod(methodName, paramTypes);
//invoke method with actual params
m.invoke(o, "testparam");

8

여러 번 호출하면 Java 7에 도입 된 새로운 메소드 핸들을 사용할 수 있습니다. 다음은 String을 반환하는 메소드입니다.

Object obj = new Point( 100, 200 );
String methodName = "toString";  
Class<String> resultType = String.class;

MethodType mt = MethodType.methodType( resultType );
MethodHandle methodHandle = MethodHandles.lookup().findVirtual( obj.getClass(), methodName, mt );
String result = resultType.cast( methodHandle.invoke( obj ) );

System.out.println( result );  // java.awt.Point[x=100,y=200]

1
미래 독자들에게; 성능에 관심이 있다면 invokeExact가능할 때마다 사용하고 싶을 것 입니다. 이를 위해 호출 사이트 서명은 메소드 핸들 유형과 정확히 일치해야합니다. 일을하려면 보통 약간의 시간이 걸립니다. 이 경우 첫 번째 매개 변수를 다음 methodHandle = methodHandle.asType(methodHandle.type().changeParameterType(0, Object.class));과 같이 캐스팅 하고 다음과 같이 호출하십시오.String result = (String) methodHandle.invokeExact(obj);
Jorn Vernee

7

이것은 Java Reflection 패키지로 할 수있는 것 같습니다.

http://java.sun.com/developer/technicalArticles/ALT/Reflection/index.html

특히 아래 이름으로 메소드 호출에서 :

import java.lang.reflect. *;

public class method2 {
  public int add(int a, int b)
  {
     return a + b;
  }

  public static void main(String args[])
  {
     try {
       Class cls = Class.forName("method2");
       Class partypes[] = new Class[2];
        partypes[0] = Integer.TYPE;
        partypes[1] = Integer.TYPE;
        Method meth = cls.getMethod(
          "add", partypes);
        method2 methobj = new method2();
        Object arglist[] = new Object[2];
        arglist[0] = new Integer(37);
        arglist[1] = new Integer(47);
        Object retobj 
          = meth.invoke(methobj, arglist);
        Integer retval = (Integer)retobj;
        System.out.println(retval.intValue());
     }
     catch (Throwable e) {
        System.err.println(e);
     }
  }
}

6

인덱싱 (빠르게)

FunctionalInterface메소드를 컨테이너에 저장하여 색인을 작성할 수 있습니다 . 배열 컨테이너를 사용하여 숫자로 호출하거나 해시 맵을 사용하여 문자열로 호출 할 수 있습니다. 이 방법으로 메소드를 색인화하여 동적으로 빠르게 호출 할 수 있습니다 .

@FunctionalInterface
public interface Method {
    double execute(int number);
}

public class ShapeArea {
    private final static double PI = 3.14;

    private Method[] methods = {
        this::square,
        this::circle
    };

    private double square(int number) {
        return number * number;
    }

    private double circle(int number) {
        return PI * number * number;
    }

    public double run(int methodIndex, int number) {
        return methods[methodIndex].execute(aNumber);
    }
}

람다 구문

람다 구문을 사용할 수도 있습니다.

public class ShapeArea {
    private final static double PI = 3.14;

    private Method[] methods = {
        number -> {
            return number * number;
        },
        number -> {
            return PI * number * number;
        },
    };

    public double run(int methodIndex, int number) {
        return methods[methodIndex].execute(aNumber);
    }
}

1
이 기술은 반사보다 훨씬 낫습니다.
John O

정말 더 낫습니까?
Dimitri Kopriwa

@DimitriKopriwa 인덱싱은 CPU 계산 대신 램을 사용하는 방법입니다. 정수 인덱싱의 경우 알고리즘의 어려움은입니다 O(1).
Amir Fo

5
Method method = someVariable.class.getMethod(SomeClass);
String status = (String) method.invoke(method);

SomeClass클래스이며 someVariable변수입니다.


someVariable이 실제로 객체 인 경우 someVariable.getClass ()를 호출하십시오. 또한 클래스를 유일한 인수로 사용하여 getMethod ()를 호출 할 수 없습니다. 메소드를 사용하여 메소드를 호출하지 마십시오. 올바른 : someVariable.getClass (). getMethod ( "coolMethod", parameterClasses) .invoke (arguments);
Orangle

5

나는 이것을 이렇게한다 :

try {
    YourClass yourClass = new YourClass();
    Method method = YourClass.class.getMethod("yourMethodName", ParameterOfThisMethod.class);
    method.invoke(yourClass, parameter);
} catch (Exception e) {
    e.printStackTrace();
}

5

다음 코드가 도움이 될 수 있습니다.

public static Method method[];
public static MethodClass obj;
public static String testMethod="A";

public static void main(String args[]) 
{
    obj=new MethodClass();
    method=obj.getClass().getMethods();
    try
    {
        for(int i=0;i<method.length;i++)
        {
            String name=method[i].getName();
            if(name==testMethod)
            {   
                method[i].invoke(name,"Test Parameters of A");
            }
        }
    }
    catch(Exception ex)
    {
        System.out.println(ex.getMessage());
    }
}

감사....


이것은 Java에서 문자열을 비교하는 방법이 아닙니다. .equals 메소드를 사용해야합니다. 그렇지 않으면, 그것들이 그것들이 동일한 객체 참조인지 비교하고 실제로 객체 참조에 신경 쓰지 않고 문자열 내용 만 일치합니다. 또한 리플렉션을 통해 이름으로 방법을 얻을 수 있으므로 왜 자신의 롤을 할 것인지 확실하지 않습니까?
Lo-Tan

5

사용 준비 방법은 다음과 같습니다.

인수없이 메소드를 호출하려면 다음을 수행하십시오.

public static void callMethodByName(Object object, String methodName) throws IllegalAccessException, InvocationTargetException, NoSuchMethodException {
    object.getClass().getDeclaredMethod(methodName).invoke(object);
}

인수를 사용하여 메소드를 호출하려면 다음을 수행하십시오.

    public static void callMethodByName(Object object, String methodName, int i, String s) throws IllegalAccessException, InvocationTargetException, NoSuchMethodException {
        object.getClass().getDeclaredMethod(methodName, int.class, String.class).invoke(object, i, s);
    }

위의 방법을 아래와 같이 사용하십시오 :

package practice;

import java.io.IOException;
import java.lang.reflect.InvocationTargetException;

public class MethodInvoke {

    public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, SecurityException, IllegalAccessException, IllegalArgumentException, InvocationTargetException, IOException {
        String methodName1 = "methodA";
        String methodName2 = "methodB";
        MethodInvoke object = new MethodInvoke();
        callMethodByName(object, methodName1);
        callMethodByName(object, methodName2, 1, "Test");
    }

    public static void callMethodByName(Object object, String methodName) throws IllegalAccessException, InvocationTargetException, NoSuchMethodException {
        object.getClass().getDeclaredMethod(methodName).invoke(object);
    }

    public static void callMethodByName(Object object, String methodName, int i, String s) throws IllegalAccessException, InvocationTargetException, NoSuchMethodException {
        object.getClass().getDeclaredMethod(methodName, int.class, String.class).invoke(object, i, s);
    }

    void methodA() {
        System.out.println("Method A");
    }

    void methodB(int i, String s) {
        System.out.println("Method B: "+"\n\tParam1 - "+i+"\n\tParam 2 - "+s);
    }
}

산출:

방법 A  
방법 B :  
	Param1-1  
	매개 변수 2-테스트

3

Student.java

class Student{
    int rollno;
    String name;

    void m1(int x,int y){
        System.out.println("add is" +(x+y));
    }

    private void m3(String name){
        this.name=name;
        System.out.println("danger yappa:"+name);
    }
    void m4(){
        System.out.println("This is m4");
    }
}

StudentTest.java

import java.lang.reflect.Method;
public class StudentTest{

     public static void main(String[] args){

        try{

            Class cls=Student.class;

            Student s=(Student)cls.newInstance();


            String x="kichha";
            Method mm3=cls.getDeclaredMethod("m3",String.class);
            mm3.setAccessible(true);
            mm3.invoke(s,x);

            Method mm1=cls.getDeclaredMethod("m1",int.class,int.class);
            mm1.invoke(s,10,20);

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

1

리플렉션을 사용해야합니다. 클래스 객체를 초기화 한 다음이 클래스의 메소드를 호출 한 다음 선택적 매개 변수 를 사용하여 객체에서이 메소드를 호출하십시오 . try-catch 블록 에서 다음 스 니펫을 래핑해야합니다.

그것이 도움이되기를 바랍니다!

Class<?> aClass = Class.forName(FULLY_QUALIFIED_CLASS_NAME);
Method method = aClass.getMethod(methodName, YOUR_PARAM_1.class, YOUR_PARAM_2.class);
method.invoke(OBJECT_TO_RUN_METHOD_ON, YOUR_PARAM_1, YOUR_PARAM_2);

1

이것은 나를 위해 잘 작동합니다 :

public class MethodInvokerClass {
    public static void main(String[] args) throws NoSuchMethodException, SecurityException, IllegalAccessException, IllegalArgumentException, ClassNotFoundException, InvocationTargetException, InstantiationException {
        Class c = Class.forName(MethodInvokerClass.class.getName());
        Object o = c.newInstance();
        Class[] paramTypes = new Class[1];
        paramTypes[0]=String.class;
        String methodName = "countWord";
         Method m = c.getDeclaredMethod(methodName, paramTypes);
         m.invoke(o, "testparam");
}
public void countWord(String input){
    System.out.println("My input "+input);
}

}

산출:

My input testparam

메인과 같은 다른 메소드에 이름을 전달하여 메소드를 호출 할 수 있습니다.


1

사용 import java.lang.reflect.*;

public static Object launchProcess(String className, String methodName, Class<?>[] argsTypes, Object[] methodArgs)
        throws Exception {

    Class<?> processClass = Class.forName(className); // convert string classname to class
    Object process = processClass.newInstance(); // invoke empty constructor

    Method aMethod = process.getClass().getMethod(methodName,argsTypes);
    Object res = aMethod.invoke(process, methodArgs); // pass arg
    return(res);
}

사용 방법은 다음과 같습니다.

String className = "com.example.helloworld";
String methodName = "print";
Class<?>[] argsTypes = {String.class,  String.class};
Object[] methArgs = { "hello", "world" };   
launchProcess(className, methodName, argsTypes, methArgs);

0

jooR 을 사용하면 다음과 같습니다 .

on(obj).call(methodName /*params*/).get()

보다 정교한 예는 다음과 같습니다.

public class TestClass {

    public int add(int a, int b) { return a + b; }
    private int mul(int a, int b) { return a * b; }
    static int sub(int a, int b) { return a - b; }

}

import static org.joor.Reflect.*;

public class JoorTest {

    public static void main(String[] args) {
        int add = on(new TestClass()).call("add", 1, 2).get(); // public
        int mul = on(new TestClass()).call("mul", 3, 4).get(); // private
        int sub = on(TestClass.class).call("sub", 6, 5).get(); // static
        System.out.println(add + ", " + mul + ", " + sub);
    }
}

인쇄합니다 :

3, 12, 1


-10

나를 위해 매우 간단하고 바보 같은 방법은 단순히 메서드 호출자 메서드를 만드는 것입니다.

public static object methodCaller(String methodName)
{
    if(methodName.equals("getName"))
        return className.getName();
}

그런 다음 메소드를 호출해야 할 때 간단히 다음과 같은 것을 넣으십시오.

//calling a toString method is unnessary here, but i use it to have my programs to both rigid and self-explanitory 
System.out.println(methodCaller(methodName).toString()); 

4
컴파일 타임에 인스턴스가 이미 알려진 경우 왜 그렇게하지 className.getName().toString()않습니까? 당신은 모든 반사점을 놓치고 있습니다.
BalusC

내가 말했듯이,이 경우에는 불필요하지만 항상 인스턴스가 나쁜 프로그래밍 습관임을 알고 있다고 가정합니다.
SMayne

2
@ SMayne :이 게시물을 삭제하는 것이 좋습니다.
lpapp

나쁜 프로그래밍은이 경우에 칭찬이 될 것이다
pdenti
당사 사이트를 사용함과 동시에 당사의 쿠키 정책개인정보 보호정책을 읽고 이해하였음을 인정하는 것으로 간주합니다.
Licensed under cc by-sa 3.0 with attribution required.