对于常量，Enum是一个更好的选择。这里有一个例子

公共类myClass {

public enum myEnum {
    Option1("String1", 2), 
    Option2("String2", 2) 
    ;
    String str;
            int i;

            myEnum(String str1, int i1) { this.str = str1 ; this.i1 = i }


}

总之，以秒为单位的timeout值应该是一个配置设置(从属性文件中读取或像Spring中那样通过注入)，而不是一个常量。

这完全可以接受，甚至可能是标准。

(public/private) static final TYPE NAME = VALUE;

其中TYPE是类型，NAME是全大写的名称，空格用下划线表示，VALUE是常量值;

我强烈建议不要将常量放在它们自己的类或接口中。

附注:声明为final且为mutable的变量仍然可以更改;但是，变量永远不能指向不同的对象。

例如:

public static final Point ORIGIN = new Point(0,0);

public static void main(String[] args){

    ORIGIN.x = 3;

}

这是合法的，ORIGIN将是(3,0)点。

在Java中实现常量的最佳方法是什么?

我们应该避免的一种方法是:使用接口来定义常量。

创建专门用于声明常量的接口实际上是最糟糕的事情:它违背了设计接口的初衷:定义方法契约。

即使已经存在一个接口来满足特定的需求，在其中声明常量也没有意义，因为常量不应该成为API和提供给客户端类的契约的一部分。

---

为了简化，我们有4种有效的方法。

使用静态的最终字符串/整数字段:

1)使用在内部声明常量的类。 1变体)创建一个专门用于声明常量的类。

Java 5 enum:

2)在相关的目的类(嵌套类)中声明枚举。 2变体)创建枚举作为一个独立的类(在它自己的类文件中定义)。

---

TLDR:哪个是最好的方法，在哪里找到常数?

In most of cases, the enum way is probably finer than the static final String/Integer way and personally I think that the static final String/Integer way should be used only if we have good reasons to not use enums. And about where we should declare the constant values, the idea is to search whether there is a single existing class that owns a specific and strong functional cohesion with constant values. If we find such a class, we should use it as the constants holder. Otherwise, the constant should be associated to no one particular class.

---

静态final字符串/静态final整数vs enum

Enums usage is really a way to strongly considered. Enums have a great advantage over String or Integer constant field. They set a stronger compilation constraint. If you define a method that takes the enum as parameter, you can only pass a enum value defined in the enum class(or null). With String and Integer you can substitute them with any values of compatible type and the compilation will be fine even if the value is not a defined constant in the static final String/ static final Integer fields.

例如，下面两个在类中定义为静态final String字段的常量:

public class MyClass{

   public static final String ONE_CONSTANT = "value";
   public static final String ANOTHER_CONSTANT = "other value";
   . . .
}

下面是一个方法，它期望将这些常量中的一个作为参数:

public void process(String constantExpected){
    ...    
}

你可以这样调用它:

process(MyClass.ONE_CONSTANT);

or

process(MyClass.ANOTHER_CONSTANT);

但是没有编译约束阻止你以这种方式调用它:

process("a not defined constant value");

只有在运行时才会出现错误，并且只有在一次检查传输的值时才会出现错误。

对于enum，不需要检查，因为客户端只能在enum参数中传递enum值。

例如，这里有两个在枚举类中定义的值(所以是常量):

public enum MyEnum {

    ONE_CONSTANT("value"), ANOTHER_CONSTANT(" another value");

    private String value;

    MyEnum(String value) {
       this.value = value;
    }
         ...
}

下面是一个方法，它期望将这些枚举值中的一个作为参数:

public void process(MyEnum myEnum){
    ...    
}

你可以这样调用它:

process(MyEnum.ONE_CONSTANT);

or

process(MyEnum.ANOTHER_CONSTANT);

但是编译永远不会允许你以这种方式调用它:

process("a not defined constant value");

---

我们应该在哪里声明常数?

如果您的应用程序包含一个现有的类，该类拥有特定的和强大的常量值函数内聚，则1)和2)看起来更直观。 一般来说，如果常量是在操纵它们的主类中声明的，或者有一个很自然的名字，我们可以在里面找到它，那么使用起来会更容易。

例如，在JDK库中，在一个不仅声明常量声明的类(java.lang.Math)中声明了指数和π常数值。

   public final class Math {
          ...
       public static final double E = 2.7182818284590452354;
       public static final double PI = 3.14159265358979323846;
         ...
   }

使用数学函数的客户端经常依赖于Math类。 因此，他们可以很容易地找到常数，也可以很自然地记住E和的定义。

If your application doesn't contain an existing class that has a very specific and strong functional cohesion with the constant values, the 1 variant) and the 2 variant) ways appear more intuitive. Generally, it doesn't ease the use of the constants if these are declared in one class that manipulates them while we have also 3 or 4 other classes that manipulate them as much as and no one of these classes seems be more natural than others to host constant values. Here, defining a custom class to hold only constant values makes sense. For example in the JDK library, the java.util.concurrent.TimeUnit enum is not declared in a specific class as there is not really one and only one JDK specific class that appear as the most intuitive to hold it :

public enum TimeUnit {
    NANOSECONDS {
      .....
    },
    MICROSECONDS {
      .....
    },
    MILLISECONDS {
      .....
    },
    SECONDS {
      .....
    },
      .....
}      

在java.util.concurrent中声明的许多类都使用它们: BlockingQueue, ArrayBlockingQueue<E>， CompletableFuture, ExecutorService，…实际上，似乎没有谁比他们更适合主持这次全会。

仅仅为了保存常量而使用接口是一种糟糕的做法(Josh Bloch将其命名为常量接口模式)。以下是乔希的建议:

如果常数与 现有的类或接口 是否应该将它们添加到类中 接口。例如，所有的 盒装的数字基元类， 如Integer和Double，导出 MIN_VALUE和MAX_VALUE常量。如果 这些常数最好看成 枚举类型的成员 应该用enum导出它们吗 类型。否则，您应该导出 带有不可实例化对象的常量 实用程序类。

例子:

// Constant utility class
package com.effectivejava.science;
public class PhysicalConstants {
    private PhysicalConstants() { }  // Prevents instantiation

    public static final double AVOGADROS_NUMBER   = 6.02214199e23;
    public static final double BOLTZMANN_CONSTANT = 1.3806503e-23;
    public static final double ELECTRON_MASS      = 9.10938188e-31;
}

关于命名约定:

按照惯例，这些字段有名称 由大写字母组成的 用下划线分隔的单词。它是 重要的是，这些字段包含 要么是原始值，要么是引用 到不可变对象。

我同意大多数人所说的，在处理常量集合时最好使用枚举。然而，如果你在Android上编程，有一个更好的解决方案:IntDef Annotation。

@Retention(SOURCE)
@IntDef({NAVIGATION_MODE_STANDARD, NAVIGATION_MODE_LIST,NAVIGATION_MODE_TABS})
public @interface NavigationMode {}
public static final int NAVIGATION_MODE_STANDARD = 0;
public static final int NAVIGATION_MODE_LIST = 1;
public static final int NAVIGATION_MODE_TABS = 2;
...
public abstract void setNavigationMode(@NavigationMode int mode);
@NavigationMode
public abstract int getNavigationMode();

IntDef注释在一个简单的方面优于枚举，它占用的空间明显更少，因为它只是一个编译时标记。它不是一个类，也没有自动字符串转换属性。