blocks|key|2941403|text|这仍然是一个常量。有关常量命名约定的详细信息，请参阅JLS。但在现实中，这完全是偏好的问题。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|2941404|2941405|2941406|接口类型中的常量名称应该是，类类型的final变量通常可以是一个或多个单词、首字母缩写或缩写的序列，全部大写，组件由下划线"_"字符分隔。常量名称应该是描述性的，而不是不必要的缩写。按照惯例，它们可以是任何适当的词性。常量的名称示例包括MIN_VALUE、MAX_VALUE、MIN_RADIX和Character类的MAX_RADIX。|blockquote|style|CODE|2941407|2941408|一组代表一个集合的可选值的常量，或者，在较少的情况下，表示整数值中的掩码位的一组常量，有时可以用常用的缩写词作为名称前缀来指定，例如：|2941409|接口ProcessStates+{+int+PS_RUNNING+=+0；int+PS_SUSPENDED+=+1；}|2941410|涉及常量名称的模糊处理很少见：|2941411|2941412|由于它们是可分辨的syntactically.，因此|2941413|常量名称通常没有小写字母，因此它们通常不会遮蔽包或类型的名称，也不会遮蔽名称通常至少包含一个小写are名称的字段|unordered-list-item|2941414|2941415|entityMap|0|LINK|mutability|MUTABLE|url|http://java.sun.com/docs/books/jls/second_edition/html/names.doc.html#9367^0|Q|3|0|0|0|0|I|5|1P|3|3A|9|3K|9|3U|9|44|9|4F|9|0|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|16|8|@]|9|@$A|17|B|18|1|19]]|C|$]]|$1|D|3|-4|5|6|7|1A|8|@]|9|@]|C|$]]|$1|E|3|-4|5|6|7|1B|8|@]|9|@]|C|$]]|$1|F|3|G|5|H|7|1C|8|@$A|1D|B|1E|I|J]|$A|1F|B|1G|I|J]|$A|1H|B|1I|I|J]|$A|1J|B|1K|I|J]|$A|1L|B|1M|I|J]|$A|1N|B|1O|I|J]|$A|1P|B|1Q|I|J]]|9|@]|C|$]]|$1|K|3|-4|5|6|7|1R|8|@]|9|@]|C|$]]|$1|L|3|M|5|6|7|1S|8|@]|9|@]|C|$]]|$1|N|3|O|5|6|7|1T|8|@]|9|@]|C|$]]|$1|P|3|Q|5|6|7|1U|8|@]|9|@]|C|$]]|$1|R|3|-4|5|6|7|1V|8|@]|9|@]|C|$]]|$1|S|3|T|5|6|7|1W|8|@]|9|@]|C|$]]|$1|U|3|V|5|W|7|1X|8|@]|9|@]|C|$]]|$1|X|3|-4|5|6|7|1Y|8|@]|9|@]|C|$]]|$1|Y|3|-4|5|6|7|1Z|8|@]|9|@]|C|$]]]|Z|$10|$5|11|12|13|C|$14|15]]]]

That's still a constant. See the <a href="http://java.sun.com/docs/books/jls/second_edition/html/names.doc.html#9367" rel="noreferrer">JLS</a> for more information regarding the naming convention for constants. But in reality, it's all a matter of preference.

<hr>

<blockquote>
 The names of constants in interface types should be, and <code>final</code>
 variables of class types may conventionally be, a sequence of one or
 more words, acronyms, or abbreviations, all uppercase, with components
 separated by underscore <code>"_"</code> characters. Constant names should be
 descriptive and not unnecessarily abbreviated. Conventionally they may
 be any appropriate part of speech. Examples of names for constants
 include <code>MIN_VALUE</code>, <code>MAX_VALUE</code>, <code>MIN_RADIX</code>, and <code>MAX_RADIX</code> of the
 class <code>Character</code>.
 
 A group of constants that represent alternative values of a set, or,
 less frequently, masking bits in an integer value, are sometimes
 usefully specified with a common acronym as a name prefix, as in:

<pre><code>interface ProcessStates {
 int PS_RUNNING = 0;
 int PS_SUSPENDED = 1;
}
</code></pre>
 
 Obscuring involving constant names is rare:
 
 <ul>
 <li>Constant names normally have no lowercase letters, so they will not normally obscure names of packages or types, nor will they normally shadow fields, whose names typically contain at least one lowercase letter.</li>
 <li>Constant names cannot obscure method names, because they are distinguished syntactically.</li>
 </ul>
</blockquote>

blocks|key|3155787|text|没有“正确”的方法--只有约定。您已经说明了最常见的约定，也是我在自己的代码中遵循的约定:所有静态最终结果都应该全部大写。我想其他团队也会遵循其他约定。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3155788|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 no "right" way -- there are only conventions. You've stated the most common convention, and the one that I follow in my own code: all static finals should be in all caps. I imagine other teams follow other conventions.

blocks|key|3155836|text|语言并不关心。重要的是遵循你正在工作的项目的既定风格和惯例，这样其他维护者(或五个月后的你)就有最好的机会不会被弄糊涂了。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3155837|我认为可变对象的全大写名称肯定会让我感到困惑，即使对该对象的引用恰好存储在static+final变量中。|offset|length|style|CODE|3155838|entityMap^0|0|11|C|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|$]]

The language doesn't care. What's important is to follow the established styles and conventions of the project you're working on, such that other maintainers (or you five months from now) have the best possible chance of not being confused.

I think an all-uppercase name for a mutable object would certainly confuse me, even if the reference to that object happened to be stored in a <code>static final</code> variable.

blocks|key|3155843|text|这些变量都是常量，即private+static+final，不管它们是否全部用大写字母命名。全大写约定只是让这些变量变得更明显，这些变量是常量，但不是必需的。我见过|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|3155844|private+static+final+Logger+log+=+Logger.getLogger(MyClass.class);|code-block|syntax|javascript|3155845|以前是小写的，我可以接受，因为我知道只使用记录器来记录消息，但它确实违反了约定。我想，您可能会争辩说，将其命名为log是一种子约定。但一般来说，用大写字母命名常量不是一种正确的方式，但这是最好的方式。|3155846|entityMap^0|A|K|0|0|1K|3|0^^$0|@$1|2|3|4|5|6|7|O|8|@$9|P|A|Q|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|R|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|S|8|@$9|T|A|U|B|C]]|D|@]|E|$]]|$1|M|3|-4|5|6|7|V|8|@]|D|@]|E|$]]]|N|$]]

These variables are constants, i.e. <code>private static final</code> whether they're named in all caps or not. The all-caps convention simply makes it more obvious that these variables are meant to be constants, but it isn't required. I've seen 

<pre><code>private static final Logger log = Logger.getLogger(MyClass.class);
</code></pre>

in lowercase before, and I'm fine with it because I know to only use the logger to log messages, but it does violate the convention. You could argue that naming it <code>log</code> is a sub-convention, I suppose. But in general, naming constants in uppercase isn't the One Right Way, but it is The Best Way.

blocks|key|2941547|text|在我看来，变量是“常量”通常是一个实现细节，并不一定证明不同的命名约定是合理的。它可能有助于提高可读性，但在某些情况下也会损害可读性。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2941548|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 my opinion a variable being "constant" is often an implementation detail and doesn't necessarily justify different naming conventions. It may help readability, but it may as well hurt it in some cases.

blocks|key|2941572|text|这是一个非常有趣的问题。我会将你问题中的两个常量根据它们的类型进行划分。int+MAX_COUNT是基元类型的常量，而Logger+log是非基元类型。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|2941573|当我们使用原语类型的常量时，我们在代码public+static+final+in+MAX_COUNT+=+10中只改变了常量一次，并且我们只是在for(int+i+=+0;+i<MAX_COUNT;+i%2B%2B)中访问常量的值。这就是我们习惯使用这个约定的原因。|2941574|而在非原语类型的情况下，尽管我们只在一个地方private+static+final+Logger+log+=+Logger.getLogger(MyClass.class);初始化常量，但我们希望在log.debug("Problem")的其他地方对这个常量进行变异或调用方法。我们不喜欢把点运算符放在大写字符后面。毕竟，我们必须在点运算符后面放一个函数名，这肯定是一个驼峰大小写的名称。这就是为什么LOG.debug("Problem")看起来很笨拙。|2941575|String类型也是如此。在代码中，我们通常不会在String常量上改变或调用方法，这就是为什么我们对String类型的对象使用大写命名约定的原因。|2941576|entityMap^0|10|D|1N|A|0|J|11|21|W|0|M|1U|2S|K|5L|K|0|0|6|P|6|1F|6|0^^$0|@$1|2|3|4|5|6|7|N|8|@$9|O|A|P|B|C]|$9|Q|A|R|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|S|8|@$9|T|A|U|B|C]|$9|V|A|W|B|C]]|D|@]|E|$]]|$1|H|3|I|5|6|7|X|8|@$9|Y|A|Z|B|C]|$9|10|A|11|B|C]|$9|12|A|13|B|C]]|D|@]|E|$]]|$1|J|3|K|5|6|7|14|8|@$9|15|A|16|B|C]|$9|17|A|18|B|C]|$9|19|A|1A|B|C]]|D|@]|E|$]]|$1|L|3|-4|5|6|7|1B|8|@]|D|@]|E|$]]]|M|$]]

Well that's a very interesting question. I would divide the two constants in your question according to their type. <code>int MAX_COUNT</code> is a constant of primitive type while <code>Logger log</code> is a non-primitive type.

When we are making use of a constant of a primitive types, we are mutating the constant only once in our code <code>public static final in MAX_COUNT = 10</code> and we are just accessing the value of the constant elsewhere <code>for(int i = 0; i&lt;MAX_COUNT; i++)</code>. This is the reason we are comfortable with using this convention.

While in the case of non-primitive types, although, we initialize the constant in only one place <code>private static final Logger log = Logger.getLogger(MyClass.class);</code>, we are expected to mutate or call a method on this constant elsewhere <code>log.debug("Problem")</code>. We guys don't like to put a dot operator after the capital characters. After all we have to put a function name after the dot operator which is surely going to be a camel-case name. That's why <code>LOG.debug("Problem")</code> would look awkward.

Same is the case with <code>String</code> types. We are usually not mutating or calling a method on a <code>String</code> constant in our code and that's why we use the capital naming convention for a <code>String</code> type object.

blocks|key|3155901|text|对对象的常量引用不是常量，它只是对对象的常量引用。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3155902|private+static+final不是定义一个常量或不是常量的东西。这只是Java定义常量的方式，但这并不意味着每个private+static+final声明都是用来定义常量的。|offset|length|style|CODE|3155903|当我编写private+static+final+Logger时，我并不是想定义一个常量，我只是想定义一个对一个对象的引用，这个对象是private+(它不能从其他类访问)、static+(它是一个类级变量，不需要实例)和final+(它只能赋值一次)。如果它恰好与Java期望您声明一个常量的方式一致，那么，不幸的是，它不会使它成为常量。我不关心编译器、声纳或任何Java专家说什么。常量值是一回事，像MILLISECONDS_IN_A_SECOND+=+1000这样的常量值是一回事，而对对象的常量引用是另一回事。|3155904|众所周知，黄金是会发光的，但并不是所有发光的都是黄金。|3155905|entityMap^0|0|0|K|1P|K|0|4|R|1V|7|2F|6|33|5|5M|V|0|0^^$0|@$1|2|3|4|5|6|7|N|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|O|8|@$D|P|E|Q|F|G]|$D|R|E|S|F|G]]|9|@]|A|$]]|$1|H|3|I|5|6|7|T|8|@$D|U|E|V|F|G]|$D|W|E|X|F|G]|$D|Y|E|Z|F|G]|$D|10|E|11|F|G]|$D|12|E|13|F|G]]|9|@]|A|$]]|$1|J|3|K|5|6|7|14|8|@]|9|@]|A|$]]|$1|L|3|-4|5|6|7|15|8|@]|9|@]|A|$]]]|M|$]]

A constant reference to an object is not a constant, it's just a constant reference to an object.

<code>private static final</code> is not what defines something to be a constant or not. It's just the Java way to define a constant, but it doesn't mean that every <code>private static final</code> declaration was put there to define a constant.

When I write <code>private static final Logger</code> I'm not trying to define a constant, I'm just trying to define a reference to an object that is <code>private</code> (that it is not accessible from other classes), <code>static</code> (that it is a class level variable, no instance needed) and <code>final</code> (that can only be assigned once). If it happens to coincide with the way Java expects you to declare a constant, well, bad luck, but it doesn't make it a constant. I don't care what the compiler, sonar, or any Java guru says. A constant value, like <code>MILLISECONDS_IN_A_SECOND = 1000</code> is one thing, and a constant reference to an object is another. 

Gold is known to shine, but not everything that shines is gold.

there is a rule which says:

<blockquote>
 Names representing constants (final variables) must be all uppercase
 using underscore to separate words
 (taken from <a href="http://geosoft.no/development/javastyle.html">http://geosoft.no/development/javastyle.html</a>)
</blockquote>

that works fine for primitive types like int or strings:

<pre><code>private static final int MAX_COUNT = 10;
</code></pre>

But what's about non primitive types? In most cases I've seen the following:

<pre><code>private static final Logger log = Logger.getLogger(MyClass.class);
</code></pre>

or in singletons, where instance variable is not in upper case.

The question is what is the right way to declare those types of variables (like log and instance)?

Java naming convention for static final variables

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

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

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

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

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

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

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

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

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

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

有一条规则说：表示常量(最终变量)的名称必须全部大写，并使用下划线分隔单词(取自)这对于像int或string这样的原语类型很有效：private static final int MAX_COUNT = 10;但是非原语类型又是什么呢？在大多数情况下，我看到了以下情况：private static final Log...

问静态最终变量的Java命名约定
EN

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问静态最终变量的Java命名约定EN

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问静态最终变量的Java命名约定
EN