Usage of final in java

Question

I was wondering what the difference is between

public final type attribute_name;

and

private type attribute_name;
public type getA_name() {
  return attribute_name;
}

Basically I want to make an attribute read-only, so it can't change after it has been initialized.
Do I make it public final, or do I make it private, and only make it accesible through a get method (without a set method)?

Answer 1

A final field MUST be set before the constructor exits. Once set, the reference cannot be modified (the value cannot be reassigned). Emphasis on the cannot be reassigned. This means that while the reference cannot change, the value itself can change.

This is legal:

final List<Integer> list = new List<Integer>();
list.add(5); // the value of list changes, but the reference doesn't

This is not:

final List<Integer> list = new List<Integer>();
list = new List<Integer>(); // may seem sort of redundant but the compiler won't allow it nonetheless

---

A private variable with a only getter can be reassigned internally by the class that holds it (but it's not visible externally so it cannot be reassigned outside the class holding it). Also, outside the class the reference is inaccessible so the variable cannot be modified except by the class holding it.

A final variable cannot be reassigned anywhere, but if it's public, another class can still access the reference and change the value of whatever object it points to.

If you don't want the variable to be reassigned after initialization as you described, use both final and private.

---

Use final for something like this:

public class User {

    private final long registrationTimeMillis;

    public User(/* various parameters probably would be here */) {
        registrationTimeMillis = System.currentTimeMillis();
    }

    public long getRegistrationTimeMillis() {
        return registrationTimeMillis;
    }
}

We don't expect that a user's registration time will change, so it makes sense to not allow it to change after construction.

---

Use private with no setter for something like this:

public class VendingController() {

    private int drinksStocked = 0;
    private int drinksDispensed = 0;

    public void dispenseDrink() {
        drinksDispensed++;
    }

    public void stockDrinks(int numberOfDrinks) {
        drinksStocked = getDrinksRemaining() + numberOfDrinks;
        drinksDispensed = 0;
    }

    public int getDrinksRemaining() {
        return drinksStocked - drinksDispensed;
    }
}

We don't want the value of drinksDispensed to change except when dispenseDrink() or stockDrinks(int numberOfDrinks) is called. It still needs to be able to be reassigned by it's own class when the vending machine is refilled though, so we shouldn't make it final

---

With respect to using public final, generally in Java that's only done for constants and that static keyword is also included since constants shouldn't be dependent on an instance.

An example of when it makes sense to use public static final

public class UnitConversions {

    public static final double CENTIMETERS_PER_INCH = 2.54;

}

It could then be used in a method as follows

public double convertFromCentimetersToInches(double centimeters) {
    return centimeters / UnitConversions.CENTIMETERS_PER_INCH;
}

---

Best of luck OP and happy coding.

More reading on final fields

Answer 2

When it's not final but private, the class itself is able to change the value.

Answer 3

The final modifier allows a field to be assigned only once - it cannot be changed after that and it has to be set at during object construction (that is, before the constructor returns).

If you want to make the field read-only, use the principles of information hiding: make it private and provide a public getter that returns the field (or a copy of it for non-primitive types).

You should use public final only for true constants. Even if your field is immutable because of final it is often a good idea to still make it private.

Answer 4

The correct way is to think in the future. What would help you achieve your goals? Maybe later you would also like to give that variable a value. If I were you, I'd do this by creatin a get method and keeping the variable private.

Full documentation for final keyword : http://en.wikipedia.org/wiki/Final_(Java)

Answer 5

Depends on where you want to access it from. Public variables can be accessed from any class within the project and package where private can only be accessed from the class where the variable is.

The 'final' operator makes it permanent and read-only.

Answer 6

Let's assume that type is a reference to an object, not a primitive type.

1. public final type attribute_name means that attribute_name cannot be reassigned to refer to something else. But attribute_name can be used to call a method that changes its state.

2. In private type attribute_name, only methods within the class can call methods on attribute_name.

So if you want it to remain constant, use approach (2). Limit the public methods to ones that ultimately call methods on attribute_name that don't modify its state.

Answer 7

This depends on some factors.

If this is a real constant that is known before and will never change, then use final. In Java final fields can be initialized in the constructor as well, so if your value is known at construction time then you can use final too.

If this value gets set (once, multiple times) during runtime then use private + getter.