Comment appeler des fonctions en bloc avec la réflexion Java

Appelez la fonction dans une variable par réflexion.

La classe que vous souhaitez appeler. Je fais juste quatre règles correctement.

Calc.java

package refrectiontest;

public class Calc {

    public int plus(int a, int b) {
        return a + b;
    }
        public int minus(int a, int b) {
        return a - b;
    }
        public int multiply(int a, int b) {
        return a * b;
    }
        public int divide(int a, int b) {
        return a / b;
    }
        
}

Où appeler.

RefrectionTest.java

package refrectiontest;

import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.List;
import java.util.logging.Level;
import java.util.logging.Logger;


public class RefrectionTest {

    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) {
        try {
            //Créer une instance
            Constructor<?> cons = Calc.class.getConstructor();
            Calc calc = (Calc) cons.newInstance();
            //Enregistrez le nom de la fonction que vous souhaitez utiliser dans la liste
            List<String> methodNames = new ArrayList<>();
            methodNames.add("plus");
            methodNames.add("minus");
            methodNames.add("multiply");
            methodNames.add("divide");
            //Appelez les fonctions collectivement avec le nom enregistré.
            //Si la signature de l'appelant est différente, il est nécessaire de créer une branche à l'intérieur ou de séparer l'instruction for.
            for(String methodName : methodNames){
                //Obtenez un pointeur de fonction dans une variable de type Method.
                //getMethod(Instance de classe créée ci-dessus,1er argument, 2ème argument, 3ème ...) de la fonction que vous souhaitez utiliser
                //Méthode 1 pour autant de signatures que vous souhaitez utiliser,Définissez-le comme méthode2.
                Method method = (Calc.class.getMethod(methodName,int.class,int.class));
                //Utilisation des fonctions. La valeur de retour de invoke étant de type Object, transtypez-la en fonction de la fonction cible.
                int result = (int)method.invoke(calc,20,10);
                System.out.println(methodName + " = " + result );

            }

        } catch (NoSuchMethodException | SecurityException | IllegalAccessException | IllegalArgumentException | InvocationTargetException | InstantiationException ex) {
            Logger.getLogger(RefrectionTest.class.getName()).log(Level.SEVERE, null, ex);
        }
        
    }
    
}

Résultat de sortie plus = 30 minus = 10 multiply = 200 divide = 2

Usage

Cela peut être utile lorsque la méthode est spécifiée en tant que type String. Dans cet exemple, les methodNames sont ajoutés un par un à la main, Les noms de fonction que vous souhaitez appeler sont méthode1, méthode2, méthode3, méthode4 ... S'il s'agit d'un numéro de série comme

for(int i = 1;i<10;i++){
    "method" + String.valuOf(i) ;
}

Vous pourrez peut-être mesurer le raccourcissement du code s'il est généré automatiquement de cette manière.