JAVA 多重构造函数和 IF 与继承

Question

也许有人知道哪种方式编写代码更好(内存更少，CPU 或 GPU 最快)。

第一种方式:使用多个构造函数和“IF”检查存在哪些参数为所有实例编写一个类？示例:

class SomeClass
{
  Parameter a;
  Parameter b;
  Parameter c;

   SomeClass(Parameter a)
  {
   this.a=a;
  }

 SomeClass(Parameter a,Parameter b)
  {
   this(a);
   this.b=b;
  }

   SomeClass(Parameter a,Parameter b,Parameter c)
  {
   this(a,b);
   this.c=c;
  }

public void method()
{
if(a!=null && b!=null && c!=null)
DO IN ONE WAY
if(a!=null && b!=null && c==null)
DO IN ANOTHER WAY
if(a!=null && b!=null && c==null)
DO IN ANOTHER WAY
if(a!=null && b==null && c==null)
DO IN ANOTHER WAY
...
    }
}

第二种方式:当需要使用更多参数时，每次继承父类时扩展父类。示例:

   class SomeClass
    {
      protected Parameter a;

       SomeClass(Parameter a)
      {
       this.a=a;
      }
      public void method()
      {USE a parameter}
    }

    class SomeClass2 extends SomeClass
    {
      protected Parameter b;

       SomeClass2(Parameter a,Parameter b)
      {
       super(a);
       this.b=b;
      }
      public void method()
      {USE a and b parameter}
     }

请告诉我哪种方法更好，为什么？

Answer 1

我什至会提出第三种方式:

interface SomeClass
{
  public void method();
}

class SomeClassWithOneParameter implements SomeClass
{
  private Parameter a;

   SomeClassWithOneParameter(Parameter a)
  {
   this.a=a;
  }
  public void method()
  {USE a parameter}
 }

class SomeClassWithTwoParameters implements SomeClass
{
  private Parameter a;
  private Parameter b;

   SomeClassWithOneParameter(Parameter a,Parameter b)
  {
   this.a=a;
   this.b=b;
  }
  public void method()
  {USE a and b parameter}
 }

现在您可以使用类似工厂的模式从具体实现中抽象出您的代码:

class SomeClassFactory
{
    public SomeClass createSomeClassWithOneParam(Parameter a) 
    {
        return new SomeClassWithOneParameter(a);
    }

    public SomeClass createSomeClassWithTwoParams(Parameter a, Parameter b) 
    {
        return new SomeClassWithTwoParameters(a, b);
    }

}

继承的问题在于它是最难耦合的。想象一下，有一天，你的只有 a 参数的类会过时......你将不得不进行大量重构才能摆脱那个类，只是因为你所有其他类都依赖于它......如果你需要一个只有参数c的类，为什么要继承参数a的类？最好的共同点不应该基于字段(在你的例子中是参数)，而是基于功能，这就是 method()。

您提出的继承树的唯一优点是可以避免在类的不同实现中重复参数定义。然而，这没有性能差异，您只是少了一点编码，而且它不如使用接口(interface)模式灵活。

关于您提出的第一种方法。它的问题是你最终会因为太多原因而修改一个大类。如果你在一个团队中工作，它可能会变成一个类，每个人都必须根据每个需求进行修改，从而影响可维护性和可读性。

Robert Martin 的“Clean Code”一书是不错的读物......