Resumo rápido
- Método é um bloco de código com nome que você chama quando precisar.
void significa que o método só faz algo e não devolve valor.- Parâmetros são os valores que o método recebe entre parênteses.
return devolve um resultado para quem chamou.- Um bom método faz uma coisa só e tem nome de ação:
Curar, CalcularDano.
Imagine o seu jogo de sobrevivência com o código de cura escrito em dez lugares diferentes: na erva, no kit médico, no descanso, no checkpoint... Se a regra da cura mudar, você vai ter que achar e corrigir os dez. Uma hora esquece um.
Os métodos (também chamados de funções) resolvem isso: você escreve a regra uma vez, dá um nome a ela e chama esse nome onde precisar.
Anatomia de um método
Todo método tem as mesmas partes:
C#
static int Curar(int vida, int quantidade)
{
return vida + quantidade;
}
| Parte | No exemplo | O que significa |
|---|
| modificador | static | pode ser chamado sem criar um objeto (por enquanto, use sempre) |
| tipo de retorno | int | o tipo do valor que o método devolve; void se não devolve nada |
| nome | Curar | um verbo em PascalCase, dizendo o que o método faz |
| parâmetros | (int vida, int quantidade) | valores que o método recebe |
| corpo | { ... } | o código que roda quando o método é chamado |
Nos exemplos deste post o programa usa top-level statements (o código solto no começo do arquivo, sem class Program), que é o padrão dos projetos novos de console. Os métodos ficam no fim do arquivo.
Método void: só faz alguma coisa
O método mais simples não recebe nada e não devolve nada. Ele só executa um conjunto de passos:
C#
MostrarAlerta();
Console.WriteLine("Você se esconde atrás do balcão.");
MostrarAlerta();
static void MostrarAlerta()
{
Console.WriteLine("!!! Zumbi por perto !!!");
}
Saída esperada
!!! Zumbi por perto !!!
Você se esconde atrás do balcão.
!!! Zumbi por perto !!!
Chamar o método é escrever o nome dele com parênteses: MostrarAlerta();. Cada chamada roda o corpo inteiro de novo.
Parâmetros: passando informações
Um alerta fixo é limitado. Com parâmetros, o método recebe valores e se adapta:
C#
MostrarStatus("Leon", 100, 12);
MostrarStatus("Jill", 35, 3);
static void MostrarStatus(string nome, int vida, int balas)
{
string estado = vida < 50 ? "FERIDO" : "ok";
Console.WriteLine($"{nome}: vida {vida} ({estado}), balas {balas}");
}
Saída esperada
Leon: vida 100 (ok), balas 12
Jill: vida 35 (FERIDO), balas 3
Os valores da chamada entram na mesma ordem dos parâmetros: o primeiro vai para nome, o segundo para vida, o terceiro para balas. O ? : é um if de uma linha: se vida < 50, usa "FERIDO"; senão, "ok".
return: devolvendo um resultado
Muitas vezes você quer que o método calcule algo e entregue o resultado. Para isso, troque o void pelo tipo do resultado e use return:
C#
int vida = 40;
vida = Curar(vida, 25);
Console.WriteLine($"Depois da erva: {vida}");
vida = Curar(vida, 50);
Console.WriteLine($"Depois do kit médico: {vida}");
static int Curar(int vidaAtual, int quantidade)
{
int nova = vidaAtual + quantidade;
if (nova > 100)
return 100; // a vida nunca passa do máximo
return nova;
}
Saída esperada
Depois da erva: 65
Depois do kit médico: 100
O return encerra o método na hora. Por isso, quando a vida passaria de 100, ele devolve 100 e a última linha nem chega a rodar. A regra de "não passar do máximo" agora mora num lugar só.
Métodos que devolvem bool
Métodos que respondem "sim ou não" deixam os if muito mais fáceis de ler. Costumam começar com Pode, Tem ou Esta:
C#
int balas = 0;
bool temFaca = true;
if (PodeAtacar(balas, temFaca))
Console.WriteLine("Você ataca!");
else
Console.WriteLine("Fuja!");
static bool PodeAtacar(int balas, bool temFaca)
{
return balas > 0 || temFaca;
}
Saída esperada
Você ataca!
Compare if (PodeAtacar(balas, temFaca)) com if (balas > 0 || temFaca): o resultado é o mesmo, mas o primeiro explica a intenção.
Parâmetros com valor padrão
Se um parâmetro quase sempre recebe o mesmo valor, dê a ele um valor padrão. Quem chama pode omitir:
C#
Console.WriteLine(CalcularDano(10));
Console.WriteLine(CalcularDano(10, 3));
static int CalcularDano(int danoBase, int multiplicador = 1)
{
return danoBase * multiplicador;
}
Saída esperada
10
30
Os parâmetros com valor padrão sempre ficam no fim da lista.
Quando criar um método
| Situação | Crie um método? |
|---|
| O mesmo trecho aparece em dois ou mais lugares | Sim |
| Um bloco grande faz uma tarefa que dá para nomear | Sim, mesmo que só apareça uma vez |
| Uma condição longa num if | Sim, um método que devolve bool |
| Uma linha simples usada uma vez | Não precisa |
Erros comuns
1. Esquecer o return. Se o método promete devolver int, todo caminho precisa terminar num return, senão o código não compila.
C#
static int Curar(int vida, int quantidade)
{
int nova = vida + quantidade;
} // erro: nem todos os caminhos retornam um valor
2. Chamar o método e ignorar o resultado. Curar(vida, 25); calcula a vida nova e joga fora. O certo é vida = Curar(vida, 25);.
3. Trocar a ordem dos argumentos. MostrarStatus(100, "Leon", 12) não compila: o primeiro parâmetro é string.
4. Método que faz tudo. Um método Jogar() com 200 linhas é difícil de entender. Divida em métodos menores com nomes claros.
DESAFIO
Tente resolver antes de abrir a resposta. Sobreviveu? Vá para o próximo.
Escreva um método void chamado Recarregar que mostra "Recarregando..." na tela.
Ver resposta
static void Recarregar() { Console.WriteLine("Recarregando..."); } e chame com Recarregar();.
Escreva um método que recebe as balas soltas e o tamanho do pente e devolve quantos pentes cheios dá para montar.
Ver resposta
static int PentesCheios(int balas, int tamanho) { return balas / tamanho; }. Com 23 balas e pente de 6, devolve 3.
O que aparece na tela? Console.WriteLine(Dobro(Dobro(3))); com static int Dobro(int x) { return x * 2; }
Ver resposta
12. O Dobro(3) de dentro dá 6, e o Dobro(6) de fora dá 12.
Por que int vida = 40; Curar(vida, 25); Console.WriteLine(vida); mostra 40?
Ver resposta
Porque o resultado do Curar não foi guardado. O método recebe uma cópia do valor; para mudar vida, faça vida = Curar(vida, 25);.
Conclusão
Com métodos, o seu código deixa de ser uma lista enorme de comandos e vira um conjunto de ações com nome: Curar, Atacar, MostrarStatus. Fica mais curto, mais fácil de ler e uma regra muda num lugar só.
E se você quiser o mesmo nome para versões diferentes de uma ação, como curar com uma erva ou com um kit médico? Isso é sobrecarga de métodos.
📖 Continue a série: Sobrecarga de métodos em C#.
Comentários
Postar um comentário