blocks|key|3752520|text|我的规则是：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3752521|3752522|不使用声明中的默认值进行初始化(null，false，0，0.0…)。|ordered-list-item|offset|length|style|CODE|3752523|如果没有更改字段值的构造函数参数，则首选声明中的初始化。|3752524|如果字段的值因构造函数参数而更改，请将constructors.|3752525|Be中的初始化与您的实践保持一致(这是最重要的规则)。|3752526|3752527|entityMap^0|0|0|G|4|L|5|R|1|T|3|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|S|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|T|8|@]|9|@]|A|$]]|$1|C|3|D|5|E|7|U|8|@$F|V|G|W|H|I]|$F|X|G|Y|H|I]|$F|Z|G|10|H|I]|$F|11|G|12|H|I]]|9|@]|A|$]]|$1|J|3|K|5|E|7|13|8|@]|9|@]|A|$]]|$1|L|3|M|5|E|7|14|8|@]|9|@]|A|$]]|$1|N|3|O|5|E|7|15|8|@]|9|@]|A|$]]|$1|P|3|-4|5|6|7|16|8|@]|9|@]|A|$]]|$1|Q|3|-4|5|6|7|17|8|@]|9|@]|A|$]]]|R|$]]

My rules:

<ol>
<li>Don't initialize with the default values in declaration (<code>null</code>, <code>false</code>, <code>0</code>, <code>0.0</code>…).</li>
<li>Prefer initialization in declaration if you don't have a constructor parameter that changes the value of the field.</li>
<li>If the value of the field changes because of a constructor parameter put the initialization in the constructors.</li>
<li>Be consistent in your practice (the most important rule).</li>
</ol>

blocks|key|3752626|text|假设您的示例中的类型，肯定更喜欢初始化构造函数中的字段。例外的情况是：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3752627|静态classes/methods|3752628|Fields中的|unordered-list-item|3752629|字段类型为static/final/et+al|3752630|3752631|3752632|我总是认为类顶部的字段列表是内容表(这里包含了什么，而不是它是如何使用的)，构造器作为介绍。当然，方法是章节。|3752633|entityMap^0|0|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|$]]|$1|G|3|H|5|F|7|R|8|@]|9|@]|A|$]]|$1|I|3|-4|5|6|7|S|8|@]|9|@]|A|$]]|$1|J|3|-4|5|6|7|T|8|@]|9|@]|A|$]]|$1|K|3|L|5|6|7|U|8|@]|9|@]|A|$]]|$1|M|3|-4|5|6|7|V|8|@]|9|@]|A|$]]]|N|$]]

Assuming the type in your example, definitely prefer to initialize fields in the constructor. The exceptional cases are:

<ul>
<li>Fields in static classes/methods</li>
<li>Fields typed as static/final/et al</li>
</ul>

I always think of the field listing at the top of a class as the table of contents (what is contained herein, not how it is used), and the constructor as the introduction. Methods of course are chapters.

blocks|key|2908339|text|如果我告诉你，这要看情况？|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2908340|我通常会初始化所有东西，并以一致的方式完成它。是的，它过于显式，但也更容易维护。|2908341|如果我们担心性能，那么我只初始化必须做的事情，并将其放在它能带来最大性价比的地方。|2908342|在实时系统中，我甚至怀疑是否需要变量或常量。|2908343|在C%2B%2B中，我通常在这两个地方几乎不进行初始化，并将其移到一个Init()函数中。为什么？嗯，在C%2B%2B中，如果你正在初始化一些在对象构造过程中可能抛出异常的东西，那么你就有可能发生内存泄漏。|2908344|entityMap^0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|L|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|M|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|N|8|@]|9|@]|A|$]]|$1|F|3|G|5|6|7|O|8|@]|9|@]|A|$]]|$1|H|3|I|5|6|7|P|8|@]|9|@]|A|$]]|$1|J|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|K|$]]

What if I told you, it depends?

I in general initialize everything and do it in a consistent way. Yes it's overly explicit but it's also a little easier to maintain. 

If we are worried about performance, well then I initialize only what has to be done and place it in the areas it gives the most bang for the buck.

In a real time system, I question if I even need the variable or constant at all.

And in C++ I often do next to no initialization in either place and move it into an Init() function. Why? Well, in C++ if you're initializing something that can throw an exception during object construction you open yourself to memory leaks.

blocks|key|711832|text|我通常会尝试构造函数，除了获取依赖项并使用它们初始化相关实例成员之外，什么也不做。如果您想对类进行单元测试，这将使您的工作变得更容易。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|711833|如果要分配给实例变量的值不受要传递给构造函数的任何参数的影响，则在声明时对其进行分配。|711834|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|F|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|G|8|@]|9|@]|A|$]]|$1|D|3|-4|5|6|7|H|8|@]|9|@]|A|$]]]|E|$]]

I normally try the constructor to do nothing but getting the dependencies and initializing the related instance members with them. This will make you life easier if you want to unit test your classes.

If the value you are going to assign to an instance variable does not get influenced by any of the parameters you are going to pass to you constructor then assign it at declaration time.

blocks|key|5163754|text|在C#中，这并不重要。您给出的两个代码示例完全相同。在第一个示例中，C#编译器(或者是CLR?)将构造一个空的构造函数并初始化变量，就像它们在构造函数中一样(+Jon+Skeet在下面的注释中解释了这一点)。如果已经有一个构造函数，那么“上面”的任何初始化都将被移到它的顶部。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|5163755|就最佳实践而言，前者比后者更不容易出错，因为有人可以很容易地添加另一个构造函数，而忘记链接它。|5163756|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|F|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|G|8|@]|9|@]|A|$]]|$1|D|3|-4|5|6|7|H|8|@]|9|@]|A|$]]]|E|$]]

In C# it doesn't matter. The two code samples you give are utterly equivalent. In the first example the C# compiler (or is it the CLR?) will construct an empty constructor and initialise the variables as if they were in the constructor (there's a slight nuance to this that Jon Skeet explains in the comments below).
If there is already a constructor then any initialisation "above" will be moved into the top of it.

In terms of best practice the former is less error prone than the latter as someone could easily add another constructor and forget to chain it.

blocks|key|3752982|text|在声明中设置该值对性能有一点好处。如果您在构造函数中设置它，它实际上被设置了两次(第一次设置为默认值，然后在ctor中重置)。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3752983|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

There is a slight performance benefit to setting the value in the declaration. If you set it in the constructor it is actually being set twice (first to the default value, then reset in the ctor).

blocks|key|2908659|text|在这里，C#的语义与Java略有不同。在C#中，声明中的赋值是在调用超类构造函数之前执行的。在Java中，它是在允许使用'this‘之后立即完成的(对于匿名内部类特别有用)，这意味着两种形式的语义确实匹配。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2908660|如果可以，将字段设为最终字段。|2908661|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|F|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|G|8|@]|9|@]|A|$]]|$1|D|3|-4|5|6|7|H|8|@]|9|@]|A|$]]]|E|$]]

The semantics of C# differs slightly from Java here. In C# assignment in declaration is performed before calling the superclass constructor. In Java it is done immediately after which allows 'this' to be used (particularly useful for anonymous inner classes), and means that the semantics of the two forms really do match.

If you can, make the fields final.

blocks|key|3753172|text|我认为有一个警告。我曾经犯过这样一个错误:在派生类内部，我试图“在声明时初始化”从抽象基类继承的字段。结果是存在两组字段，一组是"base“，另一组是新声明的字段，这花费了我相当多的时间进行调试。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3753173|教训:要初始化继承的字段，需要在构造函数内部完成。|offset|length|style|BOLD|3753174|entityMap^0|0|7|3|0^^$0|@$1|2|3|4|5|6|7|J|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|K|8|@$D|L|E|M|F|G]]|9|@]|A|$]]|$1|H|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|I|$]]

I think there is one caveat. I once committed such an error: Inside of a derived class, I tried to "initialize at declaration" the fields inherited from an abstract base class. The result was that there existed two sets of fields, one is "base" and another is the newly declared ones, and it cost me quite some time to debug.

The lesson: to initialize inherited fields, you'd do it inside of the constructor.

blocks|key|5164101|text|有很多不同的情况。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|5164102|我只需要一个空的列表|offset|length|style|BOLD|5164103|情况是很清楚的。我只需要准备我的列表，并防止当有人向列表添加项目时抛出异常。|5164104|public+class+CsvFile
{
++++private+List<CsvRow>+lines+=+new+List<CsvRow>();

++++public+CsvFile()
++++{
++++}
}|code-block|syntax|javascript|5164105|我知道的价值|5164106|我确切地知道默认情况下我想要什么值，或者我需要使用一些其他的逻辑。|5164107|public+class+AdminTeam
{
++++private+List<string>+usernames;

++++public+AdminTeam()
++++{
+++++++++usernames+=+new+List<string>()+{"usernameA",+"usernameB"};
++++}
}|5164108|或|5164109|public+class+AdminTeam
{
++++private+List<string>+usernames;

++++public+AdminTeam()
++++{
+++++++++usernames+=+GetDefaultUsers(2);
++++}
}|5164110|可能值为的空列表|5164111|有时，我希望默认情况下是一个空列表，可以通过另一个构造函数添加值。|5164112|public+class+AdminTeam
{
++++private+List<string>+usernames+=+new+List<string>();

++++public+AdminTeam()
++++{
++++}

++++public+AdminTeam(List<string>+admins)
++++{
+++++++++admins.ForEach(x+=>+usernames.Add(x));
++++}
}|5164113|entityMap^0|0|0|A|0|0|0|0|0|0|0|0|5|3|0|0|X|0|0^^$0|@$1|2|3|4|5|6|7|16|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|17|8|@$D|18|E|19|F|G]]|9|@]|A|$]]|$1|H|3|I|5|6|7|1A|8|@]|9|@]|A|$]]|$1|J|3|K|5|L|7|1B|8|@]|9|@]|A|$M|N]]|$1|O|3|P|5|6|7|1C|8|@]|9|@]|A|$]]|$1|Q|3|R|5|6|7|1D|8|@]|9|@]|A|$]]|$1|S|3|T|5|L|7|1E|8|@]|9|@]|A|$M|N]]|$1|U|3|V|5|6|7|1F|8|@]|9|@]|A|$]]|$1|W|3|X|5|L|7|1G|8|@]|9|@]|A|$M|N]]|$1|Y|3|Z|5|6|7|1H|8|@$D|1I|E|1J|F|G]]|9|@]|A|$]]|$1|10|3|11|5|6|7|1K|8|@$D|1L|E|1M|F|G]]|9|@]|A|$]]|$1|12|3|13|5|L|7|1N|8|@]|9|@]|A|$M|N]]|$1|14|3|-4|5|6|7|1O|8|@]|9|@]|A|$]]]|15|$]]

There are many and various situations.

I just need an empty list

The situation is clear. I just need to prepare my list and prevent an exception from being thrown when someone adds an item to the list.

<pre><code>public class CsvFile
{
 private List&lt;CsvRow&gt; lines = new List&lt;CsvRow&gt;();

 public CsvFile()
 {
 }
}
</code></pre>

I know the values

I exactly know what values I want to have by default or I need to use some other logic.

<pre><code>public class AdminTeam
{
 private List&lt;string&gt; usernames;

 public AdminTeam()
 {
 usernames = new List&lt;string&gt;() {"usernameA", "usernameB"};
 }
}
</code></pre>

or

<pre><code>public class AdminTeam
{
 private List&lt;string&gt; usernames;

 public AdminTeam()
 {
 usernames = GetDefaultUsers(2);
 }
}
</code></pre>

Empty list with possible values

Sometimes I expect an empty list by default with a possibility of adding values through another constructor.

<pre><code>public class AdminTeam
{
 private List&lt;string&gt; usernames = new List&lt;string&gt;();

 public AdminTeam()
 {
 }

 public AdminTeam(List&lt;string&gt; admins)
 {
 admins.ForEach(x =&gt; usernames.Add(x));
 }
}
</code></pre>

blocks|key|712070|text|在Java中，带有声明的初始化器意味着字段总是以相同的方式初始化，无论使用哪个构造函数(如果您有多个构造函数)或构造函数的参数(如果它们有参数)，尽管构造函数可能随后更改值(如果它不是最终的)。因此，使用带有声明的初始化器向读者表明，无论使用哪个构造函数，也不管传递给任何构造函数的参数是什么，初始化的值都是字段在所有情况下都具有的值。因此，只有在且总是在所有构造的对象的值都相同的情况下，才对声明使用初始化器。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|712071|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

In Java, an initializer with the declaration means the field is always initialized the same way, regardless of which constructor is used (if you have more than one) or the parameters of your constructors (if they have arguments), although a constructor might subsequently change the value (if it is not final). So using an initializer with a declaration suggests to a reader that the initialized value is the value that the field has in all cases, regardless of which constructor is used and regardless of the parameters passed to any constructor. Therefore use an initializer with the declaration only if, and always if, the value for all constructed objects is the same.

blocks|key|3753416|text|C#的设计表明内联初始化是首选的，否则它就不会在语言中出现。任何时候，只要你能避免代码中不同位置之间的交叉引用，你通常都会感觉更好。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3753417|还有静态字段初始化的一致性问题，静态字段初始化需要内联才能获得最佳性能。Constructor+Design的框架设计指南这样说：|offset|length|3753418|3753419|✓考虑内联初始化静态字段，而不是显式使用静态构造函数，因为运行库能够优化没有显式定义的静态构造函数的类型的性能。|blockquote|3753420|3753421|3753422|“考虑”在这个上下文中的意思是这样做，除非有很好的理由不这样做。在静态初始化器字段的情况下，一个很好的原因是初始化太复杂，无法进行内联编码。|3753423|entityMap|0|LINK|mutability|MUTABLE|url|https://msdn.microsoft.com/en-us/library/ms229060.aspx^0|0|10|I|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|V|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|W|8|@]|9|@$D|X|E|Y|1|Z]]|A|$]]|$1|F|3|-4|5|6|7|10|8|@]|9|@]|A|$]]|$1|G|3|H|5|I|7|11|8|@]|9|@]|A|$]]|$1|J|3|-4|5|6|7|12|8|@]|9|@]|A|$]]|$1|K|3|-4|5|6|7|13|8|@]|9|@]|A|$]]|$1|L|3|M|5|6|7|14|8|@]|9|@]|A|$]]|$1|N|3|-4|5|6|7|15|8|@]|9|@]|A|$]]]|O|$P|$5|Q|R|S|A|$T|U]]]]

The design of C# suggests that inline initialization is preferred, or it wouldn't be in the language. Any time you can avoid a cross-reference between different places in the code, you're generally better off.

There is also the matter of consistency with static field initialization, which needs to be inline for best performance. The Framework Design Guidelines for <a href="https://msdn.microsoft.com/en-us/library/ms229060.aspx" rel="nofollow noreferrer">Constructor Design</a> say this:

<blockquote>
 ✓ CONSIDER initializing static fields inline rather than explicitly using static constructors, because the runtime is able to optimize the performance of types that don’t have an explicitly defined static constructor.
</blockquote>

"Consider" in this context means to do so unless there's a good reason not to. In the case of static initializer fields, a good reason would be if initialization is too complex to be coded inline.

blocks|key|3753462|text|保持一致性很重要，但这是你要问自己的问题：“我是否有其他东西的构造器？”|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3753463|通常，我为数据传输创建模型，类本身除了作为变量的外壳之外什么也不做。|3753464|在这些场景中，我通常没有任何方法或构造函数。对于我来说，创建一个专门用于初始化列表的构造函数会让我觉得很傻，特别是因为我可以用声明来初始化它们。|3753465|因此，正如许多其他人所说，这取决于您的用法。保持简单，不要做任何你不需要做的事情。|3753466|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|J|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|K|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|L|8|@]|9|@]|A|$]]|$1|F|3|G|5|6|7|M|8|@]|9|@]|A|$]]|$1|H|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|I|$]]

Being consistent is important, but this is the question to ask yourself:
"Do I have a constructor for anything else?"

Typically, I am creating models for data transfers that the class itself does nothing except work as housing for variables.

In these scenarios, I usually don't have any methods or constructors. It would feel silly to me to create a constructor for the exclusive purpose of initializing my lists, especially since I can initialize them in-line with the declaration.

So as many others have said, it depends on your usage. Keep it simple, and don't make anything extra that you don't have to.

blocks|key|2909104|text|考虑一下您有多个构造函数的情况。对于不同的构造函数，初始化是否会有所不同？如果它们是相同的，那么为什么要对每个构造函数重复呢？这与kokos语句一致，但可能与参数无关。例如，假设您希望保留一个标志，该标志显示对象是如何创建的。那么，对于不同的构造函数，该标志将被不同地初始化，而与构造函数参数无关。另一方面，如果您对每个构造函数重复相同的初始化，则可能会(无意中)更改某些构造函数中的初始化参数，但不会更改其他构造函数中的初始化参数。因此，这里的基本概念是，公共代码应该有一个公共位置，并且不可能在不同的位置重复。所以我会说，总是把它放在声明中，直到你有一个特定的情况，它不再适用于你。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2909105|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

Consider the situation where you have more than one constructor. Will the initialization be different for the different constructors? If they will be the same, then why repeat for each constructor? This is in line with kokos statement, but may not be related to parameters. Let's say, for example, you want to keep a flag which shows how the object was created. Then that flag would be initialized differently for different constructors regardless of the constructor parameters. On the other hand, if you repeat the same initialization for each constructor you leave the possibility that you (unintentionally) change the initialization parameter in some of the constructors but not in others. So, the basic concept here is that common code should have a common location and not be potentially repeated in different locations. So I would say always put it in the declaration until you have a specific situation where that no longer works for you.

blocks|key|2909188|text|没有直接回答你关于最佳实践的问题，但重要的和相关的复习要点是，在泛型类定义的情况下，要么让编译器使用默认值进行初始化，要么我们必须使用特殊的方法将字段初始化为默认值(如果这对于代码的可读性是绝对必要的)。|type|unstyled|depth|inlineStyleRanges|offset|length|style|BOLD|entityRanges|data|2909189|class+MyGeneric<T>
{
++++T+data;
++++//T+data+=+"";+//+<--+ERROR
++++//T+data+=+0;+//+<--+ERROR
++++//T+data+=+null;+//+<--+ERROR++++++++

++++public+MyGeneric()
++++{
++++++++//+All+of+the+above+errors+would+be+errors+here+in+constructor+as+well
++++}
}|code-block|syntax|javascript|2909190|将泛型字段初始化为其默认值的特殊方法如下：|2909191|class+MyGeneric<T>
{
++++T+data+=+default(T);

++++public+MyGeneric()
++++{+++++++++++
++++++++//+The+same+method+can+be+used+here+in+constructor
++++}
}|2909192|entityMap^0|9|4|0|0|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@$9|R|A|S|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|T|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|U|8|@]|D|@]|E|$]]|$1|M|3|N|5|H|7|V|8|@]|D|@]|E|$I|J]]|$1|O|3|-4|5|6|7|W|8|@]|D|@]|E|$]]]|P|$]]

Not a direct answer to your question about the best practice but an important and related refresher point is that in the case of a generic class definition, either leave it on compiler to initialize with default values or we have to use a special method to initialize fields to their default values (if that is absolute necessary for code readability).

<pre><code>class MyGeneric&lt;T&gt;
{
 T data;
 //T data = ""; // &lt;-- ERROR
 //T data = 0; // &lt;-- ERROR
 //T data = null; // &lt;-- ERROR 

 public MyGeneric()
 {
 // All of the above errors would be errors here in constructor as well
 }
}
</code></pre>

And the special method to initialize a generic field to its default value is the following:

<pre><code>class MyGeneric&lt;T&gt;
{
 T data = default(T);

 public MyGeneric()
 { 
 // The same method can be used here in constructor
 }
}
</code></pre>

blocks|key|3753692|text|当您不需要一些逻辑或错误处理时使用：|type|unstyled|depth|inlineStyleRanges|offset|length|style|BOLD|entityRanges|data|3753693|3753694|在声明|unordered-list-item|3753695|处初始化类字段|3753696|当您需要一些逻辑或错误处理时使用：|3753697|3753698|在构造函数|3753699|中初始化类字段|3753700|3753701|当初始化值可用，并且可以将初始化放在一行上时，这种方法效果很好。但是，由于其简单性，这种形式的初始化具有局限性。如果初始化需要一些逻辑(例如，错误处理或用于填充复杂数组的for循环)，则简单的赋值是不够的。实例变量可以在构造函数中初始化，在构造函数中可以使用错误处理或其他逻辑。|blockquote|3753702|3753703|3753704|来自。|3753705|entityMap^0|H|1|0|0|0|0|G|1|0|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|12|8|@$9|13|A|14|B|C]]|D|@]|E|$]]|$1|F|3|-4|5|6|7|15|8|@]|D|@]|E|$]]|$1|G|3|H|5|I|7|16|8|@]|D|@]|E|$]]|$1|J|3|K|5|6|7|17|8|@]|D|@]|E|$]]|$1|L|3|M|5|6|7|18|8|@$9|19|A|1A|B|C]]|D|@]|E|$]]|$1|N|3|-4|5|6|7|1B|8|@]|D|@]|E|$]]|$1|O|3|P|5|I|7|1C|8|@]|D|@]|E|$]]|$1|Q|3|R|5|6|7|1D|8|@]|D|@]|E|$]]|$1|S|3|-4|5|6|7|1E|8|@]|D|@]|E|$]]|$1|T|3|U|5|V|7|1F|8|@]|D|@]|E|$]]|$1|W|3|-4|5|6|7|1G|8|@]|D|@]|E|$]]|$1|X|3|-4|5|6|7|1H|8|@]|D|@]|E|$]]|$1|Y|3|Z|5|6|7|1I|8|@]|D|@]|E|$]]|$1|10|3|-4|5|6|7|1J|8|@]|D|@]|E|$]]]|11|$]]

When you don't need some logic or error handling:

<ul>
<li>Initialize class fields at declaration</li>
</ul>

When you need some logic or error handling:

<ul>
<li>Initialize class fields in constructor</li>
</ul>

<blockquote>
 This works well when the initialization value is available and the
 initialization can be put on one line. However, this form of
 initialization has limitations because of its simplicity. If
 initialization requires some logic (for example, error handling or a
 for loop to fill a complex array), simple assignment is inadequate.
 Instance variables can be initialized in constructors, where error
 handling or other logic can be used.
</blockquote>

From <a href="https://docs.oracle.com/javase/tutorial/java/javaOO/initial.html" rel="nofollow noreferrer">https://docs.oracle.com/javase/tutorial/java/javaOO/initial.html</a> .

I've been programming in C# and Java recently and I am curious where the best place is to initialize my class fields.

Should I do it at declaration?:

<pre><code>public class Dice
{
 private int topFace = 1;
 private Random myRand = new Random();

 public void Roll()
 {
 // ......
 }
}
</code></pre>

or in a constructor?:

<pre><code>public class Dice
{
 private int topFace;
 private Random myRand;

 public Dice()
 {
 topFace = 1;
 myRand = new Random();
 }

 public void Roll()
 {
 // .....
 }
}
</code></pre>

I'm really curious what some of you veterans think is the best practice. I want to be consistent and stick to one approach.

Initialize class fields in constructor or at declaration?

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

我最近一直在用C#和Java编程，我很好奇哪里是初始化我的类字段的最好地方。我应该在申报时这样做吗？public class Dice{    private int topFace = 1;    private Random myRand = new Random();    public void Roll() ...

问在构造函数中还是在声明中初始化类字段？
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问在构造函数中还是在声明中初始化类字段？EN