3

みなさん、いい一日です。

runRandomExercise（）メソッドを持つ抽象クラスと、それを拡張してさまざまな種類の演習を追加するいくつかのクラスがあります。

ここで、ランダムタイプの演習を選択したいので、クラスの1つをランダムに選択し、その上でrunRandomExercise（）を呼び出す必要があります。

今のところ、これを手動でコーディングしていますが、これは私が考える最善の解決策ではありません。ただし、クラスタイプが異なるため、クラスだけを配列に格納することはできません。また、object []を使用すると、runRandomExercise（）メソッドを呼び出すことができません。これを処理するための賢い方法はありますか？

これが今までの私のコードです。それは機能しますが、他のクラスを追加するのは面倒です...

/*Specific classes that extend abstract class TrainingClass with the runRandomExercise() method*/
private MatheMagic mMathMag;
private Mnemonics mMnemonics;
private String[] mTrainingClasses;


/*Initialize classes*/
mMathMag = new MatheMagic();
mMnemonics = new Mnemonics();

/*Manually store classe names*/
mTrainingClasses = new String[2];
mTrainingClasses[0] = "mMathMag";
mTrainingClasses[1] = "mMnemonics"; 


/*Return random exercise*/
public String[] RandomExercise() {
    Random aGenerator = new Random();

    /*Get random class name*/
    int rnd = aGenerator.nextInt(mTrainingClasses.length);
    String aChosen = mTrainingClasses[rnd];

    String[] aRes = new String[2];


    if (aChosen == "mMathMag") {
        aRes = mMathMag.runRandomExercise();
    } else if (aChosen == "mMnemonics") {
        aRes = mMnemonics.runRandomExercise();
    }

    return aRes;
}

編集TrainingClassの定義方法は次のとおりです。

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

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

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

  /** Run a random exercise */
 public String[] runRandomExercise() {
    int i = mRandGen.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

4

簡単な解決策は、共通のメソッドを使用してインターフェースを作成し、すべてのクラスにそれを拡張させることです。

Objectの代わりにそのタイプのコレクションまたは配列を作成します。単純に反復するか、ランダムに選択して、必要なメソッドを呼び出すことができます。

GoFから私へのコマンドパターンのように感じます。

public interface Exercise {
    void execute();
}

今、あなたのクラスはこれを行います：

public class MatheMagic implements Execise {
    public void execute() {
        // special logic here.
    }
}

次に、これを行うことができます：

int numExercises = 1;
Exercise [] exercises = new Exercise[numExercises];
exercises[0] = new MatheMagic();
for (Exercise exercise : exercises) {
    exercise.execute();
}
于 2012-09-03T23:33:57.303 に答える
1

はい、はい。これらすべてのクラスを配列に格納してから、ランダムに呼び出すことができます。どのように？インターフェイスを作成し、すべてのクラスでそのインターフェイスから派生します。そうすれば、実装ではなく、インターフェースに基づいて呼び出すことができます。

于 2012-09-03T23:34:38.477 に答える