Overloaded constructors from main() and plugin.execute()

Question

edits...

1. Does instantiating a class with an overloaded constructor from main() also call the parameterless constructor?
2. Do applications that instantiate a plugin class with an overloaded constructor with plugin.execute() necessarily call the parameterless constructor?

to clarify: I'm expecting one answer for main() and one for plugin.execute() entry points.

class pluginObj {

    public pluginObj() {}             // default /primary constructor
    public pluginObj(int altConst) {} // alternate constructor

    public execute() {    //... plugin entry code goes here
    }

    public main() {       //... test entry code goes here
    }
}

context: class is a plugin for another application, using main() for testing in the short term I know that Junit is the correct way to do this in the long run.

Answer 1

Constructors works like this

Public class ExampleClass{
    private int in1;
    private int in2;
    public ExampleClass(){
        this(5) // overloading using some default value
    } // overloads the below and if called super is called here and not below, this then runs the functionality of the below constructor

    public ExampleClass(int in1){
        super(); // hidden call to parent constructor
        this.in1 = in1;
    } // doesn't overload the below or above, and if called simpley sets int1

    public ExampleClass(int in1, int in2){
        super(); // hidden call to parent constructor
        this.in1 = in1;
        this.in2 = in2;
    } // everything is done here, has nothing to do with the other 2 constructors
}

meaning depeiding on how you do the overload ... it always calls the super(), as well as whatever else was defined in the other constructor, also note that 1 instance always get intantiated using only 1 constructor, but as shows may still use the other constructors to provide multiple starting points for classes, it can for instance be used to make classes easier to create, or force some permanent values relevant to the class when it is intantiated.

It's also possible to alter what "super()" call is used see JavaDoc Simply call the super with the arguments of the constructor you wish to use