Métodos: Dando Nome e Reúso às Ações

Até agora, todo o nosso código viveu num único fluxo contínuo, escrito de cima para baixo. Para programas pequenos, isso funciona. Mas imagine um programa de mil linhas, todas amontoadas num só bloco: seria impossível de entender, de modificar, de corrigir. E se você precisasse executar a mesma sequência de instruções em três lugares diferentes do programa, teria de copiá-la três vezes — e, se descobrisse um erro nela, teria de corrigi-lo em três lugares. Há uma ferramenta que resolve esses dois problemas de uma vez, e é uma das ideias mais importantes de toda a programação: o método. Um método é um bloco de instruções ao qual damos um nome, para poder acioná-lo quando quisermos, quantas vezes quisermos. Nesta aula, você aprende a criar e usar seus próprios métodos — o primeiro passo rumo a programas organizados e sem repetição.

A ideia: um nome para uma sequência de ações

Você já usou métodos desde a primeira aula, sem os chamar assim. Console.WriteLine é um método — um bloco de instruções, escrito por outra pessoa, que exibe texto na tela, e que você aciona pelo nome. int.Parse é um método que converte texto em número. A novidade desta aula é que você pode criar os seus próprios métodos: dar um nome a uma sequência de instruções sua e acioná-la depois pelo nome, em vez de reescrevê-la.

A analogia natural é a de um verbo ou uma habilidade. Quando ensinamos alguém a "fazer café", encapsulamos uma sequência longa de passos (pegar o filtro, colocar o pó, ferver a água...) sob um único nome. Depois, basta dizer "faça café" para que toda aquela sequência seja executada, sem repetir os passos. Um método é isso: você define, uma vez, os passos de uma tarefa sob um nome; depois, aciona a tarefa inteira apenas mencionando o nome. Esse acionar um método pelo nome chama-se, em programação, chamar (ou invocar) o método.

Criando o primeiro método

Vamos criar um método simples que exibe uma mensagem de boas-vindas. Primeiro, veja o código completo, e depois o dissecaremos:

// A CHAMADA do método: aciona-o pelo nome.
ExibirBoasVindas();
ExibirBoasVindas();   // podemos chamá-lo quantas vezes quisermos

// A DEFINIÇÃO do método: descreve o que ele faz.
void ExibirBoasVindas()
{
    Console.WriteLine("=================================");
    Console.WriteLine("   Bem-vindo ao nosso programa!  ");
    Console.WriteLine("=================================");
}

Há duas coisas distintas aqui, e é vital não confundi-las. A definição do método (a parte de baixo) descreve o que ele faz, mas não o executa por si só — é como escrever a receita do café: escrevê-la não faz café. A chamada do método (as duas linhas de cima, ExibirBoasVindas();) é o que efetivamente executa o bloco — é como dizer "faça café". Repare que chamamos o método duas vezes, e o resultado é a mensagem de boas-vindas exibida duas vezes: eis o reúso em ação. Escrevemos os passos uma única vez (na definição) e os executamos quantas vezes quisermos (nas chamadas).

Agora, dissecando a definição. A palavra void (em inglês, "vazio") indica que este método não devolve nenhum valor — ele apenas faz algo (exibe texto), sem produzir um resultado que possamos guardar. Veremos, na próxima aula, métodos que devolvem valores; por ora, void significa "este método executa ações, mas não retorna nada". Em seguida vem o nome do método, ExibirBoasVindas, seguido de parênteses () — que, neste caso, estão vazios, indicando que o método não precisa de nenhuma informação para funcionar (na próxima aula, colocaremos coisas entre eles). Por fim, o bloco entre chaves contém as instruções que o método executa quando chamado. A chamada, por sua vez, repete o nome seguido dos parênteses e do ponto e vírgula: ExibirBoasVindas();.

Por que métodos: os dois grandes benefícios

Dois benefícios justificam a existência dos métodos, e vale entendê-los com clareza, pois eles orientam quando você deve criar um método.

O primeiro é evitar repetição. Se uma mesma sequência de instruções aparece em vários lugares do seu programa, transformá-la num método permite escrevê-la uma vez e chamá-la onde for preciso. O ganho não é só de digitação: se você precisar mudar aquela lógica, muda num único lugar — a definição do método — e a mudança se reflete em todas as chamadas. Sem métodos, você caçaria e alteraria cada cópia, com o risco de esquecer alguma. Há um princípio célebre na programação que resume isso: "não se repita" (em inglês, Don't Repeat Yourself, ou DRY). Código repetido é código difícil de manter; os métodos são a principal arma contra a repetição.

O segundo benefício é organização e clareza. Mesmo que um trecho de código apareça uma única vez, dar-lhe um nome de método pode torná-lo muito mais legível. Compare um programa que é um bloco gigante de cem instruções com um que é uma sequência de chamadas com nomes claros: LerDadosDoUsuario(); ValidarDados(); CalcularResultado(); ExibirRelatorio();. O segundo se lê quase como uma descrição em português do que o programa faz, e cada método pode ser entendido (e corrigido) isoladamente. Dividir um problema grande em métodos menores, cada um com uma responsabilidade clara, é uma das habilidades centrais do bom programador — a arte de decompor que mencionamos lá na Aula #01, agora ganhando uma ferramenta concreta.

Um exemplo com organização

Vejamos os métodos organizando um pequeno programa. Em vez de um bloco único, dividimos a tarefa em partes nomeadas:

// O programa principal fica limpo, lendo-se como um resumo do que acontece:
ExibirCabecalho();
ExibirMenu();
ExibirRodape();

// As definições detalham cada parte:
void ExibirCabecalho()
{
    Console.WriteLine("### SISTEMA DE BIBLIOTECA ###");
}

void ExibirMenu()
{
    Console.WriteLine("1 - Emprestar livro");
    Console.WriteLine("2 - Devolver livro");
    Console.WriteLine("3 - Sair");
}

void ExibirRodape()
{
    Console.WriteLine("-----------------------------");
    Console.WriteLine("Escolha uma opção acima.");
}

Repare como a parte principal do programa — as três chamadas no topo — se tornou um resumo legível do que o programa faz: exibe cabeçalho, menu e rodapé. Os detalhes de cada parte estão guardados nas definições correspondentes, fora do caminho, prontos para serem consultados se necessário. Essa separação entre o "o quê" (a sequência de chamadas) e o "como" (as definições) é a essência da organização por métodos, e torna programas grandes administráveis.

Uma convenção de nomes

Note que nomeei os métodos começando com letra maiúscula: ExibirBoasVindas, CalcularResultado. Essa é a convenção do C# para nomes de métodos — diferente da convenção para variáveis, que começam com minúscula (precoTotal, Aula #04). Assim, ao ler um nome, você já distingue pela primeira letra se é uma variável (minúscula) ou um método (maiúscula). E, como nas variáveis, prefira nomes descritivos que revelem o que o método faz, tipicamente começando com um verbo (Exibir, Calcular, Ler, Validar), já que um método representa uma ação. Um bom nome de método permite entender o que ele faz sem precisar ler seu interior — uma cortesia com quem lê o código.

O código ganhou a primeira forma real de organização. Um método dá nome a uma sequência de ações e permite invocá-la quantas vezes forem necessárias, o que resolve de uma vez dois problemas distintos: a repetição, porque a lógica passa a existir num lugar só, e a legibilidade, porque um nome bem escolhido comunica a intenção sem obrigar a ler a implementação.

O benefício da manutenção é o que mais pesa com o tempo. Quando a regra muda, ela muda num único ponto, e não em oito lugares espalhados onde é fácil esquecer um. Essa é a primeira aparição de um princípio que atravessa todo o resto: cada conhecimento deve ter um lugar só.

Fontes e leituras recomendadas

• Métodos em C# — a referência oficial sobre definição e chamada de métodos; a base desta aula.
• Funções locais — sobre os métodos definidos diretamente no programa, como fazemos aqui.
• Convenções de nomenclatura — as convenções para nomear métodos, variáveis e demais elementos.
• O princípio DRY (não se repita) — a explicação do princípio de evitar repetição que motiva os métodos.
• Estrutura de um programa C# — como os métodos se encaixam na organização geral de um programa.

Exercícios

Exercício 1

Crie um método void ExibirLinha() que exiba uma linha de traços (por exemplo, --------------------), e chame-o três vezes em pontos diferentes de um programa que também exibe outras mensagens entre as linhas. Explique a diferença entre definir e chamar o método.

ExibirLinha();
Console.WriteLine("Relatório de vendas");
ExibirLinha();
Console.WriteLine("Total: R$ 1.000");
ExibirLinha();

void ExibirLinha()
{
    Console.WriteLine("--------------------");
}

Exercício 2

Escreva um programa que tenha três métodos: ExibirTitulo, ExibirCorpo e ExibirDespedida, cada um exibindo mensagens apropriadas, e chame-os na ordem certa na parte principal. Comente como a parte principal ficou mais legível por causa dos nomes dos métodos.

ExibirTitulo();
ExibirCorpo();
ExibirDespedida();

void ExibirTitulo() => Console.WriteLine("=== Boletim ===");
void ExibirCorpo() => Console.WriteLine("Suas notas estão disponíveis.");
void ExibirDespedida() => Console.WriteLine("Até a próxima!");

Exercício 3

Explique, com suas palavras, o que a palavra void significa na definição de um método. O que ela nos diz sobre o que o método faz (ou não faz)?

Exercício 4

Você tem um programa em que a sequência de instruções que exibe um cabeçalho decorado aparece em quatro lugares diferentes. Explique, com base nos benefícios da aula, por que transformá-la num método é vantajoso — em especial, o que acontece se você depois precisar mudar o visual do cabeçalho.

Exercício 5

Sem código: explique a diferença entre a convenção de nomes para variáveis e para métodos em C#, e por que essa distinção é útil para quem lê o código. Dê um exemplo de nome bem escolhido para cada um.