Fundamentos de Métodos

Métodos são os blocos básicos de construção para organizar código. Esta lição cobre como definir e usar métodos em Java.

O que é um Método

Um método é um bloco de código que realiza uma tarefa específica e pode ser chamado repetidamente.

Benefícios dos Métodos

Benefício	Descrição
Reutilização de código	Escreva uma vez, chame muitas vezes
Lógica clara	Divida problemas complexos em métodos menores
Fácil manutenção	Alterações precisam ser feitas em apenas um lugar

Definição de Método

Sintaxe

JAVA

modificador tipoRetorno nomeMétodo(listaParâmetros) {
    // Corpo do método
    return valorRetorno;
}

Exemplo: Método Simples

JAVA

public class MethodDemo {
    // Definir método
    public static void sayHello() {
        System.out.println("Hello, Java!");
    }
    
    public static void main(String[] args) {
        // Chamar método
        sayHello();
        sayHello();  // Pode ser chamado múltiplas vezes
    }
}

▶ Experimente

Saída:

TEXT

Hello, Java!
Hello, Java!

Parâmetros de Método

Parâmetros permitem que métodos recebam dados externos.

Sem Parâmetros

JAVA

public static void printLine() {
    System.out.println("================");
}

Com Parâmetros

JAVA

public static void greet(String name) {
    System.out.println("Hello, " + name + "!");
}

Múltiplos Parâmetros

JAVA

public static int add(int a, int b) {
    return a + b;
}

Exemplo: Parâmetros de Método

JAVA

public class ParamDemo {
    public static void greet(String name) {
        System.out.println("Hello, " + name + "!");
    }
    
    public static int add(int a, int b) {
        return a + b;
    }
    
    public static void printInfo(String name, int age) {
        System.out.println("Nome: " + name + ", Idade: " + age);
    }
    
    public static void main(String[] args) {
        greet("Alice");           // Hello, Alice!
        greet("Bob");             // Hello, Bob!
        
        int sum = add(3, 5);
        System.out.println("3 + 5 = " + sum);  // 8
        
        printInfo("John", 25);   // Nome: John, Idade: 25
    }
}

▶ Experimente

Valores de Retorno

Métodos podem retornar um resultado para o chamador.

Com Valor de Retorno

JAVA

public static int max(int a, int b) {
    return (a > b) ? a : b;
}

Sem Valor de Retorno (void)

JAVA

public static void printMax(int a, int b) {
    int max = (a > b) ? a : b;
    System.out.println("Máximo: " + max);
}

Exemplo: Valores de Retorno

JAVA

public class ReturnDemo {
    public static int max(int a, int b) {
        return (a > b) ? a : b;
    }
    
    public static double average(int a, int b) {
        return (a + b) / 2.0;
    }
    
    public static boolean isEven(int num) {
        return num % 2 == 0;
    }
    
    public static void main(String[] args) {
        System.out.println("max(3, 5) = " + max(3, 5));       // 5
        System.out.println("avg(3, 5) = " + average(3, 5));   // 4.0
        System.out.println("isEven(4) = " + isEven(4));       // true
        System.out.println("isEven(7) = " + isEven(7));       // false
    }
}

▶ Experimente

⚠️ Nota: Métodos void não podem usar return valor, mas podem usar return; para sair do método antecipadamente.

Sobrecarga de Métodos

Sobrecarga de métodos significa ter múltiplos métodos com o mesmo nome mas diferentes listas de parâmetros na mesma classe.

Regras de Sobrecarga

Regra	Descrição
Mesmo nome de método	Obrigatório
Diferente número de parâmetros	Permitido
Diferente tipo de parâmetro	Permitido
Diferente ordem de parâmetros	Permitido
Diferente tipo de retorno	Não considerado sobrecarga

Exemplo: Sobrecarga de Métodos

JAVA

public class OverloadDemo {
    public static int add(int a, int b) {
        return a + b;
    }
    
    public static int add(int a, int b, int c) {
        return a + b + c;
    }
    
    public static double add(double a, double b) {
        return a + b;
    }
    
    public static String add(String a, String b) {
        return a + b;
    }
    
    public static void main(String[] args) {
        System.out.println(add(1, 2));              // 3
        System.out.println(add(1, 2, 3));           // 6
        System.out.println(add(1.5, 2.5));          // 4.0
        System.out.println(add("Hello", "World"));  // HelloWorld
    }
}

▶ Experimente

Varargs (Argumentos Variáveis)

Varargs permitem que métodos aceitem um número variável de argumentos.

Sintaxe

JAVA

public static int sum(int... numbers) {
    int total = 0;
    for (int num : numbers) {
        total += num;
    }
    return total;
}

Exemplo: Varargs

JAVA

public class VarargsDemo {
    public static int sum(int... numbers) {
        int total = 0;
        for (int num : numbers) {
            total += num;
        }
        return total;
    }
    
    public static void printNames(String... names) {
        for (String name : names) {
            System.out.println(name);
        }
    }
    
    public static void main(String[] args) {
        System.out.println(sum(1, 2));           // 3
        System.out.println(sum(1, 2, 3));        // 6
        System.out.println(sum(1, 2, 3, 4, 5));  // 15
        
        printNames("Alice", "Bob", "Charlie");
    }
}

▶ Experimente

⚠️ Nota: Varargs deve ser o último parâmetro em um método, e um método só pode ter um parâmetro varargs.

Passagem de Parâmetros

Java usa "passagem por valor" para passagem de parâmetros.

Passagem de Tipo Primitivo

JAVA

public static void changeValue(int num) {
    num = 100;  // Apenas modifica variável local
}

public static void main(String[] args) {
    int x = 10;
    changeValue(x);
    System.out.println(x);  // 10, inalterado
}

Passagem de Tipo de Referência

JAVA

public static void changeArray(int[] arr) {
    arr[0] = 100;  // Modifica conteúdo do array
}

public static void main(String[] args) {
    int[] arr = {1, 2, 3};
    changeArray(arr);
    System.out.println(arr[0]);  // 100, modificado
}

💡 Entendimento: Tipos primitivos passam uma cópia do valor. Tipos de referência passam uma cópia do endereço.

Pilha de Chamadas de Método

Quando métodos são chamados, frames de pilha são criados na memória de pilha.

JAVA

public static void main(String[] args) {
    methodA();
}

public static void methodA() {
    methodB();
}

public static void methodB() {
    System.out.println("Hello");
}

Ordem de chamada: main → methodA → methodB → completa → retorna para methodA → retorna para main

❓ Perguntas Frequentes

P: Qual é a diferença entre método e função? R: Em Java, métodos devem pertencer a uma classe. Funções em outras linguagens são métodos estáticos de classes em Java.

P: Quando devo usar métodos estáticos? R: Quando o método não precisa acessar o estado do objeto. Métodos de classes utilitárias são tipicamente estáticos.

P: O return pode ser omitido? R: Métodos void podem omitir return (eles terminam automaticamente). Métodos com valores de retorno devem ter uma instrução return.

📖 Resumo

Métodos são as unidades básicas para organizar código e podem ser chamados repetidamente
Métodos podem ter parâmetros e valores de retorno
Sobrecarga de métodos: mesmo nome de método, diferentes listas de parâmetros
Varargs permitem que métodos aceitem um número variável de argumentos
Java usa passagem por valor

📝 Exercícios

Prática de métodos: Escreva métodos para calcular o máximo, mínimo e média de dois números
Prática de sobrecarga: Escreva múltiplos métodos de impressão que suportem diferentes tipos de parâmetros
Varargs: Escreva um método que calcule a média de qualquer número de valores

Próxima Lição

Na próxima lição, aprenderemos sobre Métodos Avançados — recursão, métodos estáticos e referências de métodos.