声明私有静态最终变量的原因

Question

Why would you declare a static final variable as private for an immutable type?

Could it possibly do any harm to declare them public on any case?

Answer 1

因此，没有人可以从外部访问它并依赖于该值，让您可以自由地更改它而没有副作用的风险（至少在声明它的类之外）。

Answer 2

There are serveral reasons...

Privacy

Keep implementation details hidden from the clients, for example constants for internal use only and with no use for clients

Security

Protect your code from maliscious client codes for example:

static class A
{
    public final static List<String> list = buildList();

    public static List<String> buildList()
    {
        ArrayList<String> list = new ArrayList<>();
        list.addAll(Arrays.asList("A", "B", "C"));
        return list;
    }
}

static class B
{
    public static void main(String[] args)
    {
        A.list.clear();
        System.out.println(A.list);
    }
}

You dont want any one to manipulate you internal data.

Answer 3

It's just best OOP practice to keep variables within the proper scope. An example would be a global static final integer for performing a number of calculations within the class. Having it exposed (public) not only could cause problems, but confusion as well.

Say you had a class where you needed to know the value of pi:

public class MyClass {
    private static final double PI = 3.14159;

    //functions performing calculations with value of PI
}

The value of pi is only needed within MyClass , so leaving it to be exposed makes no sense - all calculations with the variable are done within MyClass . If you need it again to perform a calculation, it should be done within the class holding the value to keep your code organized.

Answer 4

public class GUICommon {
    private static final ExecutorService executorServices = Executors.newWorkStealingPool();

    public static void useExecutors(Runnable run) 
    {
    executorServices.execute(run);
    }
}

I used it on this way.

Answer 5

The static modifier, in combination with the final modifier, is also used to define constants. The final modifier indicates that the value of this field cannot change.

https://docs.oracle.com/javase/tutorial/java/javaOO/classvars.html

If you declare the static final variable with public, the variable will be able to see out site its class. It may cause a potential bug at compile-time if someone try to change its value in other classes.

If you declare the static final variable with private, it is hidden in other classes. So you can avoid the such a bug.