What is the process of defining more than one method in a class differentiated by parameters Mcq?

• Becoming familiar with the term overloading
• Creating multiple constructors for a class.
• Creating multiple methods with the same name in a class.

Let's once more return to our Person class. It currently looks like this:

public class Person { private String name; private int age; private int height; private int weight; public Person(String name) { this.name = name; this.age = 0; this.weight = 0; this.height = 0; } public void printPerson() { System.out.println(this.name + " is " + this.age + " years old"); } public void growOlder() { this.age++; } public boolean isAdult() { if (this.age < 18) { return false; } return true; } public double bodyMassIndex() { double heightInMeters = this.height / 100.0; return this.weight / (heightInMeters * heightInMeters); } public String toString() { return this.name + " is " + this.age + " years old, their BMI is " + this.bodyMassIndex(); } public void setHeight(int height) { this.height = height; } public int getHeight() { return this.height; } public int getWeight() { return this.weight; } public void setWeight(int weight) { this.weight = weight; } public String getName() { return this.name; } }

All person objects are 0 years old when created. This is because the constructor sets the value of the instance variable age to 0:

public Person(String name) { this.name = name; this.age = 0; this.weight = 0; this.height = 0; }

We would also like to be able to create persons so that the constructor is provided both the age as well as the name as parameters. This is possible since a class may have multiple constructors.

Let's make an alternative constructor. The old constructor can remain in place.

public Person(String name) { this.name = name; this.age = 0; this.weight = 0; this.height = 0; } public Person(String name, int age) { this.name = name; this.age = age; this.weight = 0; this.height = 0; }

We now have two alternative ways to create objects:

public static void main(String[] args) { Person paul = new Person("Paul", 24); Person ada = new Person("Ada"); System.out.println(paul); System.out.println(ada); }

Paul is 24 years old. Ada is 0 years old.

The technique of having two (or more) constructors in a class is known as constructor overloading. A class can have multiple constructors that differ in the number and/or type of their parameters. It's not, however, possible to have two constructors with the exact same parameters.

We cannot, for example, add a public Person(String name, int weight) constructor since it would be impossible for Java to differentiate between this and the one that has two parameters where int parameter is used for age.

Hold on a moment. We'd previously concluded that "copy-paste" code is not a good idea. When you look at the overloaded constructors above, however, they have a lot in common. We're not happy with this.

The first constructor - the one that receives a name as a parameter - is in fact a special case of the second constructor - the one that's given both name and age. What if the first constructor could call the second constructor?

This is possible. A constructor can be called from another constructor using the this keyword, which refers to this object in question!

Let's modify the first constructor so that it does not do anything by itself, but instead calls the second constructor and asks it to set the age to 0.

public Person(String name) { this(name, 0); //here the code of the second constructor is run, and the age is set to 0 } public Person(String name, int age) { this.name = name; this.age = age; this.weight = 0; this.height = 0; }

The constructor call this(name, 0); might seem a bit weird. A way to think about it is to imagine that the call is automatically replaced with "copy-paste" of the second constructor in such a way that the age parameter is set to 0. NB! If a constructor calls another constructor, the constructor call must be the first command in the constructor.

New objects can be created just as before:

public static void main(String[] args) { Person paul = new Person("Paul", 24); Person eve = new Person("Eve"); System.out.println(paul); System.out.println(eve); }

Paul is 24 years old. Eve is 0 years old.

Methods can be overloaded in the same way as constructors, i.e., multiple versions of a given method can be created. Once again, the parameters of the different versions must be different. Let's make another version of the growOlder method that ages the person by the amount of years given to it as a parameter.

public void growOlder() { this.age = this.age + 1; } public void growOlder(int years) { this.age = this.age + years; }

In the example below, "Paul" is born 24 years old, ages by a year and then by 10 years:

public static void main(String[] args) { Person paul = new Person("Paul", 24); System.out.println(paul); paul.growOlder(); System.out.println(paul); paul.growOlder(10); System.out.println(paul); }

Prints:

Paul is 24 years old. Paul is 25 years old. Paul is 35 years old.

A Person now has two methods, both called growOlder. The one that gets executed depends on the number of parameters provided.

We may also modify the program so that the parameterless method is implemented using the method growOlder(int years):

public void growOlder() { this.growOlder(1); } public void growOlder(int years) { this.age = this.age + years; }

You have reached the end of this section! Continue to the next section:

Remember to check your points from the ball on the bottom-right corner of the material!