Java 工作方式类似于常量的变量的命名约定

我有一个像常数一样使用的变量（它永远不会改变）。我不能将其声明为常量，因为该值是在运行时添加的

您会将变量名大写以帮助自己理解该数据的含义吗

或者你会不会因为这违背了惯例，让事情变得更加混乱

更大的问题：

---

即使场景不是典型的约定，您是否也遵循约定，但距离足够近，可以帮助您个人理解事情？

是否可以将其标记为只读？那么约定就不那么重要了。

如果它能帮助你（和其他人）在六个月后理解你的代码，那就去做吧。如果不行，就不要。就这么简单

---

就我个人而言，我会将其资本化。这是Java中的惯例，由于其面向对象的特性，常量总是在运行时分配。如果我不小心给它赋值，我肯定会在下次扫描那段代码时注意到。我会把它命名为变量，我更喜欢保持命名的一致性。 正如Rob已经建议的那样，readonly（至少在C#中提供）怎么样。

---

或者一个没有设定器的属性。

< P>我不认为我的个人需要在这里是最重要的——如果我已经编写了代码，我已经比其他人更适合在将来和需要时回扫它。所以我把“任何其他人”放在首位——现在或未来的队友需要像我一样彻底地理解代码（理想情况下）

此外，强制性的代码审查是向代码库承诺任何事情的前提条件（这是一种优秀的做法，也是我现在的雇主的一贯规则），如果我的注意力不集中，我很可能会被要求进行代码审查（这确实发生了——这就是为什么我喜欢强制性的代码审查，因为它适用于我自己和其他人！）

“变量在启动时只设置一次”是一种非常特殊的情况，可能值得添加到您的团队指南中——将其视为“比变量更接近常数”可能有很大意义，但只有在代码库中一致使用相同的规则/指南时，这才有帮助。如果规则不存在，我会检查是否有关于添加它的共识；否则，我不会为了我的个人爱好而违反准则。。。这就是“无我编程”和“代码库的团队所有权”的根源，这两个原则是我热诚服务的

顺便说一句，如果我在编码指导原则方面是一个人团队（虽然这不是一个最佳情况，但确实发生了），我想我自己将“启动时设置一次”变量视为命名约定中的常量，这一点不会有任何困难。但如果有一个更大的团队，那就需要更多的工作，而且这两种方式都可以

你是否遵守惯例，即使 这种情况并不典型 惯例，但足够接近它 可能会帮助你个人 明白吗

当场景不典型时，遵循约定可能会使其他人（甚至是你，过一段时间后）感到困惑或减速。我会避免给变量以它不是的伪装

---

此外，您有这种非典型情景的事实可能表明，也许可以遵循其他更典型的范例。尽管如此，我没有任何关于替代方案的即时建议。

我会将其大写（因为从设计角度来看，它更稳定而不是可变），并在其周围添加一条注释，说明其对应用程序的唯一性。

FWIW我自己的惯例是对

#define

和enum使用所有大写。对于

const

变量，我要么不使用特定的约定，要么在使用时在名称前面加上“

k

”（对于“konstant”-而不是“

c

”，它已经被过度用于“count”或“char”之类的东西）

---

我发现我喜欢“

k

”约定，可能会更频繁地使用它，甚至可能会将它用于枚举，为可怕的预处理器宏保留尖叫、所有caps标识符。

首先，遵循项目的编码标准。你应该为阅读代码的其他人而不是你自己编写代码。您的个人偏好不应优先于项目范围内的规则和惯例等

在没有项目编码标准的情况下，您应该遵循所使用语言的“最佳实践”

在Java中，最佳实践是使用驼峰大小写标识符声明一个伪常量。这就是Sun Java编码标准所说的，也是绝大多数专业Java开发人员所使用的

<>在C和C++中，（经典）约定是所有的上限都被用作常数，被定义为预处理器符号。因此，因为这不是预处理器符号，所以您应该使用您的编码标准所说的适用于变量的任何内容

伪常量不应该更改的事实不会阻止某人修改代码，从而使其实际更改，无论是意外更改还是有意更改。如果您使用/滥用编码约定，使标识符看起来像真正的Constant，那么您将成为问题的一部分：

试图读取/调试代码的人会首先假定标识符是一个实常量，而不会调查它不是实常量的可能性

然后，当他们看到宣言时，会有很多喊叫和威胁 防御性隔阂

实际上，处理伪常量的更好方法是封装它。在Java中，您可以将其声明为私有成员，并提供getter和setter。setter应该采取措施防止伪常量在第一次设置后被更改。任何好的JavaJIT编译器都会内联一个简单的getter，所以这不会影响运行时

public final int MY_INT = Integer.getInteger("a.property.name");

public class Foo {

public static final int MY_INT;

static {
Properties p = new Properties();
try{
p.load( new FileInputStream("app.props"):
} catch(IOException e) {
//SWALLOW or RETHROW AS ERROR
}
MY_INT=Integer.parseInt( p.getProperty("my.int","17") ); //17 is default if you swallo IOException
}
...
}

#include <iostream>

class ParamFoo
{
    public:
        static void initializeAtStartup(double x);
        static double getFoo();
    private:
        static double foo_;
};

double ParamFoo::foo_;

void ParamFoo::initializeAtStartup(double x)
{
    foo_ = x;
}

double ParamFoo::getFoo()
{
    return foo_;
}

int main(void)
{
    ParamFoo::initializeAtStartup(0.4);
    std::cout << ParamFoo::getFoo() << std::endl;
}

public class BadClass
{ 
    public static final double PI = 3.1;     
      // PI is very constant.  Not according to the business roles modeled by my 
      // application, but by nature.  I don't have a problem making this publicly
      // accessible--except that [Math] already does, with much better precision)

    public static /*final*/ int FOO = null;
      // FOO is constant only by convention.  I cannot even enforce its "constness".
      // Making it public means that my enemies (overtime, for example) can change 
      // the value (late night programming), without telling me.
}

public class BetterClass
{
    public static final double PI = 3.1;
    private /*final*/ Integer foo = null; 

    public int getFoo() {
        return this.foo.intValue();
    }
    public void setFoo(int value) {
        // The business rules say that foo can be set only once.
        // If the business rules change, we can remove this condition 
        // without breaking old code.
        if ( null == this.foo ) {
           this.foo = value;
        } else {
           throw new IllegalStateException("Foo can be set only once.");
        }
    }
}

#include <iostream>

int main()
{
    int i = 0;
    std::cin >> i;

    const int CONST = i; 
    std::cout << CONST; //displays i

    system("PAUSE"); 
    return 0;
}