Java Language Expliquer ce qu'est la surcharge et la dérogation de la méthode.


Exemple

Le remplacement de méthodes et la surcharge sont deux formes de polymorphisme supportées par Java.

Surcharge de méthode

La surcharge de méthode (également connue sous le nom de polymorphisme statique) est une façon dont vous pouvez avoir deux (ou plusieurs) méthodes (fonctions) avec le même nom dans une seule classe. Oui c'est aussi simple que ça.

public class Shape{
    //It could be a circle or rectangle or square
    private String type;
    
    //To calculate area of rectangle
    public Double area(Long length, Long breadth){
        return (Double) length * breadth;
    }
    
     //To calculate area of a circle
     public Double area(Long radius){
        return (Double) 3.14 * r * r;
    }
}

De cette façon, l'utilisateur peut appeler la même méthode pour la zone en fonction du type de forme dont il dispose.

Mais la vraie question est maintenant, comment java compiler va-t-il distinguer quel corps de méthode doit être exécuté?

Eh bien, Java a clairement indiqué que même si les noms de méthodes ( area() dans notre cas) peuvent être identiques, mais que la méthode des arguments est différente, elle devrait être différente.

Les méthodes surchargées doivent avoir une liste d'arguments différente (quantité et types).

Cela étant dit, nous ne pouvons pas ajouter une autre méthode pour calculer l'aire d'un carré comme ceci: public Double area(Long side) car dans ce cas, elle entrera en conflit avec la méthode de cercle et provoquera une ambiguïté pour le compilateur Java.

Dieu merci, il y a des relaxations en écrivant des méthodes surchargées comme

Peut avoir différents types de retour.

Peut avoir différents modificateurs d'accès.

Peut lancer différentes exceptions.

Pourquoi est-ce ce qu'on appelle le polymorphisme statique?

Eh bien, c'est parce que les méthodes surchargées à invoquer sont décidées au moment de la compilation, en fonction du nombre réel d'arguments et des types de compilation des arguments.

L'une des raisons courantes de l'utilisation de la surcharge de méthodes est la simplicité du code fourni. Par exemple rappelez-vous String.valueOf() qui prend presque n'importe quel type d'argument? Ce qui est écrit derrière la scène est probablement quelque chose comme ceci: -

static String valueOf(boolean b) 
static String valueOf(char c) 
static String valueOf(char[] data) 
static String valueOf(char[] data, int offset, int count) 
static String valueOf(double d) 
static String valueOf(float f) 
static String valueOf(int i) 
static String valueOf(long l) 
static String valueOf(Object obj) 

Dérogation de méthode

Eh bien, la méthode qui remplace (oui vous le devinez bien, c'est aussi le polymorphisme dynamique) est un sujet un peu plus intéressant et complexe.

En cas de substitution de méthode, nous écrasons le corps de la méthode fourni par la classe parente. Je l'ai? Non? Passons en revue un exemple.

public abstract class Shape{
    
    public abstract Double area(){
        return 0.0;
    }
}

Nous avons donc une classe appelée Shape et elle a une méthode appelée zone qui renverra probablement la zone de la forme.

Disons que maintenant nous avons deux classes appelées Circle et Rectangle.

public class Circle extends Shape {
    private Double radius = 5.0;

    // See this annotation @Override, it is telling that this method is from parent
    // class Shape and is overridden here
    @Override
    public Double area(){
        return 3.14 * radius * radius;
    }
}

De même classe de rectangle:

 public class Rectangle extends Shape {
    private Double length = 5.0;
    private Double breadth= 10.0;


    // See this annotation @Override, it is telling that this method is from parent
    // class Shape and is overridden here
    @Override
    public Double area(){
        return length * breadth;
    }
}

Donc, maintenant, les deux classes de vos enfants ont mis à jour le corps de la méthode fourni par la classe parent ( Shape ). Maintenant, la question est comment voir le résultat? Eh bien laisse faire le vieux moyen psvm .

public class AreaFinder{
    
    public static void main(String[] args){

        //This will create an object of circle class
        Shape circle = new Circle();
        //This will create an object of Rectangle class
        Shape rectangle = new Rectangle();
        
        // Drumbeats ......
        //This should print 78.5
        System.out.println("Shape of circle : "+circle.area());

        //This should print 50.0
        System.out.println("Shape of rectangle: "+rectangle.area());            
        
    }
}

Hou la la! n'est-ce pas génial? Deux objets de même type appelant les mêmes méthodes et renvoyant des valeurs différentes. Mon ami, c'est le pouvoir du polymorphisme dynamique.

Voici un tableau pour mieux comparer les différences entre les deux: -

Surcharge de méthode Dérogation de méthode
La surcharge de la méthode est utilisée pour améliorer la lisibilité du programme. La substitution de méthode est utilisée pour fournir l'implémentation spécifique de la méthode déjà fournie par sa super classe.
La surcharge de méthode est effectuée dans la classe. La substitution de méthode se produit dans deux classes ayant une relation IS-A (héritage).
En cas de surcharge de la méthode, le paramètre doit être différent. En cas de substitution de méthode, le paramètre doit être identique.
La surcharge de méthode est l'exemple du polymorphisme de compilation. La substitution de méthode est l'exemple du polymorphisme d'exécution.
En Java, la surcharge de la méthode ne peut pas être effectuée en modifiant uniquement le type de retour de la méthode. Le type de retour peut être identique ou différent dans la surcharge de la méthode. Mais vous devez changer le paramètre. Le type de retour doit être identique ou covariant lors de la substitution de méthode.