Getter Pattern Within Class?

Question

I have a field in a class that should only be accessed directly from a getter. As an example...

public class CustomerHelper {
  private final Integer customerId;
  private String customerName_ = null;

  public CustomerHelper(Integer customerId) {
    this.customerId = customerId;
  }

  public String getCustomerName() {
    if(customerName_ == null){
      // Get data from database.
      customerName_ = customerDatabase.readCustomerNameFromId(customerId);
      // Maybe do some additional post-processing, like casting to all uppercase.
      customerName_ = customerName_.toUpperCase();
    }
    return customerName_;
  }

  public String getFormattedCustomerInfo() {
    return String.format("%s: %s", customerId, getCustomerName());
  }
}

So even within the class itself a function like getFormattedCustomerInfo should not be able to access it via customerName_. Is there a way to enforce a class not access a field directly aside from the provided getter function?

Answer 1

There is no such mechanism in Java (or at least I think there should not be). If you are sure that getFormattedCustomerInfo should be prohibited from direct access to customerName_, create another class and compose them.

I would recommend CustomerInfoFormatter.

Also, I would change customerName_ to customerName as the language supports privacy by explicit declaration and it is not needed to add more indicators.

Answer 2

It looks like you are trying to cache the database value, and want to protect against accessing a value which has yet to be cached.

If this is true, then the variable customerName_ should not exist in the CustomerHelper class; the cached value should exist closer to the database.

The method customerDatabase.readCustomerNameFromId(customerId) should first look at a cache, and if the cache is empty, call the database and cache the result.

Effectively, customerName_ becomes a value in the cache: Map<Integer, String> cache where the key is customerId.