Scribd
Upload
58 views5 pages

Java Method Overloading Explained

The document discusses function overloading in Java, explaining that it allows methods to have the same name but different parameters. It provides examples of overloading methods by changing the number of arguments and data types. The document also addresses that overloading by return type alone is not possible in Java due to ambiguity issues.

Uploaded by

Kartavya Jhunjhunwala 9A
Copyright
© All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as PDF, TXT or read online on Scribd
58 views5 pages

Java Method Overloading Explained

The document discusses function overloading in Java, explaining that it allows methods to have the same name but different parameters. It provides examples of overloading methods by changing the number of arguments and data types. The document also addresses that overloading by return type alone is not possible in Java due to ambiguity issues.

Uploaded by

Kartavya Jhunjhunwala 9A
Copyright
© All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as PDF, TXT or read online on Scribd

Purwanchal Vidyamandir

SESSION- 2021-22
STUDY MATERIAL
SUBJECT- COMPUTER
APPLICATIONS

CLASS- IX
NOTES ON FUNCTION OVERLOADING :--
If a class has multiple methods having same name but different in parameters, it is known as Method
Overloading.

If we have to perform only one operation, having same name of the methods increases the readability of
the program.

Suppose you have to perform addition of the given numbers but there can be any number of arguments, if
you write the method such as a(int,int) for two parameters, and b(int,int,int) for three parameters then it
may be difficult for you as well as other programmers to understand the behavior of the method because
its name differs.

So, we perform method overloading to figure out the program quickly.

Advantage of method overloading

Method overloading increases the readability of the program.

Different ways to overload the method

There are two ways to overload the method in java

1. By changing number of arguments

2. By changing the data type

In Java, Method Overloading is not possible by changing the return type of the method only.

1) Method Overloading: changing no. of arguments


In this example, we have created two methods, first add() method performs addition of two numbers and
second add method performs addition of three numbers.

In this example, we are creating static methods so that we don't need to create instance for calling
methods.

class Adder{
static int add(int a,int b){return a+b;}
static int add(int a,int b,int c){return a+b+c;}
}
class TestOverloading1{
public static void main(String[] args){
[Link]([Link](11,11));
[Link]([Link](11,11,11));
}}
Test it Now

Output:

22
33
2) Method Overloading: changing data type of arguments
In this example, we have created two methods that differs in data type. The first add method receives two
integer arguments and second add method receives two double arguments.

class Adder{
static int add(int a, int b){return a+b;}
static double add(double a, double b){return a+b;}
}
class TestOverloading2{
public static void main(String[] args){
[Link]([Link](11,11));
[Link]([Link](12.3,12.6));
}}
Test it Now

Output:

22
24.9

Q) Why Method Overloading is not possible by changing the return type of


method only?
In java, method overloading is not possible by changing the return type of the method only because of
ambiguity. Let's see how ambiguity may occur:

class Adder{
static int add(int a,int b){return a+b;}
static double add(int a,int b){return a+b;}
}
class TestOverloading3{
public static void main(String[] args){
[Link]([Link](11,11));//ambiguity
}}
Test it Now

Output:

Compile Time Error: method add(int,int) is already defined in class Adder

[Link]([Link](11,11)); //Here, how can java determine which sum() method should be
called?

Note: Compile Time Error is better than Run Time Error. So, java compiler renders compiler time error if you
declare the same method having same parameters.
Can we overload java main() method?
Yes, by method overloading. You can have any number of main methods in a class by method
overloading. But JVM calls main() method which receives string array as arguments only. Let's see the
simple example:

class TestOverloading4{
public static void main(String[] args){[Link]("main with String[]");}
public static void main(String args){[Link]("main with String");}
public static void main(){[Link]("main without args");}
}
Test it Now

Output:

main with String[]


PURWANCHAL VIDYAMANDIR
SESSION : 2021-2022
CLASS : IX
SUBJECT : COMPUTER APPLICATIONS
TOPIC : FUNCTION OVERLOADING

Q1 . Design a class to overload a function compared as follows :


(a) void compare(int, int) — to compare two integer values and print the greater of the
two integers.
(b) void compare(char, char) — to compare the numeric value of two characters and
print the character with higher numeric value.
(c) void compare(String, String) — to compare the length of the two strings and print
the longer of the two.

Q2 . Design a class to overload a function area( ) as follows:


(i) double area (double a, double b, double c) with three double arguments, returns the
area of a scalene triangle using the formula:
area = √s(s−a)(s−b)(s−c)
where s=( a+b+c) / 2
(ii) double area (int a, int b, int height) with three integer arguments, returns the area of
a trapezium using the formula:
area = 0.5 x height x (a + b)
(iii) double area (double diagonal 1, double diagonal 2) with two double arguments,
returns the area of a rhombus using the formula :
area = 0.5 x (diagonal 1 x diagonal 2)

Common questions

Powered by AI

Practical examples of method overloading include creating overloaded 'add' methods in a class where one method handles two integer parameters and another handles three integer parameters, each performing addition but on a different number of inputs . Another example is having overloaded 'compare' methods that can compare integers, characters by their numeric values, or strings by length, handling different data types while performing conceptually similar operations .

If multiple overloaded methods differ only in their return type, it results in a compile-time error due to ambiguity. The Java compiler requires method signatures to differ in parameter types or counts, not return types. This is because, at the point of method invocation, the compiler can't use the caller's expected return type to determine which method to run, leading to unclear method selection .

Yes, method overloading can improve program readability by allowing methods to be named consistently according to their operations while still handling different types of inputs or number of arguments. This means that developers can keep method names intuitive and concise without resorting to different naming conventions for different parameter sets or operations, facilitating easier understanding and maintenance of code .

Ambiguity arises in method overloading when overloaded methods have identical names and parameter types or counts, with only different return types. The Java compiler cannot determine which method to execute as it does not consider the return type in such cases, resulting in a compile-time error. For instance, methods 'static int add(int a, int b)' and 'static double add(int a, int b)' will cause ambiguity because the compiler looks for a method match based on name and parameter list alone .

Method overloading is not possible by changing only the return type because it creates ambiguity for the compiler. If methods have the same name and parameters, the compiler cannot decide which method to execute solely based on the return type. This leads to a compile-time error. For example, if two methods are defined as 'static int add(int a, int b)' and 'static double add(int a, int b)', the compiler cannot determine which method to call when 'Adder.add(11,11)' is used .

In Java, method overloading can be achieved through two techniques: changing the number of arguments in the methods or changing the data type of the arguments. It cannot be done by altering the return type of methods .

Overloading the 'area' function in a class handling geometric shape calculations aims to provide a unified interface for computing the area of different geometric shapes, such as scalene triangles, trapeziums, and rhombuses, without requiring different method names for each shape's calculation. This maintains coherence in the method's naming while accommodating different formulas specific to each shape based on their properties .

Java differentiates overloaded methods by their parameter data types during compilation. When a method is called, the compiler checks the arguments passed to select the appropriate method that matches the data types of the given arguments. This allows methods to have the same name but perform operations specific to the passed data types .

Method overloading is when a class has multiple methods with the same name but different parameters. It enhances the readability of the program because it allows the same method name to accommodate different operation needs without having to use different method names, making the program's behavior easier to understand. In Java, method overloading can be achieved by changing the number of arguments or the data type of arguments .

Java allows the main() method to be overloaded, meaning multiple versions of the main() method with different parameter lists can be created within a class. However, the Java Virtual Machine (JVM) will only call the main() method that accepts a string array as an argument when starting the program. Other overloaded versions of main() will not be considered by the JVM for starting the program .

You might also like