Re: Where do you keep contants in Interfaces or in cl*****?

Newsgroups: comp.lang.java.gui,comp.lang.java.programmer
Followup-To: comp.lang.java.programmer

Royan <romayankin@[EMAIL PROTECTED]
> writes:
>I have some controversial information on what is the best place to
>keep constants, is there any fundamental recommendation?

  The best place for a question not related to GUI programming
  is outside of »comp.lang.java.gui«.

  The best place for a question in the subject header line is
  a copy in the body of a post.

  (1) Constants can only be kept in interfaces, cl***** might
  have »final fields« or »constant variables«, but these are not
  called »constants« in Java.

  JLS3, 4.2.4 mentions constants in cl*****:

      »Other useful constructors, methods, and constants are
      predefined in the cl***** Float, Double, and Math.« 

  I admit that this contradicts my previous statement (1). But
  this might be the only place, where the JLS3 mentions
  »constants in cl*****«.

  In JLS3, however, 6.8.6 the wording is:

      »The names of constants in interface types should be, and
      final variables of class types may conventionally be, ...«

  This sup****ts (1).

  (BTW, »final variable of class type« seems ambigous to me.

  Is this a final variable /whose type/ is a class, such as:

final java.lang.Object v; ?

  Or is this a final variable that is /a field/ of a class:

class Example { ... final int v; ... } ? - ... Never mind)

  Constant-related terms are also mentioned in JLS3, 8.3.2.1:

      »One subtlety here is that, at run time, static variables
      that are final and that are initialized with compile-time
      constant values are initialized first. This also applies
      to such fields in interfaces (§9.3.1). These variables are
      constants” that will never be observed to have their
      default initial values (§4.12.5), even by devi-ous
      programs. See §12.4.2 and §13.4.9 for more discussion.«

  The definition of an instance of an enum type is called
  an »enum constant« by JLS3, 8.9.

  At least, the BNF-grammar given in the JLS3 only seems to
  mention »constant declaration« for interfaces (JLS3, 9.1.4):

InterfaceMemberDeclaration:
ConstantDeclaration

  This seems to suggest that by the grammar only interfaces
  can have constants (and enumerations can have enum constants).

  I also found this related little-read paragraph from JLS3,
  13.4.10 interesting:

      »The best way to avoid problems with "inconstant
      constants" in widely-distributed code is to declare as
      compile time constants only values which truly are
      unlikely ever to change. Other than for true mathematical
      constants, we recommend that source code make very
      sparing use of class variables that are declared static
      and final. If the read-only nature of final is required,
      a better choice is to declare a private static variable
      and a suitable accessor method to get its value.  [...]

      We also recommend, as a general rule, that only truly
      constant values be declared in interfaces. We note, but do
      not recommend, that if a field of primitive type of an
      interface may change, its value may be expressed
      idiomatically as in:

            interface Flags {
            boolean debug =new Boolean(true).booleanValue();
            }

      insuring that this value is not a constant. Similar idioms
      exist for the other primi-tive types.«

  So now the JLS does not only specify Java, but also acts
  as a style guide.

  By 15.28, a compile-time constant expression does not have to
  be a constant, it might be a name refering to a constant
  variable (4.12.4).

Newsgroups: comp.lang.java.gui,comp.lang.java.programmer
Followup-To: comp.lang.java.programmer