Java offre une grande flexibilité aux développeurs. Ils peuvent utiliser les méthodes possédant les mêmes noms mais prenant des paramètres différents. Cette technique est impossible à achever pour les développeurs PHP.
Cette surcharge des méthodes s'applique aussi bien aux constructeurs qu'aux fonctions placées dans le corps d'une classe. Cette permission contribue à garder une sémantique correcte du code. Imaginons une situation où notre application devrait permettre de calculer un prix à partir d'un String ou d'un Integer. Overloading de la fonction getPrice() rendra cette tâche possible. Analysons donc le code ci-dessous :
public class Overloading {
public static void main(String[] args) {
Cart cartInst = new Cart();
System.out.println("Price directly from double method : " + cartInst.getPrice(100.0d));
System.out.println("Price directly from string overloaded method : " + cartInst.getPrice("100.0"));
}
}
class Cart {
private static final double TAX = 19.6d;
public double getPrice(String itemPrice) {
try {
double stringDouble = Double.parseDouble(itemPrice.trim());
System.out.println("String => double = " + stringDouble);
return getPrice(stringDouble);
} catch (NumberFormatException e) {
System.out.println("Exception when trying to convert String to double " + e.getMessage());
}
return -0.1d;
}
public double getPrice(double itemPrice) {
return (itemPrice + ((itemPrice*TAX)/100));
}
}
On remarquera que le résultat sera exactement le même pour les deux méthodes appelées :
Price directly from double method : 119.6 String => double = 100.0 Price directly from string overloaded method : 119.6
Quelles sont les différences entre overloading et overriding en Java ?
La surcharge de la méthode getPrice() a lieu au moment de compilation. Elle est invisiblement décomposée en deux méthodes différentes pour que l'environnement de lancement sache quelle function appeler avec quels paramètres. Le moment où la machine virtuelle Java est capable de déterminer quelle version utiliser, s'appelle l'attachement statique (static binding). La notion inverse est l'attachement dynamique (dynamic binding) et il a lieu quand la JVM ne peut distinguer de quelle méthode il s'agit qu'au moment d'exécution du code.
Regardons la différence entre static binding et dynamic binding sur un exemple qui ne sera pas exécuté. Il servira juste à illustrer cette nuance :
public class StaticDynamicBinding {
public static void main(String[] args) {
Cart cartInst = new Cart();
Cart mobInst = new CartMobile();
// dynamic binding - both objects are Cart instances; JVM will know which showCartName() it must call at
// runtime
cartInst.showCartName();
mobInst.showCartName();
// static binding - compilator knows which getPrice() method it must call
System.out.println("Price directly from double method : " + cartInst.getPrice(100.0d));
System.out.println("Price directly from string overloaded method : " + cartInst.getPrice("100.0"));
}
}
class Cart {
private static final double TAX = 19.6d;
public void showCartName() {
System.out.println("Cart class called");
}
public double getPrice(String itemPrice) {
try {
double stringDouble = Double.parseDouble(itemPrice.trim());
System.out.println("String => double = " + stringDouble);
return getPrice(stringDouble);
} catch (NumberFormatException e) {
System.out.println("Exception when trying to convert String to double " + e.getMessage());
}
return -0.1d;
}
public double getPrice(double itemPrice) {
return (itemPrice + ((itemPrice*TAX)/100));
}
}
class CartMobile extends Cart {
public void showCartName() {
System.out.println("CartMobile class called");
}
}
L'attachement statique est donc la première chose qui différencie la surcharge d'une méthode à un héritage (override).
La deuxième différence entre les deux repose sur le fait qu'on peut "overloader" plusieurs méthodes au sein de la même classe. En ce qui concerne overriding, on ne peut que le faire dans les sous-classes.