Method As Well As Constructor Overloading Best Practices Inward Java

You postulate to live on careful piece overloading a method inwards Java, particularly later the introduction of autoboxing inwards Java 5. Poorly overloaded method non solely adds confusion amidst developers who utilisation that only besides they are error prone as well as leaves your programme on compiler's mercy to select proper method. One of the best examples of a poorly overloaded method is the remove method of ArrayList. There are 2 versions of remove, first, 1 which takes an Object as declaration i.e. remove(Object element) as well as the 2nd one, which takes an index as declaration i.e. remove(int index). It worked fine until Java 1.4 where in that place is clearly a distinction betwixt primitive types as well as objects type only inwards Java 1.5, where you lot tin overstep an int primitive to a method which accepts an Integer object, creates around nasty problem.

Now suppose you lot receive got an ArrayList of Integer alongside values 1, 2 as well as 3, as well as you lot telephone yell upwardly remove(1) as well as therefore which method volition live on called? JVM tin translate 1 as index besides or 1 as Integer object also.

It's best to avoid issues related to method overloading by next around Java best practices. For those who doesn’t know what is method overloading inwards Java? method overloading agency declaring to a greater extent than than 1 method alongside the same nurture only dissimilar method signatures.

This is by as well as large done to do methods which do same matter only alongside dissimilar types. For example, 1 of the most pop examples of method overloading is System.out.println() method, which is overloaded to receive got dissimilar types of parameters similar String, double, int etc, encounter this Java tutorial on method overloading as well as static vs dynamic binding for to a greater extent than details.

By the way, all of these Java best practices which are explained inwards the context of method overloading are as applicable to constructor overloading inwards Java because inwards damage of overloading method as well as constructors are almost same.

Java Best Practices -  Method Overloading

Here are around of the mutual things which you lot tin scream back piece overloading method or constructor inwards Java. These Java best practices are completely based upon sense as well as you lot may receive got around to a greater extent than to add together to this list. let’s encounter my listing of Java best practices piece overloading method inwards Java.

1) Don't overload method which accepts same number of parameter alongside similar types

Two overloaded methods which accepts a same number of declaration alongside similar types i.e. which follow same type hierarchy is a most mutual fault piece overloading a method  in Java. For example, honor out which version of overloaded method volition live on invoked inwards the next scenario :

import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;

/**
 * Java programme to demonstrate around best practise to next piece overloading

 * method inwards Java.This Java programme shows a instance of confusing method overloading inwards Java

 *
 * @author Javin Paul
 */
public class OverloadingTest {
 
    public static void main(String args[]){
       List abc = new ArrayList();
       List bcd = new LinkedList();
     
       ConfusingOverloading co = new ConfusingOverloading();
       co.hasDuplicates(abc); //should telephone yell upwardly to ArryList overloaded method
       co.hasDuplicates(bcd); //should telephone yell upwardly to LinkedList overloaded method
    }

 
}

class ConfusingOverloading{
 
    public boolean hasDuplicates (List collection){
        System.out.println("overloaded method alongside Type List ");
        return true;
    }
 
    public boolean hasDuplicates (ArrayList collection){
        System.out.println("overloaded method alongside Type ArrayList ");
        return true;
    }
 
 
    public boolean hasDuplicates (LinkedList collection){
        System.out.println("overloaded method alongside Type LinkedList ");
        return true;
    }
 
}

Output
the overloaded method alongside Type List
the overloaded method alongside Type List

To the surprise of around programmers method alongside declaration type List is called both the time, instead of expected method which takes ArrayList as well as LinkedList, because method overloading is resolved at compile fourth dimension using static binding inwards Java. This is  also 1 of the reasons, why it's of import to clearly sympathize difference betwixt method overloading as well as overriding inwards Java. Here expected instance is upshot of mistaking overloading as overriding, which piece of job on the actual object as well as happens at runtime. To know to a greater extent than near static as well as dynamic binding inwards Java , you lot tin besides encounter my ship service departure betwixt static as well as dynamic binding inwards Java.

2) Use radically dissimilar types piece overloading method inwards Java

It's completely legal as well as in that place is no ambiguity when 2 overloaded method accepts radically dissimilar types similar String as well as Integer. Though both overloaded methods volition receive got solely 1 parameter, it’s yet clear which method is called because both types are completely dissimilar to each other. Both programmer as well as compiler both know which method volition live on invoked for a particular call. One of the examples of this sort of overloading is the constructor of java.util.Scanner course of report which accepts File, InputStream or String as parameter, as shown below :

Scanner(File source)

Scanner(InputStream source)

Scanner(String source)

3) Beware of Autoboxing piece overloading method inwards Java

Prior to introduction of Autoboxing as well as unboxing inwards Java 5, method which receive got primitive type as well as object type were radically dissimilar as well as it’s clear which method volition live on invoked. Now alongside autoboxing it's actually confusing. Clasical instance of this sort overloading fault is ArrayList’s  remove() method, which is overloaded to receive got index as good as Object. when you lot shop Integer inwards ArrayList as well as telephone yell upwardly remove() method, It’s difficult to honor out which remove() method volition live on called, as shown inwards below instance :

List<Integer> numbers = new ArrayList<Integer>();
numbers.add(1);
numbers.add(2);
numbers.add(3);
System.out.println("numbers: " + numbers);
numbers.remove(1); //should take away "1" as chemical ingredient or 2^nd chemical ingredient from ArrayList
System.out.println("numbers: " + numbers);

Output:
numbers: [1, 2, 3]
numbers: [1, 3]

Many Java programmer expects that Integer(1) object would  be removed only since remove() is overloaded, compiler direct remove(int) over remove(Object). Rules of which overloaded method gets chosen inwards instance of autoboxing is complex as well as difficult to remember, therefore Its best to avoid 2 overloaded methods where 1 receive got Object as well as other receive got primitive type. If past times whatever adventure you lot must receive got to do this as well as therefore brand certain both of them perform the identical function.

Further Learning
Complete Java Masterclass
Top 10 JDBC Best practices for Java programmer

10 Best practices to follow piece writing code comments

JUnit best practices for amend unit of measurement testing

Why utilisation @Override notation inwards Java – coding best practice

Java best practise piece dealing alongside passwords inwards application