Equivalent of const(C++) in Java

Java does not support const-qualification of references to objects.

Workarounds include the following:

• Immutable objects.
• Unmodifiable views of modifiable objects (for example, those returned by Collections.unmodifiable*()).
• Read-only interface types
• Defensive copies.

Immutable objects prevent modification by the recipient, but they also prevent modification through any reference. They are not equivalent to C++ const pointers/references.

Closest are read-only interface types. You could map a const-correct C++ class to two Java units, one an interface with only the const-qualified methods.

This is sometimes useful, to control what can modify an instance of the class. However, it's not done as frequently as in C++.

The "final" keyword means const. But the use of final in java is much different than C++ Only fields or local variables can be final. A final class is not a const class but a sealed class that cannot be inherited. A final method is a sealed method, a method that cannot be overridden.

In C++ there is the concept of "const type" but in java you have only the concept of const field, const method (not-overridable) and const class (not-inheritable).

I think you want a immutable object. An object is considered immutable if its state cannot change after it is constructed.

To do that you need

• ensure the class cannot be overridden - make the class final, or use static factories and keep constructors private
• make fields private and final force callers to construct an object completely in a single step, instead of using a no-argument constructor combined with subsequent calls to setXXX methods

• do not provide any methods which can change the state of the object in any way - not just setXXX methods, but any method which can change state.

  public final class SomeThing{

  public Something(String name) {
      fname=name
  }
  
  private final String fName;
  
  public String getName() {
        return fName;
  }
  

  }