Technique Overloading in Java with Examples


Method Overloading in Java

Technique overloading in java is a characteristic that enables a category to have multiple technique with the identical identify, however with completely different parameters.

Java helps technique overloading by two mechanisms:

  1. By altering the variety of parameters
  2. By altering the info sort of parameters Overloading by altering the variety of parameters A technique could be overloaded by altering the variety of parameters.

What’s Technique overloading in Java?

“Technique overloading is a characteristic of Java through which a category has multiple technique of the identical identify and their parameters are completely different.”

In different phrases, we are able to say that Technique overloading is an idea of Java through which we are able to create a number of strategies of the identical identify in the identical class, and all strategies work in several methods. When multiple technique of the identical identify is created in a Class, this kind of technique is known as the Overloaded Technique.

We will simply perceive about technique of overloading by the beneath instance:

Suppose we have now to write down a way to seek out the sq. of an integer quantity. We will write this technique as follows:

public void intSquare ( int quantity ) 
{
 int sq. = quantity * quantity;
 System.out.printIn("Technique with Integer Argument Known as:"+sq.);
}

Suppose we wish to discover the sq. of 10, then to seek out the sq. of 10, we are able to name this technique as follows:

 intSquare(5);

Now, if we wish to discover the Sq. of a double sort worth, then we have now to create one other Sq. () technique as follows:

public void doubleSquare(double quantity)
{
 double sq. = quantity * quantity; 
 System.out.printIn("Technique with double Argument Known as:"+sq.);
}

Equally, if we wish to discover the sq. of lengthy sort worth, then we have now to create one other technique as follows:

public void longSquare(lengthy quantity)
{ 
lengthy sq. = quantity * quantity;
System.out.printIn("Technique with lengthy Argument Known as:"+sq.);
}

If we glance fastidiously, to seek out the sq. of a quantity solely, in line with the info sort of the quantity, we have now to take three names as follows:

See also  Strategic Administration- Which means & Its Significance

intSquare()

doubleSquare()

longSquare()

Whether it is attainable {that a} programmer has to take just one identify and this system itself decides which technique to make use of for which sort of worth, then it will likely be simpler for the programmer to get the identical. There isn’t any must memorise the names of multiple technique for sort work. In Java, we can provide the above three strategies the identical identify.

If we offer solely the sq. () identify as a substitute of giving completely different names to the above three strategies and write the remainder of the outline as follows, then Java’s Compiler doesn’t generate any error.

public void Sq. ( int quantity ) 
{
 int sq. = quantity * quantity;
 System.out.printIn(“Technique with Integer Argument Known as:“+sq.);
 }
public void Sq.(double quantity)
 {
 double sq. = quantity * quantity; 
System.out.printIn(“Technique with double Argument Known as:“+sq.);
}
public void Sq.(lengthy quantity)
 { 
lengthy sq. = quantity * quantity;
System.out.printIn(“Technique with lengthy Argument Known as:“+sq.);
}

If we outline these three strategies in a category, then these strategies could be referred to as Overloaded Strategies as they’ve the identical identify. Allow us to develop CalculateSquare Class to grasp this, which is as follows:

class CalculateSquare
 { 
public void sq.()
 { 
System.out.println("No Parameter Technique Known as");
 } 
public int sq.( int quantity )
 {
int sq. = quantity * quantity;
System.out.println("Technique with Integer Argument Known as:"+sq.); 
}
public float sq.( float quantity ) 
{
 float sq. = quantity * quantity;
 System.out.println("Technique with float Argument Known as:"+sq.); 
}
public static void principal(String[] args)
  {
    CalculateSquare obj = new CalculateSquare();
    obj.sq.();
    obj.sq.(5);   
    obj.sq.(2.5);   
  }
 }

Notice: Now we have not supplied any argument within the ‘parenthesis’ of the sq.() technique in our program. On this case, the Compiler Class calls the tactic through which no Parameter has been outlined to attain the Argument.

See also  Getting older Mind Initiative awards fund 5 new concepts to review, struggle neurodegeneration | MIT Information

Output:

No Parameter Technique Known as 

Technique with Integer Argument Known as: 25

Technique with float Argument Known as: 6.25

On this method, we are able to outline multiple Strategies of the identical identify in a category, which is known as Technique Overloading, and 

The Java compiler itself performs the suitable Technique Name for an object, primarily based on the Knowledge Sort of the Arguments of the Strategies.

Advantages of utilizing Technique Overloading

  • Technique overloading will increase the readability of this system.
  • This gives flexibility to programmers in order that they will name the identical technique for several types of knowledge.
  • This makes the code look clear.
  • This reduces the execution time as a result of the binding is finished in compilation time itself.
  • Technique overloading minimises the complexity of the code.
  • With this, we are able to use the code once more, which saves reminiscence.

Easy methods to do Technique Overloading?

In java, we do technique overloading in two methods:

  1. By altering the variety of parameters.
  2. By altering knowledge sorts.
  • Change the variety of arguments:

Within the instance beneath, we have now two strategies, the primary technique has two arguments, and the second technique has three arguments.

class Demo
{
  void multiply(int a, int b)
  {
    System.out.printIn("Result's"+(a*b)) ;
  }
  void multiply(int a, int b,int c)
  {
    System.out.printIn("Result's"+(a*b*c));
  }
  public static void principal(String[] args)
  {
    Demo obj = new Demo();
    obj.multiply(8,5);   
    obj.multiply(4,6,2);   
  }
}

Output:- 

Result’s 40 

Result’s 48.

  • By Altering the info sorts: 

Within the instance given beneath, we have now two strategies, and their knowledge sorts are completely different.

class Sum
{  
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 principal(String[] args)
{  
System.out.println(Sum.add(17,13));  
System.out.println(Sum.add(10.4,10.6));  
}
}

Notice: On this instance, we’re creating static strategies in order that we don’t must create an occasion for calling strategies.

See also  New {hardware} gives quicker computation for synthetic intelligence, with a lot much less vitality | MIT Information

Output:

30, 21

Some factors to recollect about technique overloading:

  • Technique overloading can’t be executed by altering the return sort of strategies.
  • A very powerful rule of technique overloading is that two overloaded strategies should have completely different parameters.

Technique overloading has nothing to do with return-type.

If there are two strategies of the identical signature inside a category in this system, then Ambiguity Error comes, whether or not their return-type is completely different or not. Because of this technique overloading has no relation with return-type.

class Pattern{
	int disp(int x){
		return x;	
	}
	double disp(int y){
		return y;
	}
	public static void principal(String args[])
{
	Pattern s = new Pattern();
	System.out.printIn("Worth of x : " + s.disp(5));
	System.out.printIn("Worth of y : " + s.disp(6.5));
	}  
}

Output:

Pattern.java:6: error: technique disp(int) is already outlined in school Pattern

On this method, we are able to outline multiple Strategies of the identical identify in a category referred to as Technique Overloading. The Java Compiler itself, primarily based on the Knowledge Sort of the Arguments of the Strategies,  performs the suitable technique name for an object. 

This brings us to the top of the weblog on Technique Overloading in Java. Hope this lets you up-skill your C++ expertise. To study extra about programming and different associated ideas, try the programs on Nice Studying Academy

Additionally, in case you are making ready for Interviews, try these Interview Questions for Java to ace it like a professional.

Additionally Learn: Easy methods to make Resume for Java Developer

Leave a Reply