Question

我有一个公共类，需要传递7个参数。目前，我能够将其中3个传递给构造函数，将另外4个传递给类中的公共方法。像这样：


Public Class AClass{
    private XClass axClass;
    private String par4;
    private String par5; 
    private String par6;
    private String par7;

    public AClass(String par1, String par2, String par3){
       aXClass = new XClass(par1,par2,par3);
    }

    public execute(String par4,String par5, String par6, String par7){
       //this is needed because they are used in other private methods in this class
       this.par4 = par4;
       this.par5 = par5;
       this.par6 = par6;
       this.par7 = par7;

       //call other private methods within this class. 
       //about 7 lines here
    }

}

我的问题是，这是要求班级客户传递参数的正确方法吗？

Answer 1

如果这是您想要的，那么不应该阻止您将7个参数传递给构造函数。我不知道是否有最大数量的参数可以传递给Java中的方法，但如果有最大值，它肯定会高于7。

创建类及其公共方法时，您将创建一个关于如何使用和访问该类的接口。从技术上讲，到目前为止你所做的是正确的。请求类的客户端传递参数是“正确的方法”吗？这取决于你，界面的设计者。

当我看到传递7个参数时，我的第一直觉就是默默地问：“这些参数之间是否存在某种关系，这可能意味着它们在一个属于自己的类中很好地融合在一起？”这可能是您在查看代码时要解决的问题。但这是一个设计问题，而不是正确性问题。

Answer 2

我会使用Builder Pattern而不是

建议的许多构造函数参数

Effective Java第2项：面对许多构造函数参数时考虑构建器

这是一个简单的类来说明：

public class Dummy {

    private final String    foo;
    private final String    bar;
    private final boolean   baz;
    private final int       phleem;

    protected Dummy(final Builder builder) {
        this.foo = builder.foo;
        this.bar = builder.bar;
        this.baz = builder.baz;
        this.phleem = builder.phleem;
    }

    public String getBar() {
        return this.bar;
    }

    public String getFoo() {
        return this.foo;
    }

    public int getPhleem() {
        return this.phleem;
    }

    public boolean isBaz() {
        return this.baz;
    }

    public static class Builder {
        private String  foo;
        private String  bar;
        private boolean baz;
        private int     phleem;

        public Dummy build() {
            return new Dummy(this);
        }

        public Builder withBar(final String bar) {
            this.bar = bar;
            return this;
        }

        public Builder withBaz(final boolean baz) {
            this.baz = baz;
            return this;
        }

        public Builder withFoo(final String foo) {
            this.foo = foo;
            return this;
        }

        public Builder withPhleem(final int phleem) {
            this.phleem = phleem;
            return this;
        }

    }

}

你会像这样实例化它：

Dummy dummy = new Dummy.Builder()
                    .withFoo("abc")
                    .withBar("def")
                    .withBaz(true)
                    .withPhleem(123)
                    .build();

很好的部分：你可以获得构造函数参数的所有好处（例如，如果你想要它就具有不变性），但你也可以获得可读的代码。

Answer 3

你不能只创建一个存储这些参数的类/ hashmap并将其传递给函数吗？

public excute(Storageclass storageClass){
       //this is needed because they are used in other private methods in this class
       this.par4 = storageClass.getPar4();
       this.par5 = storageClass.getPar5();
       this.par6 = storageClass.getPar6();
       this.par7 = storageClass.getPar7();

       //or
       this.storageClass = storageClass;
    }

Answer 4

我真的没有看到这个问题。

在任何情况下，您都可以创建一个“请求”对象或类似的东西：

class SomeClass { 
     private String a;
     private String b;
     ....
     public SomeClass( Request r ) { 
        this.a = r.get("a");
        this.b = r.get("b");
        ...
     }

     public void execute( Request other ) { 
         this.d = other.get("d");
         this.e = other.get("d");
         ...
     }
}

另请参阅：http://c2.com/cgi/wiki?TooManyParameters

Answer 5

在不知道使用儿童课程的情况下，我可以说你所做的事情没有任何本质上的错误。

请注意，您必须声明

private XClass axClass;

在你的AClass变量中。

然而，你说'我能够......'这是否意味着以另一种方式宣布这个问题？

Answer 6

我并不关心它，因为在调用构造函数之后，对象应该100％准备好使用。它不是在你的例子中写的。

如果传递给execute方法的参数可以简单地使用，并且这是客户感兴趣的方法，我认为没有理由将它们作为类中的数据成员。

如果不了解您的最终目标，很难说清楚。但我会重新考虑这个实现。

Answer 7

如果您计划引入需要知道AClass.someMethod()的{{1}}而不要求您调用par4-7，那么显然您应该在构造函数中传递参数。< / p>

另一方面：如果你只用AClass.excute()构造这个对象的实例并用它做一些有意义的事情除了调用par1-3那么允许它是有意义的用少于七个完整参数构造的对象。

然而，我自己的审美观点是试图限制一个对象可以使某些方法起作用而其他方法失败的“模式”的数量。理想情况下，完全构造的对象可以运行程序员可能调用的任何方法。我担心设计问题，而不是过于担心构造函数的绝对数量。

但正如其他人所指出的那样，有时这些参数的自然分组可以得到自己的对象。例如：在许多API中，他们使用矩形对象而不是传递（x，y，width，height）。

Answer 8

正如其他人已经写过的那样，传递7个参数在技术上是正确的，尽管不是非常“用户友好”，如果可以的话。

由于你没有写太多关于这个类的内容，我可以提出一个小问题：在构造函数中你只是创建XClass对象，所以在之前创建这个对象并将其作为一个传递它是明智的单个参数。

这样的事情：

...
XClass aXClass = new XClass(par1, par2, par3);
AClass aClass = new AClass(aXClass);
...

这是构造函数：

public AClass(XClass aXClass) {
       this.aXClass = aXClass;
}

处理7个以上的参数

8 个答案: