java - 在java中调用random类的random方法

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 */
 }      
}

此时在主要 Activity 中我想这样做:

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 框架在名称作为命令行参数传递的类中动态加载和执行测试)。

与其在类中随机执行一个方法，我建议创建一个具有公共(public)接口(interface)的 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 每个练习，但为了避免反射(reflection)，额外的冗长是值得的!