Best practice/pattern for flag values

Question

I'm writing a class that has several public static final int fields that can be combined bitwise. I'm debating whether to number all the default values zero, have zero represent the defaults but NOT have public fields numbered zero, or number every field with a power of two.
I've thought of the following pros and cons:
The advantages of the first pattern include allowing the defaults to be set explicitly in user code, making the coder's intent apparent. The disadvantages include it being an error to test flags against the default (zero) values, and that error not being apparent to the user.
The advantages of the second pattern include there being no default values to erroneously test against. Disadvantages include the inability to set defaults explicitly.
The advantages of the thid pattern include being able to test against defaults and set defaults explicitly. Disadvantages include the possibility of erroneously setting two mutually exclusive flags.
I'm leaning toward the third pattern, because I can make it my own problem to test for mutually exclusive flags. Is there anything else I haven't considered?
Edited by: kjkrum on Oct 2, 2010 9:50 AM

Answer 1

kjkrum wrote:
I'm writing a class that has several public static final int fields that can be combined bitwise.Perfect, do it.
public class Person {
// female is 0, male is 1
  public static final int FLAG_GENDER = 1;
  public static final int FLAG_EMPLOYEE = 2;
  public static final int FLAG_CLIENT = 4;
  protected int flags = 0;
  public String getGender() {
    return (isFlag(FLAG_GENDER) ? "male" : "female");
  public boolean isEmployee() {
    return isFlag(FLAG_EMPLOYEE);
  public boolean isClient() {
    return isFlag(FLAG_CLIENT);
  public void setGender(String gender) {
    setFlag(FLAG_GENDER, (gender == "male"));
  public void setEmployee(boolean value) {
    setFlag(FLAG_EMPLOYEE, value);
  public void setClient(boolean value)
    setFlag(FLAG_CLIENT, value);
  protected boolean isFlag(int flag) {
    return ((flags & flag) == flag);
  protected void setFlag(int flag, boolean value) {
    if(value) {
      flags |= flag;
    else {
      flags &= ~flag;
}Done, that took me a whole 10 minutes with rewrites.
I'm debating whether to number all the default values zero, have zero represent the defaults but NOT have public fields numbered zero, or number every field with a power of two.
I've thought of the following pros and cons:
The advantages of the first pattern include allowing the defaults to be set explicitly in user code, making the coder's intent apparent. The disadvantages include it being an error to test flags against the default (zero) values, and that error not being apparent to the user.
The advantages of the second pattern include there being no default values to erroneously test against. Disadvantages include the inability to set defaults explicitly.
The advantages of the thid pattern include being able to test against defaults and set defaults explicitly. Disadvantages include the possibility of erroneously setting two mutually exclusive flags.
I'm leaning toward the third pattern, because I can make it my own problem to test for mutually exclusive flags. Is there anything else I haven't considered?
Edited by: kjkrum on Oct 2, 2010 9:50 AMWhat's more important... you sitting here trying to make a philisophical decision, or getting the class definition written?
Edited by: pierrot_2 on Oct 3, 2010 3:28 PM