blocks|key|1619176|text|一个稍微简化的答案：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1619177|public+class+Book
{
++++private+final+String+title;

++++public+Book(String+title)
++++{
++++++this.title+=+title;
++++}

++++public+Book()
++++{
++++++this("Default+Title");
++++}

++++...
}|code-block|syntax|javascript|1619178|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

A slightly simplified answer:

<pre><code>public class Book
{
 private final String title;

 public Book(String title)
 {
 this.title = title;
 }

 public Book()
 {
 this("Default Title");
 }

 ...
}
</code></pre>

blocks|key|1404531|text|考虑使用Builder模式。它允许您在参数上设置默认值，并以清晰简洁的方式进行初始化。例如：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1404532|++++Book+b+=+new+Book.Builder("Catcher+in+the+Rye").Isbn("12345")
+++++++.Weight("5+pounds").build();|code-block|syntax|javascript|1404533|编辑:它还消除了对具有不同签名的多个构造器的需要，并且可读性更好。|1404534|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|L|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|M|8|@]|9|@]|A|$]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

Consider using the Builder pattern. It allows for you to set default values on your parameters and initialize in a clear and concise way. For example:

<pre><code>
 Book b = new Book.Builder("Catcher in the Rye").Isbn("12345")
 .Weight("5 pounds").build();
</code></pre>

Edit: It also removes the need for multiple constructors with different signatures and is way more readable.

blocks|key|1404587|text|您需要指定什么是类不变式，即对于类的实例始终为真的属性(例如，书的标题永远不会为空，或者狗的大小始终>+0)。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1404588|这些不变量应在构造过程中建立，并在对象的生命周期中保留，这意味着方法不应破坏这些不变量。构造函数可以通过强制参数或通过设置默认值来设置这些不变量：|1404589|class+Book+{
++++private+String+title;+//+not+nullable
++++private+String+isbn;++//+nullable

++++//+Here+we+provide+a+default+value,+but+we+could+also+skip+the+
++++//+parameterless+constructor+entirely,+to+force+users+of+the+class+to
++++//+provide+a+title
++++public+Book()
++++{
++++++++this("Untitled");+
++++}

++++public+Book(String+title)+throws+IllegalArgumentException
++++{
++++++++if+(title+==+null)+
++++++++++++throw+new+IllegalArgumentException("Book+title+can't+be+null");
++++++++this.title+=+title;
++++++++//+leave+isbn+without+value
++++}
++++//+Constructor+with+title+and+isbn
}|code-block|syntax|javascript|1404590|然而，这些不变量的选择在很大程度上取决于你正在编写的类，你将如何使用它，等等，所以你的问题没有明确的答案。|1404591|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|N|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|O|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|6|7|P|8|@]|9|@]|A|$]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

You need to specify what are the class invariants, i.e. properties which will always be true for an instance of the class (for example, the title of a book will never be null, or the size of a dog will always be > 0).

These invariants should be established during construction, and be preserved along the lifetime of the object, which means that methods shall not break the invariants. The constructors can set these invariants either by having compulsory arguments, or by setting default values:

<pre><code>class Book {
 private String title; // not nullable
 private String isbn; // nullable

 // Here we provide a default value, but we could also skip the 
 // parameterless constructor entirely, to force users of the class to
 // provide a title
 public Book()
 {
 this("Untitled"); 
 }

 public Book(String title) throws IllegalArgumentException
 {
 if (title == null) 
 throw new IllegalArgumentException("Book title can't be null");
 this.title = title;
 // leave isbn without value
 }
 // Constructor with title and isbn
}
</code></pre>

However, the choice of these invariants highly depends on the class you're writing, how you'll use it, etc., so there's no definitive answer to your question.

blocks|key|1404629|text|另一个注意事项是，如果某个字段是必填字段或其范围有限，请在构造函数中执行检查：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1404630|public+Book(String+title)
{
++++if+(title==null)
++++++++throw+new+IllegalArgumentException("title+can't+be+null");
++++this.title+=+title;
}|code-block|syntax|javascript|1404631|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

Another consideration, if a field is required or has a limited range, perform the check in the constructor:

<pre><code>public Book(String title)
{
 if (title==null)
 throw new IllegalArgumentException("title can't be null");
 this.title = title;
}
</code></pre>

blocks|key|1404673|text|有几个人建议添加null检查。有时这是正确的做法，但并不总是如此。看看这篇优秀的文章，告诉你为什么要跳过它。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1404674|http://misko.hevery.com/2009/02/09/to-assert-or-not-to-assert/|offset|length|1404675|entityMap|0|LINK|mutability|MUTABLE|url^0|0|0|1Q|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|N|8|@]|9|@$D|O|E|P|1|Q]]|A|$]]|$1|F|3|-4|5|6|7|R|8|@]|9|@]|A|$]]]|G|$H|$5|I|J|K|A|$L|C]]]]

Several people have recommended adding a null check. Sometimes that's the right thing to do, but not always. Check out this excellent article showing why you'd skip it.

<a href="http://misko.hevery.com/2009/02/09/to-assert-or-not-to-assert/" rel="nofollow noreferrer">http://misko.hevery.com/2009/02/09/to-assert-or-not-to-assert/</a>

blocks|key|1619399|text|您应该始终构造一个有效且合法的对象；如果不能使用构造函数参数，则应该使用构建器对象来创建一个构建器对象，只有在对象完成时才从构建器中释放对象。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1619400|关于构造函数的使用问题:我总是尝试有一个所有其他构造函数都遵循的基本构造函数，使用“省略”的参数链接到下一个逻辑构造函数，并在基本构造函数结束。所以：|1619401|class+SomeClass
{
SomeClass()+{
++++this("DefaultA");
++++}

SomeClass(String+a)+{
++++this(a,"DefaultB");
++++}

SomeClass(String+a,+String+b)+{
++++myA=a;
++++myB=b;
++++}
...
}|code-block|syntax|javascript|1619402|如果这是不可能的，那么我会尝试使用一个私有的init()方法，所有的构造函数都遵循这个方法。|1619403|并且保持构造函数和参数的数量很小--作为指导，每个构造函数和参数最多5个。|1619404|entityMap^0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|P|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|Q|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|6|7|R|8|@]|9|@]|A|$]]|$1|K|3|L|5|6|7|S|8|@]|9|@]|A|$]]|$1|M|3|-4|5|6|7|T|8|@]|9|@]|A|$]]]|N|$]]

You should always construct a valid and legitimate object; and if you can't using constructor parms, you should use a builder object to create one, only releasing the object from the builder when the object is complete.

On the question of constructor use: I always try to have one base constructor that all others defer to, chaining through with "omitted" parameters to the next logical constructor and ending at the base constructor. So:

<pre><code>class SomeClass
{
SomeClass() {
 this("DefaultA");
 }

SomeClass(String a) {
 this(a,"DefaultB");
 }

SomeClass(String a, String b) {
 myA=a;
 myB=b;
 }
...
}
</code></pre>

If this is not possible, then I try to have an private init() method that all constructors defer to.

And keep the number of constructors and parameters small - a max of 5 of each as a guideline.

I've been wondering what the best (i.e. cleanest/safest/most efficient) way of handling multiple constructors in Java is? Especially when in one or more constructors not all fields are specified:

<pre><code>public class Book
{

 private String title;
 private String isbn;

 public Book()
 {
 //nothing specified!
 }

 public Book(String title)
 {
 //only title!
 }

 ... 

}
</code></pre>

What should I do when fields are not specified? I've so far been using default values in the class so that a field is never null, but is that a "good" way of doing things?

Best way to handle multiple constructors in Java

Java

我一直在想，在Java中处理多个构造函数的最好(即最干净/最安全/最有效)的方法是什么？尤其是在一个或多个构造函数中没有指定所有字段时：public class Book{    private String title;    private String isbn;    public Book()    {   ...

问在Java中处理多个构造函数的最佳方法
EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问在Java中处理多个构造函数的最佳方法EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问在Java中处理多个构造函数的最佳方法
EN