Enforce setting private variable in subclass with abstract method

Question

Hi,
Is this something that is common usage/practice?:
public abstract class Base {
    private int importantPrivateVariable = setImportantPrivateVariable();
    protected abstract int setImportantPrivateVariable();
}I would like to enforce the extender of the class to set a private variable, but as there is no abstract variable in java, I can only use a method for it.
Thanks,
lemonboston
Edit: the variable could be protected as well, I suppose this is not important here, but correct me if I am wrong

Answer 1

lemonboston wrote:
Hi,
Is this something that is common usage/practice?:I don't think that's so common, but that's code easily understandable. However there are several problems with this approach:
public abstract class Base {
private int importantPrivateVariable = setImportantPrivateVariable();
protected abstract int setImportantPrivateVariable();
}I would like to enforce the extender of the class to set a private variableThat's no what your code implements: your base class forces the subclasses to return an int value, and the Base class uses that value to assign it to the variable.
Therefore the method should be called get<Something> (e.g. <TT>getInitialValueOfImportantVariable()</TT>+ to have a naming consistent with its signature (it returns a value, whereas a regular setter method should declare a void return type: <TT>protected abstract void setImportantPrivateVariable(int someValue);</TT>).
Edit: the variable could be protected as well, I suppose this is not important here,Well, yes, this is "important" - at least, there a noticeable difference: the variable being private, the base class is free to handle it as it sees fit (e.g., assign the value at construction time and never modify it afterwards). If the variable was protected, the subclass could modify in ways and at times not known by the base class.
but correct me if I am wrongThere's a trap in this construct: the method is called in the variable initializer, that is, behind the scenes, approximately during the execution of the Base class constructor, so before the subclass constructor. So, you are calling a method on an object that is not fully initialized (e.g. some of its attributes may still be <TT>null</TT> at this stage). There is a rule that discourages such situations, that goes something like "don't call non-private and non-final methods from a constructor".
To avoid this trap, two options:
- require an int argument in the Base class's constructor , as was suggested above
- don't get and set the value of the important variable in the initializer or constructor code, but from a special method in the base class instead:
public abstract class Base {
    private int importantPrivateVariable; // default value is zero
// or alternatively:
//    private int importantPrivateVariable = ...; // Some default value
    protected abstract int getImportantPrivateVariable();
    public void initializeImportantPrivateVariable() {
        importantPrivateVariable = getImportantPrivateVariable();
}That construct is a degenerate form of a common design pattern known under the name of Template Method (where a base class method calls generally several subclass methods in a specified order and with a specified chaining, leaving it to the subclass to implement the details of the methods).
The drawback is that the client code (the one that uses the Base instance) has to know when to call that initialization method, whereas the constructor-based initialization lets the client code free to not care at all.
Much luck,
J.