Understanding Java constructor with no parameter but with class variables

Question

From the java tutorial I see that a class can have two different constructors with the distinction being the number of arguments provided in each constructor, they also give an example of the no constructor parameter. Based on that information and their example. I have written the class to get a better understanding. I also notice that the fields inside the no param constructor can be changed using getter and setter methods, so I do not see differences with a constructor that has parameters. I have read some question here but they don't address this.

My question: Are there specific cases where such constructor SHOULD be used, if yes what is the reasoning behind it and are there benefits?

public class Course {

    int numberOfStudents;
    String courseName;
    String courseLecturer;

    public Course() {
        this.courseName = "Human Science";
        this.courseLecturer = "Jane Doe";
        this.numberOfStudents = 22;
    }

    public Course(String courseName, String courseLecturer, int numberOfStudents) {

        this.courseName = courseName;
        this.courseLecturer = courseLecturer;
        this.numberOfStudents = numberOfStudents;

    }

    public String getCourseName() {

        return this.courseName;
    } 

    public void setCourseName(String courseName) {

        courseName = this.courseName;
    } 

    public static void main(String[] args) {

        Course courseType2 = new Course("CIV4046F", "Obi", 45);
        System.out.println(courseType2.getCourseName());

    }

}

In the def ctor, this.courseName = courseName; is the same as this.courseName = this.courseName;. — 001
– 001, Commented May 15, 2018 at 13:59
In your case the constructor without arguments is indeed utterly useless. — Ben
– Ben, Commented May 15, 2018 at 14:00
In the Constructor with no arguments this.courseName = courseName; and the other two lines are completly useless, as both this.courseName as well as courseName refer to the same variable. — user6073886
– user6073886, Commented May 15, 2018 at 14:00
Having a constructor without arguments however is not useless in general. It's just that the constructor in your case assigns values to themselves. — Ben
– Ben, Commented May 15, 2018 at 14:01
Take notice, that every constructor always has an implicit super() in it, unless an explicit constructor call is written. — Usagi Miyamoto
– Usagi Miyamoto, Commented May 15, 2018 at 14:02

Andrey Tyukin · Accepted Answer · 2018-05-15 14:14:03Z

2

No, defining default constructors with "realistically looking" too-specialized magic values is not a good idea, it will only cause trouble later on during debugging ("What's wrong with out database, where did this Jane Doe come from?").

Overriding default constructor might make more sense when there are some "canonical default values". For example, if you were modeling fractions, then setting the numerator to 0 and denominator to 1 would give a nice default representation of a zero as a fraction.

edited May 15, 2018 at 14:14

answered May 15, 2018 at 14:08

Andrey Tyukin

45.1k4 gold badges65 silver badges103 bronze badges

Sign up to request clarification or add additional context in comments.

Comments

zouhair · Accepted Answer · 2018-05-15 14:01:54Z

2

the default parameter constructor is used when the user doesn't affect any value at the instantiation so there is default values that can be used instead of emptiness , and if there is parameters the class use the parameters affected by the user.

answered May 15, 2018 at 14:01

zouhair

711 silver badge8 bronze badges

Comments

SrThompson · Accepted Answer · 2018-05-15 14:06:12Z

There is definitely a use case for a default constructor (the one with no arguments) when you want to provide default values for non-final attributes. However, your example is not the recommended approach to provide such defaults. Your attributes should be initialized in the constructor, otherwise you have go around the class to know where the values come from. This would be better

public class Course {
    //You should also keep these private to avoid them being set outside of the class
    int numberOfStudents;
    String courseName;
    String courseLecturer;

    public Course() {
        this.courseName = "Human Science";
        this.courseLecturer = "Jane Doe";
        this.numberOfStudents = 22;
    }
}

nits.kk · Accepted Answer · 2018-05-15 14:17:41Z

Constructor execution results in creation of an object. Once an object is created the user code is not forced to set any parameter before using the object even though there may be setter methods available.

Parametrized constructor and setter methods. Suppose there is a class Duck with a parameter height of type int. You may have a setter method to set the height. Now if an object of Duck is created user code may use this invalid object of Duck (of 0 height). Even though setter method is present but still user code is not enforced to set it before using the created object. To enforce creation of object with necessary life giving parameters Parameterized constructors are needed. The setter methods enables you to modify the states during run time of the application. Based on the modified states the behavior of object can also be modified so they have a different use case but parameterized constructor solves different purpose as I mentioned above.

Default constructor on the other hand provide the user to create the object with states set to default values (these defaults may be defined inside the class while fields declaration itself or in super class or in other constructors or methods invoked by no parameter constructor).

pecks · Accepted Answer · 2018-05-15 14:05:23Z

you're getting confused because your parameters have the same name as your fields. your no-arg constructor is setting the fields to the values that they have already have been given, which isn't very useful - there's no point in doing this. your constructor with three args sets the fields to the values that you are passing in. so if you want to set the fields to values other than your defaults, you need to use the constructor with three args. otherwise a no-arg constructor will do (although it doesn't need to do anything). note also in Java, if you don't provide a constructor, you get a no-arg constructor for free. but as soon as you write a constructor with arguments, you will have to write a no-arg constructor (if you want one).

Abhishek Singh · Accepted Answer · 2018-05-15 14:07:57Z

0

Your default constructor have no effect on class variables. Instead of initializing class variable where it is declared you should initialize in the default constructor.

answered May 15, 2018 at 14:07

Abhishek Singh

2461 silver badge8 bronze badges

Comments

Kushagra Misra · Accepted Answer · 2018-05-15 14:40:28Z

0

One of the many reasons to override default constructor in java is you want to initialize some class level parameters which you are going to processes in different method and those parameter are must to initialize that class.. There are many example in java for these kind of non default constructors for example

BufferedReader br=new BufferedReader(fr)

Where fr is file reader object. If file stream is not passed to buffer reader you cannot use buffer reader class.

answered May 15, 2018 at 14:40

Kushagra Misra

4812 gold badges7 silver badges15 bronze badges

Collectives™ on Stack Overflow

Understanding Java constructor with no parameter but with class variables

7 Answers 7

Comments

Comments

Comments

Comments

Comments

Comments

Comments

Your Answer

Hot Network Questions

Collectives™ on Stack Overflow

7 Answers 7

Comments

Comments

Comments

Comments

Comments

Comments

Comments

Your Answer

Sign up or log in

Post as a guest

Related