0

これは奇妙な質問かもしれません。

私はいくつかのコードを設計しています...これは今のところ次のようになります:

abstract class MyAbstractObject {
  String param ;
  abstract void execute () ;
}

class MyObject1 extends MyAbstractObject {
  String otherParam ;
  void exectute() { // implementation } ;
}

class MyObject2 extends MyAbstractObject {
  void exectute() { // other implementation } ;
}

class useMyObject {
  void thisFunctionUsesMyObjects () {
    MyObject1 obj1 = new MyOject1(param1, param2) ;
    MyObject2 obj2 = new MyObject2(param1) ;
    obj1.execute() ;
    obj2.execute() ;
  }
  void thisFunctionToo () {
    MyObject1 obj1 = new MyOject1(param3, param2) ;
    MyObject2 obj2 = new MyObject2(param3) ; 
    // and we could have some more different MyObjectX as well...  
    MyObject3 obj3 = new MyObject3(param3) ;
    MyObject4 obj4 = new MyObject4(param3) ;

    // with an execution in another order
    obj1.execute() ;
    obj3.execute() ;
    obj2.execute() ;
    obj4.execute() ;
  }
}

そのようなコードを実行するためのより良い方法があるかどうか疑問に思っています... thisFunctionUsesMyObjects() などの複数の関数を同時に実行できることを考えると（静的は解決策にはなりません）。

なぜ気になるのかわかりません...両方の MyObject(1,2) が常に同じ最初のパラメーターを持ち、両方とも execute() メソッドがパブリックで呼び出されているだけであるという事実だと思います。

たぶん、より良い方法はありません。

4

5 に答える 5

4

おそらく、メソッドは再入可能ではなく、インスタンスは再利用できないため、andの新しいインスタンスを作成する必要があります。（そして、コンストラクターパラメーターを介して実行メソッドの入力を提供する方法を考えると、それがどのように異なるのかわかりません。）MyObjectMyObject2execute

書き直してコードを改善できます。

    MyObject1 obj1 = new MyOject1(param3, param2) ;
    MyObject2 obj2 = new MyObject2(param3) ;
    obj1.execute() ;
    obj2.execute() ;

次のように記述できます。

    new MyOject1(param3, param2).execute();
    new MyObject2(param3).execute();

次に、リファクタリングできます。

  void thisFunctionUsesMyObjects () {
    MyObject1 obj1 = new MyOject1(param1, param2) ;
    MyObject2 obj2 = new MyObject2(param1) ;
    obj1.execute() ;
    obj2.execute() ;
  }
  void thisFunctionToo () {
    MyObject1 obj1 = new MyOject1(param3, param2) ;
    MyObject2 obj2 = new MyObject2(param3) ;
    obj1.execute() ;
    obj2.execute() ;
  }

になります：

  void thisFunctionUsesMyObjects () {
    doIt(param1, param2);
  }

  void thisFunctionToo () {
    doIt(param3, param2);
  }

  private void doIt(p1, p2) {
    new MyOject1(p1, p2).execute();
    new MyObject2(p1).execute();
  }

明らかに、このパターンのインスタンスが多いほどメリットが大きくなります。OTOH、例が示すほどパターンが一貫していない場合、リファクタリングはより複雑になる可能性があります。

于 2013-06-10T11:25:06.580 に答える
1

共通コードを別のメソッドにリファクタリングすることから始めて、それを他のメソッドで使用する必要があります。

class useMyObject {
    private void useMyObjects(TypeOfParam1 param1, TypeOfParam2 param2) {
        MyObject1 obj1 = new MyOject1(param1, param2);
        MyObject2 obj2 = new MyObject2(param1);
        obj1.execute();
        obj2.execute();
    }

    void thisFunctionUsesMyObjects () {
        useMyObjects(param1, param2);
    }

    void thisFunctionToo () {
        useMyObjects(param3, param2);
    }

    // and so on...
}
于 2013-06-10T11:19:35.743 に答える
1

このコードをクリーンアップする唯一の方法は、Factory クラスをコードに導入することです。これにより、オブジェクト作成コードとオブジェクト使用コードが分割され、コードが大幅にクリーンアップされます。

例えば

abstract class ObjectFactory
{

    // Here I'm using Constants, but using enum types is the standard practise.
    public final static int OBJECT_1 = 1;
    public final static int OBJECT_2 = 2;
    // Examples.

    public static Object getInstance(int discriminator)
    { 
          // I'm sure you can guess the rest.
    }
}
于 2013-06-10T11:09:32.227 に答える
0

繰り返さないでください:

class useMyObject {

  private void executeMyObjects(Param1Type param1, Param2Type param2)
  {
    MyObject1 obj1 = new MyOject1(param1, param2) ;
    MyObject2 obj2 = new MyObject2(param1) ;
    obj1.execute() ;
    obj2.execute() ;
  }

  void thisFunctionUsesMyObjects () {
      executeMyObjects(param1, param2);
  }
  void thisFunctionToo () {
    executeMyObjects(param3, param2);
  }
}
于 2013-06-10T11:19:17.947 に答える