在java中调用随机类的随机方法

Question

我正在开发一个培训课程，该课程有一个 Training 课程，其函数返回一个随机方法（一种练习类型）。

这个通用类由一些特定类扩展，其中包含不同类型的练习。

然后我创建一个特定类的数组，并想随机选择一个，然后调用随机练习方法。

这是泛型类

public class TrainingClasses {
Method[] mMethods;
Random randomGenerator; 
 public void TraningClasses() {
    randomGenerator = new Random();

    /* Store methods */
    mMethods= getClass().getDeclaredMethods();


}

 public void RandomExercise() {
    Random randGenerator = new Random();
    int rnd = randGenerator.nextInt(mMethods.length);

mMethods[rnd].invoke(this);

}

这是一个具体培训班的例子

 public class MatheMagic extends TrainingClasses{


public MatheMagic() { 
/*Something*/
 }



public String[] SomeExercise() { 
    /*Some code */
 }

public String[] SomeOtherExercise() { 
    /*Some code */
 }      
}

在主要活动的这一点上，我想这样做：

private Object[] mTrainingClasses; 
private MatheMagic mMathMag;
/*eventually other training classes*/
mMathMag = new MatheMagic();
mTrainingClasses[0] = mMathMag;

Random randGenerator = new Random();
int rnd = randGenerator.nextInt(mTrainingClasses.length);
Object aTrain = mTrainingClasses[rnd];

/*Return exercise*/
String[] mRes = aTrain.RandomExercise();

这是代码的相关部分，现在仍然不完整......但是当我尝试存储动态调用方法的结果时，由于出现类型不匹配错误，我无法继续。 可能是项目结构不对，应该改用别的架构……不过，目前还没有找到更好的办法。

感谢任何能够提供帮助的人。

––––––––––––––––––––––––––––––––––––––––––––––––––––

谢谢大家的回答。 以下是可能需要的人的最终工作代码：

/** Common interface for all exercises */ 
public interface Exercise {
  public String[] run();
} 



/** Common interface for all training classes */
public abstract class TrainingClass {

  private Random rand = new Random();
  public ArrayList<Exercise> mExerciseTypes = new ArrayList<Exercise>();

  /** Run a random exercise */
  public String[] runRandomExercise() {
    int i = rand.nextInt(mExerciseTypes.size());
    return mExerciseTypes.get(i).run();
  }

}


/*Specific training class*/

public class MatheMagic extends TrainingClass {

 public MatheMagic() {

        class SomeExercise implements Exercise {

            public String[] run() {

                 String[] mRes = new String[2];
                  mRes[0] = "Question type 1";
                  mRes[1] = "Answer type 1";
                return mRes;
            }

        }

        class SomeOtherExercise implements Exercise {

            public String[] run() {

                 String[] mRes = new String[2];
                  mRes[0] = "Question type 2";
                  mRes[1] = "Answer type 2";
                return mRes;
            }

        }
        SomeExercise mN = new SomeExercise();

        SomeOtherExercise mS = new SomeOtherExercise();

        mExerciseTypes.add(mN);
        mExerciseTypes.add(mS);
 }

}

Answer 1

我认为您可能应该重新考虑您的设计。在大多数情况下，通常应避免使用反射。只有在动态加载和执行代码时才真正需要反射（例如，JUnit 框架在名称作为命令行参数传递的类中动态加载和执行测试）。

我建议不要在一个类中随机执行一个方法，而是创建一个具有公共接口的Exercise 对象集合，随机选择其中一个然后运行它。这是我在想的一些骨架代码：

import java.util.ArrayList;
import java.util.Random;

/** Common interface for all training classes */
public abstract class TrainingClass {

  private Random rand = new Random();
  protected ArrayList<Exercise> exercises = new ArrayList<Exercise>();

  /** Run a random exercise */
  public String[] runRandomExercise() {
    int i = rand.nextInt(exercises.size());
    return exercises.get(i).run();
  }

}

/** Common interface for all exercises */ 
public interface Exercise {
  String[] run();
}

public class MatheMagic extends TrainingClass {

  /** Constructor creates all the exercises */
  public MatheMagic() {
    // Some exercise
    exercises.add(new Exercise {
      public String[] run() {
        // Code for some exercise ...
      }
    });
    // Some other exercise
    exercises.add(new Exercise {
      public String[] run() {
        // Code for some other exercise ...
      }
    });
    // etc ...
  }

}

由于所有练习都是Exercise 类型并且有一个通用的run() 方法，因此不需要使用反射。声明有点冗长，因为您需要为每个练习创建一个 anonymous inner class，但为了避免反思，额外的冗长是值得的！

Answer 2

如果您手动创建训练类数组（即不是通过反射），您可以将保存类的数组类型更改为：

private TrainingClasses[] mTrainingClasses; 

以及你随机选择的班级类型：

TrainingClasses aTrain = mTrainingClasses[rnd];

这应该允许您在aTrain 上调用RandomExercise 方法。