Apprendre Surcharge de Méthode | Principes Essentiels de la POO

La surcharge de méthodes en C# permet de définir plusieurs méthodes portant le même nom dans une classe, chacune différant par le type ou le nombre de paramètres, ou les deux, offrant ainsi une manière plus claire et flexible de gérer divers scénarios d'entrée.

Par exemple, il est possible d'avoir deux méthodes portant le même nom mais avec un nombre de paramètres différent :

index.cs


              12345678910111213141516171819
            
using System;
class ConsoleApp
{
    static int sum(int a, int b)
    {
        return a + b;
    }

    static int sum(int a, int b, int c)
    {
        return a + b + c;
    }

    static void Main()
    {
        Console.WriteLine(sum(5, 7));
        Console.WriteLine(sum(5, 7, 9));
    }
}

Dans le code ci-dessus, la méthode sum a été surchargée pour proposer deux variantes de paramètres. Une méthode peut également avoir différents types de retour pour ses différentes variantes, cependant il est important d'éviter toute ambiguïté, sinon le compilateur affichera une erreur, car la principale façon pour le compilateur de distinguer deux méthodes portant le même nom est leur liste de paramètres.

Par exemple :

index.cs


              12345678910
            
static int sum(int a, int b)
{
    return a + b;
}

// This is wrong and will show an error
static long sum(int a, int b)
{
    return a + b;
}

Le code ci-dessus est incorrect car les paramètres sont exactement les mêmes que ceux de la méthode d'origine, tandis que le type de retour est différent. Cela n'est pas autorisé, car il devient impossible pour le compilateur (ou même pour les humains) de déterminer laquelle exécuter lors de l'appel de la méthode :

index.cs


              123
            
sum(1, 3); 
// Should it execute `int sum(int a, int b)` or `long sum(int a, int b)` ? 
// It is impossible to reach a good answer for the compiler in this case so it shows an error

C'est pourquoi, lors de la surcharge d'une méthode, une méthode ayant un type de retour différent doit également avoir un ensemble de paramètres différent afin d'être identifiable et d'éviter toute ambiguïté. L'exemple suivant est également incorrect :

index.cs


              12345678910
            
static int sum(int a, int b)
{
    return a + b;
}

// This is wrong and will show an error
static long sum(int first, int second)
{
    return first + second;
}

Cela s'explique par le fait que les noms des paramètres n'ont pas d'importance, mais que leurs types en ont. Les cas de surcharge suivants sont valides :

index.cs


              1234567891011121314151617181920212223242526
            
using System;
class ConsoleApp
{
    static int sum(int a, int b)
    {
        return a + b;
    }

    static long sum(long a, long b)
    {
        return a + b;
    }

    static string sum(int a, long b, float c)
    {
        return Convert.ToString(a + b + c);
    }

    static void Main()
    {
        Console.WriteLine(sum(5, 7)); // Calls 'int sum()'
        Console.WriteLine(sum(500000000000, 700000000000)); // Calls 'long sum()'
        Console.WriteLine(sum(5, 7, 9)); // Calls 'string sum()'
    }
}

1. Comment le compilateur différencie-t-il les méthodes surchargées ?

2. Lequel des exemples suivants est une surcharge de méthode valide ?

Tout était clair ?

Merci pour vos commentaires !

Section 4. Chapitre 7

Demandez à l'IA

Posez n'importe quelle question ou essayez l'une des questions suggérées pour commencer notre discussion

Suggested prompts:

Can you give more examples of valid method overloading in C#?

What are some common mistakes to avoid when overloading methods?

Can you explain how method overloading differs from method overriding?

Awesome!

Completion rate improved to 2.04

Glissez pour afficher le menu

Par exemple, il est possible d'avoir deux méthodes portant le même nom mais avec un nombre de paramètres différent :

index.cs


              12345678910111213141516171819
            
using System;
class ConsoleApp
{
    static int sum(int a, int b)
    {
        return a + b;
    }

    static int sum(int a, int b, int c)
    {
        return a + b + c;
    }

    static void Main()
    {
        Console.WriteLine(sum(5, 7));
        Console.WriteLine(sum(5, 7, 9));
    }
}

Par exemple :

index.cs


              12345678910
            
static int sum(int a, int b)
{
    return a + b;
}

// This is wrong and will show an error
static long sum(int a, int b)
{
    return a + b;
}

index.cs


              123
            
sum(1, 3); 
// Should it execute `int sum(int a, int b)` or `long sum(int a, int b)` ? 
// It is impossible to reach a good answer for the compiler in this case so it shows an error

index.cs


              12345678910
            
static int sum(int a, int b)
{
    return a + b;
}

// This is wrong and will show an error
static long sum(int first, int second)
{
    return first + second;
}

Cela s'explique par le fait que les noms des paramètres n'ont pas d'importance, mais que leurs types en ont. Les cas de surcharge suivants sont valides :

index.cs


              1234567891011121314151617181920212223242526
            
using System;
class ConsoleApp
{
    static int sum(int a, int b)
    {
        return a + b;
    }

    static long sum(long a, long b)
    {
        return a + b;
    }

    static string sum(int a, long b, float c)
    {
        return Convert.ToString(a + b + c);
    }

    static void Main()
    {
        Console.WriteLine(sum(5, 7)); // Calls 'int sum()'
        Console.WriteLine(sum(500000000000, 700000000000)); // Calls 'long sum()'
        Console.WriteLine(sum(5, 7, 9)); // Calls 'string sum()'
    }
}

1. Comment le compilateur différencie-t-il les méthodes surchargées ?

2. Lequel des exemples suivants est une surcharge de méthode valide ?

Tout était clair ?

Merci pour vos commentaires !

Section 4. Chapitre 7