I was wondering if there was an equivalent to c++'s const in Java. I understand the final keyword, but unfortunately I cannot use that to declare a functions return value final. Instead, it always ensures the function cannot be overridden, correct?
Basically, I want to make sure a given returned class cannot be modified and is read only. Is that possible in Java?
Basically, I want to make sure a given returned class cannot be modified and is read only. Is that possible in Java?
Not directly, but one workaround is an immutable object.
Example -
public final Foo {
private final String s;
public Foo(String s){
this.s = s;
}
// Only provide an accessor!
public String getString(){
return s;
}
}
Java does not support const-qualification of references to objects.
Workarounds include the following:
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).
Java does not support the concept of constness as C/C++ use it.
The Java equivalent to this Foo class cannot be written.
class Foo
{
public:
std::vector<Bar>& bars( void ) const
{ return m_bars; }
private:
std::vector<Bar> m_bars;
};
However, Java has another approach, using interfaces.
class Foo
{
public:
ReadonlyList<Bar> bars( )
{ return m_bars; }
private:
ArrayList<Bar> m_bars;
};
Java's final keyword is more similar to Foo * const than any other c++ concept. Note that Foo const* is very common and useful, while Foo * const is less so.
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
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;
}
}
Java specifically discarded some features of C++, const is one of it. This conscious decision can be reflected by the fact that const is a reserved word in Java (but not used)
The designers probably thought that the feature is really annoying and not really useful. I had that feeling when I was a C++ coder. Certain kind of static checking is just way too much.
