How do you reproduce the behavior of const-pointers in Java?

Question

I have a singleton class containing a bunch of control data that needs to be kept synchronized with the rest of my application. As a result, there are many times which I want another class to be able to read the information but not modify it. Currently, this singleton class has many public variables. I don't want to use getter and setter functions because they are wordy and annoying. Also, there are a lot of variables.

If my singleton class is called ControlData, I could create a second create a second class called ImmutableControlData, where it has all the same members, but they are declared final. Then, when retrieving my singleton, I would return an ImmutableControlData, rather than a ControlData object. However, this means that I need to constantly maintain the ImmutableControlData class as well as the ControlData class (annoying...)

If I had const-pointers, I would just return a const-pointer to my ControlData object. What can I do in Java, instead?

But they do need to be modifiable. I just want to prevent them from being modified unintentionally. — user1990929, Jan 18 '13 at 15:50
In C++, returning const pointer could wake up the const-correctness monster. — 9dan, Jan 18 '13 at 15:53
Why are you even using a singleton in the first place, on an unrelated note? — Shotgun Ninja, Jan 18 '13 at 15:56
because there's only one set of control data that's actually correct at any given time. the real question is why should there be more than one? — user1990929, Jan 18 '13 at 16:01
Immaterial. Why should it be globally accessible? Just create one instance. — Puppy, Jan 18 '13 at 16:02
@user1990929: there's only one date that's correct at any given time, but `Date` isn't singleton ;-) Do as you please, of course, but if your class is designed to represent a value of something (in this case a sack of control data), it doesn't necessarily follow that you will never want to deal with two different values of that something in the same program. The usual practical problem with singletons is that you come to test some code that uses them, and discover that you'd actually like to provide specific values that are "currently incorrect". — Steve Jessop, Jan 18 '13 at 16:08

score 3 · Answer 1 · answered Jan 18 '13 at 15:52

Java does not have const correctness like C++.

You could make an interface that declares the methods to read the data, but not the methods to modify the data. Make the class that holds the data implement this interface. Methods elsewhere in your program that should only read the data, should accept the interface, not the class, as the parameter type. For example:

public interface ReadablePerson {
    String getName();
}

public class Person implements ReadablePerson {
    private String name;

    @Override
    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}

// Elsewhere...
public void someMethod(ReadablePerson p) {
    System.out.println(p.getName());
}

Ofcourse, in someMethod you could still subvert this by casting p to Person, but at least it requires some conscious effort (adding the cast), which should alert the programmer that (s)he is doing something (s)he shouldn't do.

An advantage of this solution is that you don't have to make a defensive copy of the data.

yes, I was hoping there was a solution that didn't involve them, but I guess there isn't. — user1990929, Jan 18 '13 at 15:58

score 0 · Answer 2 · answered Jan 18 '13 at 15:55

First: If your Class has so many members, you should try to split the class into littler ones. Maybe you can summerize some variables eg.

ControlflowVariables StateVariables

If you want to restrict the access to the variables you have to use getter. IDE can create getters and setters for you. The access to variables are the same:

singletonClass.variable is not worst then singletonClass.getVariable()

If you want to restrict the access only at some points in your code then create a final copy of tha variable

final int variable = singletonClass.getInstance().variable;

score 0 · Answer 3 · answered Jan 18 '13 at 15:55

Personally, I would not try to control access in this way. There is nothing you can to do to prevent bad programmers from misusing your class. Even in C++, they could use a simple const_cast to remove your "protection" and modify the singleton any way they like.

Instead, I would restructure the code to make it easy for others to do the right thing and hard for them to get it wrong. Segregate the interface for ControlData into two separate interfaces: one for reading the object and one for updating it. Then simply provide the two interfaces where they're needed.

How do you reproduce the behavior of const-pointers in Java?

3 Answers3