Persisting a properties object across the whole of my program.

Question

Hello all,
As per usual, sorry for any idiocy on my part and thanks for any guidance.
I have written a wrapper class for the Properties class.
I have an MDI which creates a properties object and loads it at start up, and I have tried to use the same object again (to save any property changes) when the app terminates. However, I get a nullPointerException when I try and use it when the program closes. Below is what I hope are the relevant pieces of code. I don't include it all as it a couple of hundred lines long - but can easily do so if you think it will help. Many thanks once again:
Here is the load properties method:
private void yLoadProperties(){
        String workingDirectory = System.getProperty("user.dir");
        File yFile = new File(workingDirectory + "\\KTProperties.ini");
        YPorperties yProperties = new YPorperties(yFile);
        yProperties.yLoadProperties();
        // Retrieve application name - no conversion required
        yApplicationName = yProperties.yGetProperty("ApplicationName");
}and here is the exit program method with the call the the save properties method
private void yExitApplication(){
        // Save properties back to disk
        yProperties.ySaveProperties();
        // Exit
        System.exit(0);
    }I have also declared the yProperties variable thus:
private YPorperties yProperties;
I was hoping to use the yProperties object anywhere within my program to adjust properties as required. Any help, gratefully received.
Steve

Answer 1

That's just the way Java works. I'm sure someone is able to quote chapter and verse of the Java Language Specification that spells it out, but the basic distinction is this:
A variable declaration has the form: <Type> <variableName> [= <value expression>];.
A variable assignment (which assigns a value to an existing variable) has the form: <variableName> = <value expression>;
When you specify the type of a variable, Java assumes you are declaring a new variable in the current scope, regardless of whether the name of the variable already existing in a enveloping scope. When you don't specify the type, Java will look for an existing variable with that name in the current scope and any enveloping scopes.
In my mind, when I explicitly declared yProperties, thus:> private YPorperties yProperties;> I was making it available to the whole program.With that line you declared a member variable of type YPorperties (shouldn't that be YProperties, by the way?), which means a separate yProperties variable is available as a member of each instance of your class. Note that you already specify the type of the variable yProperties in that line, so there is no need to specify that type again when using the variable further on in your application.
But yes, you are correct in saying that this variable would be available anywhere inside that one instance of your class. However, it is possible in Java to declare a variable with the same name in a different, narrower scope (as you have seen).
Java looks for variables from the narrowest scope outward, so in this case it sees the local variable yProperties before it sees the member variable yProperties.
(BTW for future reference, note that a class or an instance of a class is not a "program" as such. So declaring a private member variable does not make it available to your "program", it makes it available to an instance of a class. The fact that you use that class to start your application is irrelevant)