Question

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

第一种方式：用几个构造函数和＃34; IF＆＃34;＃34;为所有实例编写一个类。检查哪些参数存在？例如：

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

}

继承问题是它是最难的耦合。想象一下，有一天，你的类只有一个参数被淘汰了...你必须做一个重构才能摆脱那个类，只因为你所有的其他类依赖于它...如果你需要一个只有参数c的类，为什么要从带参数a的那个继承它？最佳公分母不应该基于字段（在您的案例参数中），而应基于功能，以及method()。

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

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

好的阅读将是书＆＃34;清洁代码＆＃34;来自罗伯特马丁......

JAVA多个构造函数和IF＆s继承

1 个答案: