blocks|key|1159045|text|统计信息收集可能使用非最终变量，例如计算创建的实例数量。另一方面，对于这种情况，你可能无论如何都想使用AtomicLong等，在这一点上它可能是最终的。或者，如果您正在收集多个stat，则可能最终得到一个Statistics类和对它的一个实例的最终引用。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1159046|当然，拥有(有理由的)非final静态变量是相当罕见的。|1159047|entityMap^0|1F|A|2U|A|0|0^^$0|@$1|2|3|4|5|6|7|J|8|@$9|K|A|L|B|C]|$9|M|A|N|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|O|8|@]|D|@]|E|$]]|$1|H|3|-4|5|6|7|P|8|@]|D|@]|E|$]]]|I|$]]

Statistics-gathering might use non-final variables, e.g. to count the number of instances created. On the other hand, for that sort of situation you probably want to use <code>AtomicLong</code> etc anyway, at which point it can be final. Alternatively if you're collecting more than one stat, you could end up with a <code>Statistics</code> class and a final reference to an instance of it.

It's certainly pretty rare to have (justifiably) non-final static variables.

blocks|key|1151909|text|当用作缓存时，日志记录、统计信息或调试开关显然是合理的用途。当然，完全是私人的。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1151910|如果你将可变对象分配给了最后一个字段，这在道德上与拥有一个可变字段是一样的。|1151911|一些语言，如Fan，完全不允许可变的静态(或等效的)。|1151912|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|H|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|I|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|J|8|@]|9|@]|A|$]]|$1|F|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|G|$]]

When used as a cache, logging, statistics or a debug switch are the obvious reasonable uses. All private, of course.

If you have mutable object assigned to a final field, that is morally the same as having a mutable field.

Some languages, such as Fan, completely disallow mutable statics (or equivalent).

blocks|key|584277|text|根据我的经验，静态非最终变量应该只用于单例实例。其他所有内容都可以更清晰地包含在单例(如缓存)中，也可以是最终的(如记录器引用)。然而，我不相信硬性的规则，所以我对我的建议持保留态度。也就是说，我建议仔细检查您考虑声明除单例实例之外的非final静态变量的任何情况，并查看是否可以对其进行重构或以不同方式实现--例如，移入单例容器或使用对可变对象的final引用。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|584278|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 experience static non-final variables should only be used for singleton instances. Everything else can be either more cleanly contained by a singleton (such as a cache), or made final (such as a logger reference). However I don't believe in hard and fast rules, so I would take my advice with a grain of salt. That said I would suggest carefully examining any case where you consider declaring a non-final static variable aside from a singleton instance and see if it can be refactored or implemented differently -- i.e. moved into a singleton container or use a final reference to a mutable object.

blocks|key|1151950|text|我认为包装您的静态并通过单例(或至少通过静态方法)提供访问通常是一个好主意，因为您可以更好地控制访问并避免一些竞争条件和同步问题。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1151951|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|$]]

I think wrapping your statics and providing access via singletons (or at a minimum via static methods) is generally a good idea, since you can better control access and avoid some race condition and synchronization issues.

blocks|key|1159121|text|静态变量意味着它对整个类都是可用的，所以这两个示例对整个类都是可用的。最终表示该值不能更改。所以我猜问题是什么时候你想让一个值对整个类可用，并且它在实例化后不能改变。我猜应该是一个常量，可用于该类的所有实例化。否则，如果你需要一个像population+counter这样的东西，那么就使用非final变量。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1159122|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|$]]

A static variable means that it is available to the class as a whole so both examples are available to the class as a whole. Final means that the value cannot be changed. So I guess the question is when do you want to a value to be available to an entire class and it cannot be changed after it has been instantiated. My guess would be a constant available to all instantiations of that class. Otherwise if you need something like a population counter then the non-final variable.

blocks|key|4649227|text|静态变量可用于控制应用程序级别的行为，例如指定全局日志记录级别、要连接的服务器。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|4649228|我在旧的应用程序中遇到过这样的用例，通常来自其他公司。|4649229|如今，使用静态变量来达到这样的目的显然是糟糕的实践，但在1999年，它并不是那么明显。没有Spring，没有log4j，没有来自R.C.Martin的干净代码，等等。|offset|length|style|BOLD|4649230|Java语言现在已经相当老了，即使现在强烈反对某些特性，但它在一开始就经常被使用。而且由于向后兼容性，它不太可能改变。|4649231|entityMap^0|0|0|K|5|0|0^^$0|@$1|2|3|4|5|6|7|N|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|O|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|P|8|@$F|Q|G|R|H|I]]|9|@]|A|$]]|$1|J|3|K|5|6|7|S|8|@]|9|@]|A|$]]|$1|L|3|-4|5|6|7|T|8|@]|9|@]|A|$]]]|M|$]]

Static variables can be used to control application-level behaviour, for example specifying global logging level, server to connect with.

I've met such use cases in old appliations, usually coming from other companies.

Nowadays using static variables for such purposes is obviously bad practice, but it wasn't so obvious in, say, 1999. No Spring, no log4j, no Clean code from R.C.Martin etc.

Java language is quite old now, and even if some feature is strongly discouraged now, it was often used in the beginnings. And because of backward compatibility it's unlikely to change.

blocks|key|584436|text|就个人而言，对于类的非最终变量，我使用CamelCase表示法。从代码中可以清楚地看出，它是一个类变量，因为您必须这样引用它：FooBar.bDoNotRunTests。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|584437|注意，我使用this作为类实例变量的前缀，以将它们与局部作用域变量区分开来。例如。this.bDoNotRunTests。|584438|entityMap^0|1R|L|0|6|4|15|J|0^^$0|@$1|2|3|4|5|6|7|J|8|@$9|K|A|L|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|M|8|@$9|N|A|O|B|C]|$9|P|A|Q|B|C]]|D|@]|E|$]]|$1|H|3|-4|5|6|7|R|8|@]|D|@]|E|$]]]|I|$]]

Personally for class non-final variables I use the CamelCase notation. It is clear from code that it is a class variable since you have to reference it as such: <code>FooBar.bDoNotRunTests</code>. 

On that note, I prefix class instance variables with the <code>this</code> to distinguish them from local scope variables. ex. <code>this.bDoNotRunTests</code>.

In Java, when should static non final variables be used?

For example

<pre><code>private static int MY_VAR = 0;
</code></pre>

Obviously we are not talking about constants here.

<pre><code>public static final int MY_CONSTANT = 1;
</code></pre>

In my experience I have often justified them when using a singleton, but then I end up needing to have more than one instance and cause myself great headache and re-factoring.

It seems it is rare that they should be used in practice. What do you think?

Best Practice: Java static non final variables

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

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

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

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

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

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

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

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

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

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

在Java中，什么时候应该使用静态的非final变量？例如private static int MY_VAR = 0;显然，我们在这里讨论的不是常量。public static final int MY_CONSTANT = 1;在我的经验中，我经常在使用单例时证明它们是合理的，但然后我最终需要有多个实例，并给自己带来...

问最佳实践: Java静态非最终变量
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问最佳实践: Java静态非最终变量EN