What is good practice to accessing package private variables?

Question

What is good practice to access my package-private variables from other classes in this same package?

1. Package-private accessor

   String getColor() {
       return color;
   }
   

2. Just accessing as field from object.

   String color = instanceOfClass.color;
   

In my opinion:

1. Package-private method for accessing package-private field. A lot of unnecessary code, but in my opinion provides clarity with a lot of fields (and properly named accessor methods)

2. We don't need accessors and mutators for package-private variables in package, so maybe I shouldn't create them?

Which practice is better, consistent with the programming convention?

EDIT: Thank you for fast answers! :)

Answer 1

Having accessors/mutators is usually handy even if it is some more code:

• If you later introduce some logic when accessing/setting the variable, you can do it just in one place without the need to affect all the classes using the variable - you can easily add features as additional logging, lazy loading, security, validation, ...

• You can later change the underlying representation of the field (eg return subtype in some cases)

• You can later introduce lifecycle management of the returned object - eg. Return pooled/cached/singleton/.. object
• You can later decide to return Proxy/decorated object instead without affecting callers

Generally, it is a good idea as it gives you more flexibility, preserves encapsulation and reduces coupling between objects.

Answer 2

Accessors and mutators have more to do with abstraction than they do with encapsulation. You want to be able to control how that field is set, rather than letting anyone put some random value in there. For example, you might have a value that should never be null, so..

void setField(Field field) {
    if(field != null) {
        this.field = field;
    }
}

And then you would declare your field variable as private. If you allow anyone to write anything into it, then this logic would need to be moved to everywhere that sets it, which will cause code duplication.

Answer 3

Use accessors only when necessary. Other than that, it is best to only allow package private variables to be accessed inside of that package. For example, if the variable is some value used in a calculation, do what you need with it inside the package using a public method call from another package, and then pass it to your other package.

Answer 4

Best practice is to use Getters and Setters.

This allows additional functionality (like validation) to be added more easily later and prevents you from giving the privilage of directly accessing these variables from other class.

private String color = InstanceOfClass.color;

String getColor(){
    if(background == White)
        return Black;

    else
        return White;

    }

You can have a good information about them here: Getter Setter: To Use or Not to Use