Re: Class Constants - pros and cons
Magnus Warker a ??crit :
Don't top-post!
It's the readibility of the code.
With constant classes I can write something like this:
public void setColor (Color color)
{
if (color == Color.WHITE)
No. That would be a bug. You'd write 'if ( color.equals( Color.WHITE ) )'.
...
}
This is not possible with enums, since an enume type must be defined in a
class:
public void setColor (SomeClass.Color color)
{
if (color == SomeClass.Color.WHITE)
...
}
And how is that less readable? Besides, it's wrong. 'Color' would *be* the
enum, so you'd still have 'Color.WHITE', unless 'Color' were a nested class,
but then it would be in the constant String scenario, too.
Further besides, with an enum you wouldn't say
if ( color.equals( Color.WHITE ))
{
foo( something );
}
or
if ( color == Color.WHITE )
{
foo( something );
}
you'd say
color.foo( something );
Jean-Baptiste Nizet wrote:
No. Read more about enums. Enums are classes, and can be top-level
classes. You define them, as regular classes, in their own .java file :
// Color.java
package com.foo.bar;
public enum Color {
WHITE,
BLACK;
}
// SomeClass.java
public void setColor(Color color) {
this.color = color;
if (color == Color.WHITE) {
// ...
}
switch (color) {
case WHITE :
// ...
}
}
Magnus Warker a ??crit :
I think, it would be ok, if I needed the enum only in SomeClass.
But what about constants that are needed in many classes?
??
Have them refer to the enum.
Jean-Baptiste Nizet wrote:
You define them in their own .java file
Magnus Warker a ??crit :
I saw that constant classes are used widely in the java api, e. g.
java.awt.PageAttributes.MediaType. But I also saw constants declared as
Jean-Baptiste Nizet wrote:
Yes, because enums only appeared in Java 5, and lots of classes had
already been written before that, and thus used final ints or Strings
instead.
Peter Duniho wrote:
Have you thought about using enums instead? If enums aren't solving
your need, it would be helpful if you could explain why.
That would still be helpful.
ints and Strings are not typesafe. enums are. Use enums.
If you expect a constant String 'GlueConstants.CHOIX' equal to "foobar" and
pass 'ShoeConstants.CHOIX' equal to "fubar" instead, the compiler won't
complain. If you pass the wrong enum it will.
Since enums are classes, they can contain behavior. That means you won't need
if-chains nor case constructs to select behavior; just invoke the method
directly from the enum constant itself and voil??!
--
Lew
Don't quote sigs, such as this one, either.