User defined and default constructor?

In java, when you don't explicitly specify a constructor, the compiler will add a "default" constructor: a constructor thar doesn't take parameters. If you specify a constructor, then the compiler doesn't add that constructor.

For instance, this code will compile fine:

class Student {
    String name;
    int age;
    // ...
}

// ...

Student myself = new Student();

But this code wont compile:

class Student {
    String name;
    int age;

    // ...

    public Student(String name) {
        this.name = name;
    }
}

// ...

Student myself = new Student(); // compilation error: use new Student("Jhon Smith");

Because the default constructor is not available any more.

Java provide default constructor when you dont implement yourselve one. But when you create customized constructor you have to implement also default if you would like to use constructor with no arguments. Let's asume we have class A{} for java it will looks like that:

public class A{

   public A(){//auto generated constructor

   }
}

but if you provide an customized constructor auto generated constructor dissapear.

Default constructor is not created when programmer provides any constructor. But here I'm expecting that the author of this task understands "default" constructor as the one without any parameters.

Concluding you would have two constructors:

public class MyClass {

public MyClass () {
}

public MyClass (long studentNumber, String name, String address....) {
}

Above is correct, however, in OO terms, "default constructor" is a constructor that takes in no arguments. The other type of constructor is one where arguments are taken into the constructor to make things custom.

ie:

Student(){     //default constructor
   number = 0;
   name = "bob";
   //etc etc
}

student(int nm, int nm, etc etc){   //parametrized constructor
   number = nm;
   name = nm;
   //etc etc
}

According to Charatan & Kans, Java in Two semesters 3rd Edition, page 196:

Constructor just like any methods can be overloaded, meaning within a single class we can have 2 or more constructors, where one take 1 argument like:("studentName") and within the same class, another constructor might take 2 arguments ("studentName", " studentId"), yet another constructor still within the same class may have 3 arguments ("studentName", "studentId", " studentPhoneNumber").

This is Constructor Overloading. Here's an example:

public class student {

    // attributes
    private String studentName;
    private int studentID;
    private int studentPhoneNumber;
    // constructor with one argument
    public student (String studentNameIn) {
        studentName = studentNameIn;
    }

    // constructor with 2 arguments
    public student (String studentNameIn,  int studentIdIn) {
        studentName = studentNameIn;
        studentID = studentIdIn;
    }

    // constructor with 3 arguments
    public student (String studentNameIn,  int studentIdIn, int studentPhoneNumberIn) {
        studentName = studentNameIn;
        studentID = studentIdIn;
        studentPhoneNumber = studentPhoneNumberIn;
    }

    // default constructor REINSERTED no argument
    public student () {}

    // methods
}

The above is a clear example of constructor overloading. Now during the OBJECT creation, meaning when the student object is being created, it will be up to the programmer to utilise the constructor he/she chooses, with 0 arguments ( default that was REINSERTED) or with 1 argument again he/she may choose the constructor that contains 2 arguments etc. Its a matter of choice and requirement of user.

No superclass or multiple class is needed as constructor can be overloaded as demonstrated above.