抽象类中的私有字段与私有静态字段

Question

I am confused about the scope of a private field versus a private static field of an abstract class. For example, consider the following classes and note the field validator ,

abstract class ValidComponent {
    private static Validator validator = ... //(statement to instantiate new Validator)

    /** 
     *  This method is to be used by subclasses in their factory-methods 
     *  to do some validation logic after instantiation.
     */
    protected void selfValidate() {
        //validation logic
        ...
        validator.validate(this); // <<< This line uses the validator
        ...
    }
}

class ValidUsername extends ValidComponent {

    private @NotEmpty String core;
    private ValidUsername(String unamestr) {
        this.core = unamestr;
    }

    /** This is the factory-method who use selfValidate() */
    public static ValidUsername create(String unamestr) {
        ValidUsername vuname = new ValidUsername(unamestr);
        vuname.selfValidate();
        return vuname;
    }
}

class ValidEmail extends ValidComponent {
    private @Email String core;
    private ValidEmail(String emailstr) {
        this.core = emailstr;
    }

    /** This is the factory-method who use selfValidate() */
    public static ValidEmail create(String emailstr) {
        ValidEmail vemail = new ValidEmail(emailstr);
        vemail.selfValidate();
        return vemail;
    }
}

The abstract class ValidComponent prepares method selfValidate() , in which the private static field, validator , is used.

The ValidUsername and ValidEmail are subclasses that illustrate the intention of their base class: the method selfValidate() are used in their factory-methods to validate themself.

If my understanding is correct, when vuname.selfValidate() and vemail.selfValidate() are called, both use the same Validator object, ie ValidComponent.validator .

But what if I happen to change the modifiers of validator from private static to only private , are Validor objects used in vuname.selfValidate() and vemail.selfValidate() still the same object?

Answer 1

No they are not. The static keyword means the field belongs to a class . It will be a single instance across whole VM. Without the static keyword the field belongs to an object , so each instance of the ValidComponent or its subclasses will produce new Validator object.

Answer 2

are Validor objects used in vuname.selfValidate() and vemail.selfValidate() still the same object?

No, only static data member can be shared whether private or not. Here private static Validator validator = ... is a data member of class ValidComponent whereas private Validator validator = ... is a data member of object and can't share with another object.

Answer 3

I'm not sure but I don't think this is appropriate, to use the same Validator for different objects. Your Valid* classes don't share the same constraints therefore the same validation errors. Sharing the same object can cause inconsistency.

You can change private static to private , but your design might be problematic from the outset.

Maybe factory pattern suits you better.

To answer your question

are still the same object?

No they are not.

Answer 4

Consider a private variable,

private String name;

and its getter/setter which are ofcourse public .

Now every class has access to getter/setter which in its implementation uses private variable. That's the purpose of private variables, not accessing it directly from other classes.

Your case is similar where in private validator is being accessed by selfValidate() method. By their signature, selfValidate() is accessible to subclasses.

To answer your question about whether validator object will be different in case of non-static or not, then every class that accesses it will create a new instance of that object.