Java 避免大量的“实例”；MyObjectX扩展了AbstractObject“；要调用每个myObjectX.execute（）？设计模式？

这可能是个奇怪的问题

我正在设计一些代码。。。现在看起来是这样的：

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（）方法是public和called的

---

也许没有更好的办法了

我能看到的清理此代码的唯一方法是在代码中引入一个。这将拆分对象创建代码和对象使用代码，并将大量清理您的代码

比如说

---

我能看到的清理这段代码的唯一方法是在代码中引入一个。这将拆分对象创建代码和对象使用代码，并将大量清理您的代码

比如说

不要重复你自己：

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

不要重复你自己：

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

---

您应该首先将公共代码重构为一个单独的方法，然后在其他方法中使用它：

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...
}

---

您应该首先将公共代码重构为一个单独的方法，然后在其他方法中使用它：

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...
}

大概，您必须创建

MyObject

和

MyObject2

的新实例，因为

execute

方法不可重入且实例不可重用。（考虑到您通过构造函数参数为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，如果模式不像您的示例所示的那样一致，重构可能会更复杂。

大概，您必须创建

MyObject

和

MyObject2

的新实例，因为

execute

方法不可重入且实例不可重用。（考虑到您通过构造函数参数为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，如果模式不像示例中显示的那样一致，重构可能会更复杂。

如果没有更多具体问题的具体示例，就很难提出非常具体的设计模式建议。但是你可以考虑的一个方法是提取一种方法，你可以按照你想要的顺序传递这些对象的列表或数组：

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（）

方法

---

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

如果没有更多具体问题的实例，就很难提出非常具体的设计模式建议。但是你可以考虑的一个方法是提取一种方法，你可以按照你想要的顺序传递这些对象的列表或数组：

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（）

方法

---

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

请提供

MyObject1

和

MyObject2

构造函数的代码，因为它们似乎在您的问题中起着重要作用。@AdamSiemion:我假设MyObject2对

MyAbstractObject.param

使用其单个参数，MyObject`将它们用于MyAbstractObject.Param和

MyObject1.Param

。我不认为我们需要更多。是的，我的意思是：两个对象都有一个共同的参数（及其值）。例如，在给定的时间，它们共享相同的上下文。然而，这两个对象的所有实例并不同时共享相同的上下文。第二个参数只是为了区分MyObject1和MyObject2。请提供

MyObject1

和

MyObject2

构造函数的代码，因为它们似乎在您的问题中起着重要作用。@AdamSiemion:我假设MyObject2使用其单个参数作为

MyAbstractObject.param

，MyObject`将它们用于MyAbstractObject.Param和

MyObject1.Param

。我不认为我们需要更多。是的，我的意思是：两个对象都有一个共同的参数（及其值）。例如，在给定的时间，它们共享相同的上下文。然而，这两个对象的所有实例并不同时共享相同的上下文。第二个参数只是为了区分MyObject1和MyObject2。不过，枚举对常量更安全。不过，枚举对常量更安全。Ok。我应该指定thisFunctionToo（）可以以不同的方式使用MyObject。我不能以这种方式在doIt（）中重构。但是重写成新的MyObject（param）.execute（）很酷。基本上，我使用了一个模板方法模式。考虑到这些对象中只有execute（）方法会被调用，而实例化它们的唯一原因是调用该方法（以及为执行提供有用的参数），我想知道另一种模式是否会更好。我应该指定thisFunctionToo（）可以以不同的方式使用MyObject。我不能以这种方式在doIt（）中重构。但改写成