What is the process of defining more than one method with the same name in a class differentiated by method signature?

Although a method name can be any legal identifier, code conventions restrict method names. In general, method names should be verbs and should be in mixed case, with the first letter in lowercase and the first letter of each internal word in uppercase. Here are some examples:

toString
compareTo
isDefined
setX
getX

---

Note:  You should refer to Sun Microsystems' code conventions for the Java programming language

and the JavaBeans architecture naming conventions outlined in the JavaBeans specification

.

---

A method with the same signature and return type as a method in a superclass overrides or hides the superclass method. The section Overriding and Hiding Methods

The Java programming language supports name overloading for methods, which means that multiple methods in the same class can share the same name if they have different parameter lists. Suppose that you have a class that can draw various types of data (strings, integers, and so on) and that contains a method for drawing each data type. In other languages, you have to think of a new name for each method, for example, drawString, drawInteger, drawFloat, and so on. In the Java programming language, you can use the same name for all the drawing methods but pass a different type of argument to each method. Thus, the data drawing class might declare three methods named draw, each of which takes a different type of argument.

public class DataArtist {
    ...
    public void draw(String s) {
        ...
    }
    public void draw(int i) {
        ...
    }
    public void draw(float f) {
        ...
    }
}

• 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!

What is the process of defining more than one method in a class with the same name but differentiated by the arguments they take?

What is the process of defining two or more methods within same class that have same name but different parameters declaration * 1 point?

What is the process of defining a method having same name but differ by signature?

What is the process to classify multiple methods with the same name?