Sobrecarga de Métodos

Parte da seção Programação Orientada a Objetos do Journey de C# da Coddy — lição 50 de 70.

Sobrecarga de métodos permite que você defina múltiplos métodos com o mesmo nome, mas listas de parâmetros diferentes. O compilador determina qual versão chamar com base nos argumentos que você fornece.

Cada método sobrecarregado deve ter uma assinatura única - ou um número diferente de parâmetros ou tipos de parâmetros diferentes:

public static void Print(string message)
{
    Console.WriteLine(message);
}

public static void Print(string message, int times)
{
    for (int i = 0; i < times; i++)
        Console.WriteLine(message);
}

public static void Print(int number)
{
    Console.WriteLine(number);
}

// O compilador escolhe a versão correta
Print("Hello");           // Chama Print(string)
Print("Hi", 3);           // Chama Print(string, int)
Print(42);                // Chama Print(int)

A sobrecarga difere dos parâmetros opcionais de uma maneira importante. Com parâmetros opcionais, você tem um único método que lida com múltiplos cenários. Com a sobrecarga, você tem métodos separados que podem conter lógicas completamente diferentes para cada caso.

Observe que o tipo de retorno por si só não torna os métodos únicos - você não pode ter dois métodos que diferem apenas pelo que retornam. A lista de parâmetros deve ser diferente. A sobrecarga de métodos é uma forma de polimorfismo em tempo de compilação, onde a decisão sobre qual método chamar é tomada quando o código é compilado, não quando ele é executado.

Desafio

Fácil

Vamos construir uma classe de calculadora versátil que demonstra o poder da sobrecarga de métodos. Você criará múltiplas versões de métodos de cálculo que lidam com diferentes cenários - desde operações simples com dois números até cálculos mais complexos - todos compartilhando os mesmos nomes de métodos intuitivos.

Você organizará seu código em dois arquivos:

Calculator.cs: Crie uma classe Calculator no namespace MathTools com métodos sobrecarregados que compartilham nomes, mas aceitam parâmetros diferentes:
- Multiply - Crie três versões sobrecarregadas:
  - Uma que recebe dois parâmetros int e retorna o produto deles como um int
  - Uma que recebe três parâmetros int e retorna o produto deles como um int
  - Uma que recebe dois parâmetros double e retorna o produto deles como um double
- Describe - Crie duas versões sobrecarregadas:
  - Uma que recebe um int e retorna "Integer: {value}"
  - Uma que recebe um double e retorna "Double: {value}"
Program.cs: No seu arquivo principal, crie uma instância de Calculator e demonstre como o compilador seleciona automaticamente o método sobrecarregado correto com base nos argumentos que você fornece.

Você receberá quatro entradas:

Primeiro número inteiro (ex: 5)
Segundo número inteiro (ex: 4)
Terceiro número inteiro (ex: 3)
Um número decimal (ex: 2.5)

Usando sua calculadora, realize estas operações e imprima cada resultado em sua própria linha:

Multiplique os dois primeiros inteiros (usa a versão com dois ints)
Multiplique todos os três inteiros (usa a versão com três ints)
Multiplique o primeiro inteiro e o número decimal (usa a versão com dois doubles)
Descreva o primeiro inteiro (usa a versão int)
Descreva o número decimal (usa a versão double)

Por exemplo, se as entradas forem 5, 4, 3 e 2.5, a saída deve ser:

20
60
12.5
Integer: 5
Double: 2.5

Observe como você chama Multiply e Describe com diferentes tipos e quantidades de argumentos, e ainda assim o compilador sabe exatamente qual versão usar a cada vez. Isso é o polimorfismo de tempo de compilação em ação - a decisão acontece quando seu código é compilado, não quando ele é executado!

Folha de consulta

A sobrecarga de métodos permite que você defina múltiplos métodos com o mesmo nome, mas com listas de parâmetros diferentes. O compilador determina qual versão chamar com base nos argumentos fornecidos.

Cada método sobrecarregado deve ter uma assinatura única - seja um número diferente de parâmetros ou tipos de parâmetros diferentes:

public static void Print(string message)
{
    Console.WriteLine(message);
}

public static void Print(string message, int times)
{
    for (int i = 0; i < times; i++)
        Console.WriteLine(message);
}

public static void Print(int number)
{
    Console.WriteLine(number);
}

// O compilador escolhe a versão correta
Print("Hello");           // Chama Print(string)
Print("Hi", 3);           // Chama Print(string, int)
Print(42);                // Chama Print(int)

Pontos-chave sobre a sobrecarga de métodos:

A sobrecarga difere dos parâmetros opcionais - com a sobrecarga, você tem métodos separados que podem conter uma lógica completamente diferente para cada caso
O tipo de retorno sozinho não torna os métodos únicos - a lista de parâmetros deve ser diferente
A sobrecarga de métodos é uma forma de polimorfismo em tempo de compilação, onde a decisão sobre qual método chamar é feita quando o código é compilado, não quando ele é executado

Experimente você mesmo

using System;
using MathTools;

class Program
{
    public static void Main(string[] args)
    {
        // Lê as entradas
        int firstInt = Convert.ToInt32(Console.ReadLine());
        int secondInt = Convert.ToInt32(Console.ReadLine());
        int thirdInt = Convert.ToInt32(Console.ReadLine());
        double decimalNum = Convert.ToDouble(Console.ReadLine());

        // TODO: Criar uma instância de Calculator

        // TODO: Chamar Multiply com dois inteiros e imprimir o resultado

        // TODO: Chamar Multiply com três inteiros e imprimir o resultado

        // TODO: Chamar Multiply com o primeiro inteiro e o número decimal, imprimir o resultado

        // TODO: Chamar Describe com o primeiro inteiro e imprimir o resultado

        // TODO: Chamar Describe com o número decimal e imprimir o resultado
    }
}