1

我正在开发一个具有培训课程的培训计划，该培训课程具有返回随机方法（一种锻炼类型）的函数。

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

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

这是通用类

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();

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

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

–––––––––––––––––––––––––––––––––––––––––––––––––––––––––––</p >

谢谢你们的答案。这是可能需要的人的最终工作代码：

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

}
4

2 回答 2

2

我认为您可能应该重新考虑您的设计。在大多数情况下，通常应避免使用反射。只有当您动态加载和执行代码时才真正需要反射（例如，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()方法，所以不需要使用反射。声明有点冗长，因为您需要为每个练习创建一个匿名内部类，但是为了避免反思，额外的冗长是值得的！

于 2012-09-03T14:10:45.697 回答
1

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

private TrainingClasses[] mTrainingClasses;

以及您随机选择的课程类型：

TrainingClasses aTrain = mTrainingClasses[rnd];

这应该允许您RandomExercise在aTrain.

于 2012-09-03T13:58:30.507 回答