superclasses- initializing it's fields in the subclass

[David Duran]

Ok, I'm in super brain fart mode. It must be too many donuts from this morning.
The situation: I've got a superclass that defines a set of like integer values that are required by several subclasses, each subclass defining their own values. However, the subclasses shouldn't have to be instantiated. I'd like to have those values referenced simply as SubberClass.CONSTANT. Is this even possible?

public [B]abstract[/B] class Super
{
   protected int CONSTANT;
}
public [B]final[/B] class SubberClass extends Super
{
   // can I initialize CONSTANT w/o a constructor?
   public static equalTo(int i) // uh oh, can't reference non-static var in static context!!
   {
      return CONSTANT == i;
   }
}

In other words, does anyone have advice on the best way to design this? It seems like I'm asking something that can't be "done" the way I want it:
Declare int constants in a super class, extend and define the values in the subclass and reference those values publically via the class directly, not through a new'd instance. Thanks

[Michael Morris]

Hi David,

... publically via the class directly, ...

That just sounds like a static (class) member, unless I'm not understanding you.
Michael Morris

[David Duran]

Yeah, hahaha, so I'm guessing I can't do that. Since if I declare the variables as static in the superclass, then all the subclasses will share the same value, ie they can't set their own individually.
My solution then would be to use public accessor methods which unfortunately can't be static either. I'm trying to get around having to new the subclass because it's not necessary. There's no manipulation of those variables, just retrieval.

[David Duran]

Well hot dang, I just found out about this strange and crazy idea of the "Singleton Pattern". I'm reading up on it on some javaworld articles.
If you know of any other good articles on it, I'd appreciate it. I think the Singleton Pattern is exactly what will help me.

[Ilja Preuss]

Do you really need the Subclasses? What about using the typesafe enum pattern:

class MyType {
 
  public static final MyType FOO = new MyType(42);
  public static final MyType BAR = new MyType(7);
  ...
 
  private final int myIntValue;
  private MyType(int intValue) {
    myIntValue = intValue;
  }
  
  public boolean equalTo(int intValue) {
    return myIntValue == intValue;
  }
}
 
...
System.out.println(MyType.Foo.equalTo(13));
...

[ March 01, 2003: Message edited by: Ilja Preuss ]

[Garrett Smith]

abstract class Super {
    protected static final int CONSTANT;
    static { CONSTANT = 0; } // Super is always 0.
}

public final class SubberClass extends Super {
    // Initialize CONSTANT w/o a constructor?
    protected static final int CONSTANT = 10;  // SubberClass is always 10.

    public static boolean equalTo(int i) { 

        return CONSTANT == i;
    }

    public static void main(String[] args) {

        System.out.println(CONSTANT); // prints constant from this scope.
        System.out.println(SubberClass.CONSTANT);
        System.out.println(Super.CONSTANT);
    }
}

[Garrett-Smiths-Computer:java/practice/static] garrett% java SubberClass
10
10
0
The thing to remember is that you're hiding the variable and that hiding is limited to the subclass. If you want SubberClass value of the constant, you'll have to use CONSTANT within SubberClass or use SubberClass.CONSTANT.
Here's a program that demonstrates the scope hidden static members.

abstract class Super {
    protected static final int CONSTANT;
    static { CONSTANT = 0; } // Super is always 0.
}

final class SubberClass extends Super {
    // Hide superclass CONSTANT for this class
    protected static final int CONSTANT = 10;  // SubberClass is always 10.

    public static boolean equalTo(int i) { 

        return CONSTANT == i;
    }

    public static void main(String[] args) {
        System.out.println(CONSTANT); // prints constant from this scope.
        System.out.println(SubberClass.CONSTANT);
        System.out.println(Super.CONSTANT);
    }
}
class SuperNeighbor extends Super {
    public static void main(String[] args) {

        System.out.println(CONSTANT); // prints constant from this scope.
System.out.println(SubberClass.CONSTANT);
System.out.println(Super.CONSTANT);
    }
}

In addition to hiding static variables, you can hide static methods, and even instance methods and variables. See Ch 8 of the JLS.
It's a stupid trick and totally impractical. I wouldn't do this in a professional setting, or even in my own development, especially if you're prone to donut-induced confusion!
(fixed the forum tags)
[ March 01, 2003: Message edited by: Garrett Smith ]