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

据推测，您必须创建 和 的新实例，MyObject因为MyObject2这些execute方法不是可重入的，并且这些实例是不可重用的。（考虑到您通过构造函数参数为执行方法提供输入的方式，我看不出它有什么不同。）

您可以通过一些重写来改进代码：

    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

我可以看到清理此代码的唯一方法是在您的代码中引入一个工厂类。这会将对象创建代码和对象使用代码分开，并且会大量清理您的代码。

例如

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 回答
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 回答
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 回答
0

如果没有具体问题的更具体示例，就很难提出非常具体的设计模式建议。但是您可能会考虑的一件事是提取一个方法，您可以按照您希望它们执行的顺序将这些对象的列表或数组传递给该方法：比如

public void executeAll(MyAbstractObject ... objects) {
    for (MyAbstractObject object: objects)
        object.execute();
}

然后可以更简洁地编写您拥有的功能：

void thisFunctionUsesMyObjects () {
    executeAll(new MyObject1(param1, param2), new MyObject2(param1));
}

void thisFunctionToo () {
    executeAll(new MyObject1(param3, param2), new MyObject3(param3), new MyObject2(param3), new MyObject4(param3));
}

实际上，您可以更进一步，应用复合模式来创建一个对象，该对象具有按正确顺序execute()调用所有方法的方法。execute()

这当然不会减少实例化的数量......

于 2013-06-11T11:55:24.657 回答