Being specific in the Constructor, only when necessary

Question

Hello! I am new to Java. I have a few really simple question. I know this much so far:
- Hiding is when a variable overrides another within a stronger (more inner) scope.
- Hiding is not good convention since it may confuse readers of code.
So I have this example. It's only part of an example, so it will only be the essential parts:
package example;
import java.awt.*;
public class Application {
     * The options component for this Application.
    Component optWindow;
    public Application() {
        Window optWindow = new OptionWindow();
        optWindow.pack();
        this.optWindow = optWindow;
    public void showOptions() {
        optWindow.setVisible(true);
    @Override protected void finalize() throws Throwable {
        optWindow.setVisible(false);
        optWindow = null;
        super.finalize();
class OptionWindow extends Frame {
    public OptionWindow() {
        super("Options:");
}Anyway, I also know that optWindow in the constructor hides this.optWindow. But I'm not sure 100% why.
My reasoning behind wanting to do this is that I don't think that the rest of the Application needs to know that optWindow is a Window other than in the constructor, so the Application Object should store it as just an abstract component. A sort of "type encapsulation and subclass separation".
I believe that the reason why this is hiding is because optWindow refers to the "reference" of the OptionWindow object, not the object itself =) I understand that so far.
But I believe it shouldn't because the this.optWindow does not refer to anything until after the constructor, so it shouldn't be hidden.
I have a few solutions I know of:
1) Drop the idea of storing optWindow as a Component in the Application Objects. Just store it as a window everywhere.
2) Keep it this way anyway.
3) Use a different variable name for the optWindow in the constructor.
There are in the order that I'd rather do them in. I understand that option 1 is the best. Option 2 might potentially be okay. Option 3, I really do not like since it's giving two names or references to the same object and it would be annoying to come up with a new name for it. But I could come up with something simple like "window" if necessary inside of the constructor.
My questions would be:
1) Is this a good idea to make the window an abstract component outside of the constructor?
2) Is this a "good" use of hiding; or does the rule always apply to avoid hiding?
If Question 1 is true, I'd probably go with Option 1. If Question 1 is false, but Question 2 is true, I'll go with Option 2. If Question 1 is still false, but so is Question 2, I'll go with Option 3.
Thank you very much in advanced! I really appreciate the help! =) And I look forward to asking more questions.
Edit: I wrote that OptionWindow throw Frame instead of "extends Frame".
Edited by: Macleod789 on Mar 30, 2010 2:24 PM

Answer 1

Macleod789 wrote:
Hello! I am new to Java. I have a few really simple question. I know this much so far:
- Hiding is when a variable overrides another within a stronger (more inner) scope.
- Hiding is not good convention since it may confuse readers of code.It's common and perfectly acceptable in some situations. Constructors and setters come to mind. If your code is well-written, it won't be at all confusing.
>
So I have this example. It's only part of an example, so it will only be the essential parts:
package example;
import java.awt.*;
public class Application {
* The options component for this Application.
Component optWindow;
public Application() {
Window optWindow = new OptionWindow();
optWindow.pack();
this.optWindow = optWindow;
public void showOptions() {
optWindow.setVisible(true);
@Override protected void finalize() throws Throwable {
optWindow.setVisible(false);
optWindow = null;
super.finalize();
class OptionWindow extends Frame {
public OptionWindow() {
super("Options:");
}Anyway, I also know that optWindow in the constructor hides this.optWindow. But I'm not sure 100% why.Because the JLS defines that it does. Local variables always hide members of the same name. That's the rule the designers decided on.
My reasoning behind wanting to do this is that I don't think that the rest of the Application needs to know that optWindow is a Window other than in the constructor, so the Application Object should store it as just an abstract component. A sort of "type encapsulation and subclass separation".\Huh? Reason behind doing what? Declaring the optWindow member as a Component rather than a Window? Well, yeah, if the rest of the Application class only cares that it's a Component and could do its job the same way if any other Component were used, then you're right--declaring it as a Component is the correct approach. But then it should not be named optWindow. And if the rest of the Application class doesn't need it to be a Window, then the c'tor has no reason to require that either.
I believe that the reason why this is hiding is because optWindow refers to the "reference" of the OptionWindow object, not the object itself =) I understand that so far.Reference vs. object is an important distinction to understand. However, it has nothing to do with hiding. Hiding is just about identifier names, like variables. The fact that their values are references is irrelevant to the hiding rules.
But I believe it shouldn't because the this.optWindow does not refer to anything until after the constructor, so it shouldn't be hidden.Show me the part of the JLS that says that hiding has do with whether the variable in question has been assigned or not.
In some scopes, two distinct identifiers with the same name can exist. There has to be some rule about which one takes precedence when there's no qualification. It's simpler if it's consistent and it's always the local. If it weren't, then a) it would be inconsistent, which would be confusing, and b) we'd need a new keyword or other mechanism to explicitly indicate that we're talking about the local. Or else we simply wouldn't be able to access the local variable in those contexts, which would be pretty stupid, I'm sure you agree.
I have a few solutions I know of:Solutions to what? What's the problem you're encountering?
1) Drop the idea of storing optWindow as a Component in the Application Objects. Just store it as a window everywhere.I addressed that above, and it has nothing to do with hiding.
2) Keep it this way anyway.So, a "solution" to whatever problem you're having is to do nothing and just keep having the "problem"?
1) Is this a good idea to make the window an abstract component outside of the constructor?If it's Component in the member variable, it should be in the c'tor too. If the c'tor requires a Window, then it must be because the member has to be a Window.
2) Is this a "good" use of hiding; or does the rule always apply to avoid hiding?It's very common and acceptable to have parameter names match member names where the parameter is being used to set the member.
Edited by: jverd on Mar 30, 2010 2:49 PM
Edited by: jverd on Mar 30, 2010 2:50 PM