Declaração e chamada de métodos, parâmetros

1. Sintaxe de declaração de método

A declaração de um método em Java é como uma receita de um livro de culinária: você indica o que o método retorna (tipo), como ele se chama, quais ingredientes (parâmetros) são necessários e escreve a própria receita (corpo do método).

Forma geral:

tip_vozvrashchaemogo_znacheniya imyaMetoda(parametry)
{
    // escrevemos comandos aqui
}

• tipo de retorno — o que o método retorna (por exemplo, int, void — se não retorna nada, String etc.).
• nomeDoMetodo — um nome escolhido por você (seguindo as regras do Java).
• parâmetros — a lista de variáveis que o método usará (pode ser vazia).
• corpo do método — seus comandos entre chaves { }.

Exemplos de métodos sem parâmetros

void printHello() 
{
    System.out.println("Olá, mundo!");
}

Explicação: void — o método não retorna nada; printHello — o nome; () — sem parâmetros.

Exemplo de método com parâmetros

void printName(String name) 
{
    System.out.println("Olá, " + name + "!");
}

Explicação: void — não retorna valor; printName — nome do método; String name — um parâmetro do tipo String.

Exemplo de método com vários parâmetros

void printSum(int a, int b) 
{
    System.out.println("Soma: " + (a + b));
}

Explicação: os parâmetros são indicados separados por vírgula. Dentro do método, usamos eles como variáveis comuns; o operador + realiza a soma.

Importante!

• Os métodos são declarados dentro de uma classe, mas NÃO dentro de outros métodos.
• Em Java não é permitido declarar métodos dentro de outros métodos — nada de “matrioskas”.

2. Chamada de método

Declarar um método é como pendurar uma plaquinha “Faço café”. Mas, para o café realmente aparecer, é preciso chamar o método — escrever seu nome e passar os valores dos parâmetros.

Como chamar um método

Se o método está na mesma classe e foi declarado como static (como main), você pode chamá-lo apenas pelo nome:

printHello();
printName("Alisa");
printSum(3, 5);

Se o método não for static, é preciso chamá-lo por meio de um objeto (falaremos disso mais adiante, quando estudarmos classes e objetos).

Exemplo: chamada de método a partir de main

public class MethodsDemo
{
    public static void main(String[] args) 
    {
        printHello();
        printName("Bob");
        printSum(10, 20);
    }

    static void printHello() 
    {
        System.out.println("Olá, mundo!");
    }

    static void printName(String name) 
    {
        System.out.println("Olá, " + name + "!");
    }

    static void printSum(int a, int b) 
    {
        System.out.println("Soma: " + (a + b));
    }
}

Observe: os métodos foram declarados com o modificador static para que possam ser chamados de main (que também é static).

3. Parâmetros e argumentos: o que são?

Parâmetros — são variáveis declaradas entre parênteses na declaração do método.
Argumentos — são os valores reais que você passa ao chamar o método.

Analogia: Parâmetros — como uma lista de compras; Argumentos — o que você realmente coloca no carrinho.

Exemplo

      static void greet(String name)  // name — parâmetro
{
    System.out.println("Olá, " + name + "!");
}

public static void main(String[] args) 
{
    greet("Katya"); // "Katya" — argumento
    greet("Vasya"); // "Vasya" — argumento
}

Quando você chama greet("Katya"), dentro do método a variável name passa a ser igual a "Katya".

Vários parâmetros

      static void printInfo(String name, int age)
{
    System.out.println("Nome: " + name + ", idade: " + age);
}

public static void main(String[] args) 
{
    printInfo("Masha", 25);
    printInfo("Petya", 31);
}

Atenção! Os tipos e a ordem dos parâmetros devem coincidir com o que você declarou no método.

4. Prática: escrevendo seus próprios métodos

Método que imprime uma saudação com o nome do usuário

static void sayHelloTo(String name)
{
    System.out.println("Olá, " + name + "!");
}

public static void main(String[] args)
{
    sayHelloTo("Andrey");
    sayHelloTo("El’vira");
}

Método que calcula a soma de dois números

static void printSum(int a, int b)
{
    int sum = a + b;
    System.out.println("Soma: " + sum);
}

public static void main(String[] args) 
{
    printSum(7, 8);
    printSum(15, -5);
}

Método que imprime os elementos de um array

      static void printArray(int[] array)
{
    System.out.print("Array: ");
    for (int i = 0; i < array.length; i++) 
    {
        System.out.print(array[i] + " ");
    }
    System.out.println();
}

public static void main(String[] args) 
{
    int[] nums = {1, 2, 3, 4, 5};
    printArray(nums);
}

Método que imprime n vezes a mesma string

      static void repeatPrint(String text, int n)
{
    for (int i = 0; i < n; i++) 
    {
        System.out.println(text);
    }
}

public static void main(String[] args) 
{
    repeatPrint("Java é incrível!", 3);
}

5. Como os métodos ajudam a construir o aplicativo

Se você decidir escrever um jogo de console simples ou uma calculadora, o código ficará mais claro se cada tarefa for organizada como um método.

Exemplo: mini-calculadora

public class Calculator
{
    public static void main(String[] args) 
    {
        printGreeting();
        printSum(3, 7);
        printDifference(10, 4);
    }

    static void printGreeting() 
    {
        System.out.println("Bem-vindo à calculadora!");
    }

    static void printSum(int a, int b) 
    {
        System.out.println("Soma: " + (a + b));
    }

    static void printDifference(int a, int b) 
    {
        System.out.println("Diferença: " + (a - b));
    }
}

No futuro você poderá adicionar novos métodos (multiplicação, divisão, trabalhar com arrays de números etc.), e o aplicativo vai crescer sem virar um bloco enorme de código.

6. Dicas úteis

Nomes de métodos

• O nome do método geralmente começa com letra minúscula e usa o estilo camelCase: printSum, sayHelloTo, calculateArea.
• O nome deve refletir a ação. Evite doStuff e method1.

Ordem dos parâmetros

• Respeite a ordem e os tipos dos parâmetros ao chamar.
• Se o método for printInfo(String name, int age), não pode chamar printInfo(25, "Masha").

Posso declarar dois métodos com o mesmo nome?

Sim, se eles tiverem listas de parâmetros diferentes (tipos ou quantidades diferentes). Isso é sobrecarga de métodos:

static void printSum(int a, int b) { /* ... */ }
static void printSum(int a, int b, int c) { /* ... */ }

Haverá uma aula separada sobre esse tema — por enquanto, basta saber que o Java não limita você a apenas uma assinatura por nome.

7. Erros comuns ao trabalhar com métodos e parâmetros

Erro nº 1: Quantidade ou tipos de parâmetros não coincidem na chamada.
Se o método foi declarado como printSum(int a, int b), e você o chama como printSum(5), o compilador dirá que tal método não existe. Da mesma forma, printSum("cinco", 7) — erro de tipos.

Erro nº 2: Confundir parâmetros e argumentos.
Na declaração do método vão os parâmetros (por exemplo, int a, int b), e na chamada — os argumentos (printSum(5, 7)). Não é preciso criar em main variáveis com os mesmos nomes — o importante é a coincidência de tipos e ordem.

Erro nº 3: Tentar declarar um método dentro de outro método.
Em Java, os métodos são declarados apenas no nível da classe. Não é permitido declarar dentro de outro método.

Erro nº 4: Não usar static ao chamar a partir de main.
Se você chama um método a partir de main, adicione static à declaração ou crie um objeto e chame o método nele. Detalhes — mais adiante, ao estudar POO.