创建多个包装私有方法的类似公共方法是一种不好的做法吗？

Question

我有这个类，它通过接收某些域对象来执行具有副作用的子例程。

这些领域对象是不同的类，但它们有一些相似之处。我想知道如何通过创建许多公共方法来构建服务，这些公共方法用参数包装私有方法，或者只创建一个具有更多参数的公共方法。

案例一：

class MyService {
     private MethodWithManyParameters($a, $b, $c, $d, $similarParameterA, $similarParameterB)   {
          // do things
          if ($similarParameterA == $objectTypeA) {
               // code
          }
          else if ($similarParameterB == $objectTypeB) {
               // other really similar code
          }

     }


     public DoThingsWithObjectA($a, $b, $c, $d) {
          // $this->MethodWithManyParameters($a, $b, $c, $d, $objectTypeA, $variableA);
     }

     public DoThingsWithObjectB($a, $b, $c, $d) {
          // $this->MethodWithManyParameters($a, $b, $c, $d, $objectTypeB, $variableB);
     }
}

// application code
MyService->DoThingsWithObjectA(...);
MyService->DoThingsWithObjectB(...);

案例二

class MyService {
     public DoThingsWithObject($a, $b, $c, $d, $similarParameterA, $similarParameterB)   {
          // do things
          if ($similarParameterA == $objectTypeA) {
               // code
          }
          else if ($similarParameterB == $objectTypeB) {
               // other really similar code
          }
     }
 }

 // application code
 MyService->DoThingsWithObject(........); // this one has a bigger argument list

我正在尝试考虑这两种方法的优缺点。

第一种方法：

优点： - 简化的应用程序代码，在使用大量参数的情况下可以删除一些

缺点： - 引入更多耦合，因为如果引入了 objectC，那么 MyService 也必须更改以适应它

第二种方法：

优点： - 使用较少方法的简化类 - 更灵活

缺点： - 当你必须处理对象之间的差异时，参数列表可以更大

目前看来，只有一个公共函数是好的，但第二种方法一开始看起来更干净，因为它处理的事情更抽象。

我有什么遗漏的吗？

Answer 1

没有。不是。

查一个很常用的案例：

class ConsoleClass {

     protected /* void */ InternalWrite(/* string */ $SomeValue)   {
          // do things
     } // void InternalWrite(...)

     public /* void */ WriteStr(/* string */ $SomeValue) {
          InternalWrite($SomeValue);
     }

     public /* void */ WriteInt(/* int */ $SomeValue) {
          $SomeString = (string)$SomeValue;
          InternalWrite($SomeString);
     }

     public /* void */ WriteArray(/* array */ $SomeValue) {
          $SomeString = "";

          $SomeString .= "[";
          foreach ($SomeValue as $index => $value)
          {
            $SomeString .= (string)$value;
            $SomeString .= ",";
          } // foreach
          $SomeString .= "[";

          InternalWrite($SomeString);
     }

} // class

// application code
$Console = new ConsoleClass()

$Console->WriteStr("Hello World");
$Console->WriteInt(5);
$Console->WriteArray(array(1, 2, 3, 4, 5));

只要我的 2 美分。

[更新：] 将“私人”更改为“受保护”。

Answer 2

突出的主要问题是在这两种情况下都使用if, elseif。在面向对象的设计中，这几乎总是抽象出代码的情况：

abstract class MyService
{
    abstract public function doThingsWithObject($a, $b, $c, $d);
}

class ObjectA extends MyService
{
    public function doThingsWithObject($a, $b, $c, $d)
    {
        print "Implementation for ObjectA";
    }
}

class ObjectB extends MyService
{
    public function doThingsWithObject($a, $b, $c, $d)
    {
        print "Implementation for ObjectB";
    }
}

然后使用代码：

$objectA = new ObjectA();
$objectB = new ObjectB();

$objectA->doThingsWithObject($a, $b, $c, $d); // Implementation for ObjectA
$objectB->doThingsWithObject($a, $b, $c, $d); // Implementation for ObjectB