public abstract class SuperClass {
public int x, y;
public static int z;
}
I want every subclass of SuperClass to have the static variable z. Naturally z will contain a different value for each subclass. I'm hoping to avoid defining z in every subclass, since it's going to be a functional dependancy of values x and y; Is this possible?
Unlike instance variables that are "one per instance", static variables are not "one per subclass" - they are "one per declaring class". In other words, subclasses of SuperClass share SuperClass.z, but they cannot "override" it on a class-by-class basis.
It does not mean that you cannot implement it yourself: on way to make your own per-subclass storage of integers is adding a static Map<Class,int> zs to SuperClass, with optional functions for accessing the data:
public abstract class SuperClass {
public int x, y;
private static Map<Class,Integer> zs = new HashMap<Class,Integer>();
protected static int getZ(Class c) {
Integer res = zs.get(c);
return res == null ? -1 : res.intValue();
}
protected static void setZ(Class c, int v) {
zs.put(c, v);
}
}
class SubClassOne extends SuperClass {
public int getZ() {
return SuperClass.getZ(SubClassOne.class);
}
}
class SubClassTwo extends SuperClass {
public int getZ() {
return SuperClass.getZ(SubClassTwo.class);
}
}
public static int z = x in each subclass. It doesn't result in any more lines of code than your suggestion regardless of how many subclasses I may want, right?
zs.Probably the best way to do this is to have a z() method or similar in the abstract class, and override the method in the subclasses you want.
Example:
public abstract class SuperClass {
public int x, y;
protected int z() {
return 42; // protected so only subclasses can see it - change if required
}
}
public class SubClassOne extends SuperClass {
public void foo() {
// do something...
int z = z();
// something else...
}
}
public class SubClassTwo extends SuperClass {
@Override
protected int z() {
return 1;
}
// use z() accordingly
}
Lexer has public abstract String[] getTokenNames();, subclasses have public static final String[] tokenNames = {...}; and implement the method.public static z = 1 either, so why do unneccesary code?SuperClass sup; SubClass sub;, and a nonstatic method SuperClass.foo() which accesses z. Both SuperClass and SubClass declare static int z;. sup.foo(); and sub.foo(); will both use SuperClass.z, because of static binding. The behavior you probably expected is that the z accessed depends on the identity of the object, not the class where foo() is declared. If that's what you wanted, then you're fine, but document that decision very well; it might confuse other devs.
if i understand you correctly then do
public abstract class SuperClass {
public int x, y, z;
public SuperClass(int z) {
this.z = z;
}
}
then any class that extends this class inherits z;
staticvariables belong to the class that declares them. The best you can do is hide them.