Just a simple question about a Java Programm

[thomason93]

Ok, I have to write a programm for my school in which I use 3 classes. These classes are:
Class Window

public class Window
{
protected int size;
public Window()
{
size=1;
System.out.println("Window size="+size);
}
public Window(int size)
{
this.size=size;
System.out.println("Window size="+size);
}
public void setSize(int x)
{size += x;}
public void printSize()
{System.out.println("Size=" + size);}
}

Class MWindow

public class MWindow extends Window
{
private String message = "No message";
public MWindow(String message)
{
size = 2;
this.message = message;
System.out.println ("Window message = " + message);
}
public MWindow(int size, String message)
{
super(size);
this.message = message;
System.out.println ("Window message = " + message);
}
public void setSize1(int y)
{size = y;}
public void setSize2(int z)
{super.setSize (z);}
public void printSize()
{System.out.println ("MSize="+size);}
public void printSize1()
{System.out.println (super.size);}
public void printSize2()
{super.printSize();}
}

Class RunWindow

public class RunWindow
{
public static void main (String[] args)
{
MWindow mw1=new MWindow("First MWindow");
MWindow mw2=new MWindow(3, "Second MWindow");
System.out.println(mw1.size);
System.out.println(mw2.size);
}
}

And the question I have is what is gonna print this programm. In my opinion, the printed results should be

Window message = First MWindow 
Window size=3 
Window message = Second MWindow 
2 
3

but the printed results I get when i run the programm are

Window size=1 
Window message = First MWindow 
Window size=3 
Window message = Second MWindow 
2 
3

So, the 1st line which get printed ("Window size=1") is the one I cant explain why is printed. I have figured out that for some reason, this line is printed cause of the 1st constructor of class Window, although I dont call this constructor in my code. Can anyone help me out with this question? My deadline for this excercises set is tomorrow. Thanks in advance.

[PhHein]

Subclass constructors always implicitly call super(); which is the default constructor of Window.

[thomason93]

Ok, I didnt know that. But why this implicit call of super(); is only happening during the construction of mw1 instance and not during the construction of mw2 instance?

[PhHein]

Because you are calling the super(int size) constructor explicitly yourself in line 12 of MWindow.

[Norm]

Window is the name of a Java SE class. It will be less confusing if your code used its own name and not a Java SE name.

[thomason93]

Because you are calling the super(int size) constructor explicitly yourself in line 12 of MWindow.

So, every time I call a constructor of a subclass, he also calls his super() automatically, even if I have not called anywhere in my code this default constructor of the "upper" class. But this implicit call of super() is not happening, if I have called somewhere in my subclass constructor super() by myself with or without arguments (e.g super(size) ). Am I right?

Window is the name of a Java SE class. It will be less confusing if your code used its own name and not a Java SE name.

I would change the name of this class to something different, but the question dictates me to give that class the name "Window".

[PhHein]

So, every time I call a constructor of a subclass, he also calls his super() automatically, even if I have not called anywhere in my code this default constructor of the "upper" class. But this implicit call of super() is not happening, if I have called somewhere in my subclass constructor super() by myself with or without arguments (e.g super(size) ). Am I right?

Not really, the first line of a subclass constructor is super(xyz) not somewhere, either because you've written it or the compiler inserts super() automatically. Just for testing remove the Window() constructor and recompile. You'll get a compiler error.

[gimbal2]

This is dragging on a bit. I'm going to attempt to just explain the rules that are in play here.

If there is one thing that -must- happen, it is that constructors are invoked. If that wouldn't happen then objects wouldn't properly be initialized. So Java does this for you so you can't forget, upon object creation.

That problem becomes slightly harder when you have a hierarchy of classes because then a constructor needs to be invoked in each class in that hierarchy so each individual layer can initialize itself. Again: this MUST happen or you'd end up with half-initialized objects. The question becomes: which constructor must be invoked? Sometimes Java can implicitly make that choice for you, sometimes it cannot.

- if there is a default constructor (or no constructor at all so Java generates a default constructor for you), Java can invoke that for you without any help
- if there is no default constructor but there is at least one constructor which accepts parameters, you need to explicitly invoke that constructor through super(param, param, etc.)
- if there are multiple constructors then you have to make sure that the appropriate one is explicitly invoked by using super with the correct parameters

But the whole point of all this is: a constructor MUST be invoked. And then what is in your care is that the CORRECT constructor is invoked. Hence: the usage of super().

[thomason93]

Thank you very much all for your helpfull answers. I gave in this set or excercises in time. I think I figoured out approximately the purpose of super() use etc. Though I still have a few more questions that came of these excercises.

If I add the following lines in main in RunWindow so it looks like:

public class RunWindow
{
public static void main (String[] args)
{
MWindow mw1=new MWindow("First MWindow");
MWindow mw2=new MWindow(3, "Second MWindow");
System.out.println(mw1.size);
System.out.println(mw2.size);

mw1.setSize1(4);
System.out.println(mw1.size);
mw1.setSize2(2);
System.out.println(mw1.size);
mw1.setSize(2);
System.out.println(mw1.size);
}
}

then the printed results I get are:

Window size=1
Window message = First MWindow
Window size=3
Window message = Second MWindow
2
3
4
6
8

I understand how these results came out. But if I add the the statement "protected int size =7;" in class MWindow, so now MWindow now looks like:

public class MWindow extends Window
{
    private String message = "No message";
    protected int size =7;
   
    public MWindow(String message)
    {
        
        size = 2;
        
        this.message = message;
        
        System.out.println ("Window message = " + message);
    }
    public MWindow(int size, String message)
    {
        super(size);
        this.message = message;
        System.out.println ("Window message = " + message);
    }
    public void setSize1(int y)
    {size = y;}
    public void setSize2(int z)
    {super.setSize (z);}
    public void printSize()
    {System.out.println ("MSize="+size);}
    
    public void printSize1()
    {System.out.println (super.size);}
    public void printSize2()
    {super.printSize();}
}
}

I get these results:

Window size=1
Window message = First MWindow
Window size=3
Window message = Second MWindow
2
7   //these
4   //lines
4   //have
4   //changed

I think I also understand how these results came out, but I m not sure. Whose instance's size value is '3' in line 3? Is it something like "mw2.super.size" ? (if this statement is valid). Can someone explain me what is actually happening in this case?