Dominando Métodos em Java: Criação, Invocação e Abstração

Um método Java é uma coleção de instruções agrupadas para realizar uma operação. Quando você chama o método System.out.println(), por exemplo, o sistema executa várias instruções para exibir uma mensagem no console.

Neste artigo, você aprenderá a criar seus próprios métodos com ou sem valores de retorno, invocar métodos com ou sem parâmetros e aplicar abstração de métodos no design de programas.

Criando um Método

Considere o seguinte exemplo para explicar a sintaxe de um método:

public static int methodName(int a, int b) {
    // corpo do método
}

Aqui:

public static — modificador
int — tipo de retorno
methodName — nome do método
a, b — parâmetros formais
int a, int b — lista de parâmetros

A definição de um método consiste em um cabeçalho e um corpo:

modifier returnType nameOfMethod (Parameter List) {
    // corpo do método
}

A sintaxe acima inclui:

modifier — Define o tipo de acesso do método; é opcional.
returnType — O método pode retornar um valor.
nameOfMethod — Nome do método. A assinatura do método consiste no nome e na lista de parâmetros.
Parameter List — Lista de parâmetros: tipo, ordem e número. São opcionais; o método pode ter zero parâmetros.
method body — Define o que o método faz com as instruções.

Exemplo: Método minFunction

O código a seguir define um método chamado minFunction() que recebe dois parâmetros e retorna o menor entre eles:

/** Retorna o mínimo entre dois números */
public static int minFunction(int n1, int n2) {
    int min;
    if (n1 > n2)
        min = n2;
    else
        min = n1;
    return min;
}

Chamada de Método

Para usar um método, ele deve ser chamado. Existem duas formas: método que retorna valor ou que não retorna nada (void).

O processo é simples: quando um programa invoca um método, o controle é transferido para o método chamado. Este retorna o controle ao chamador em duas condições:

quando a instrução return é executada;
quando atinge a chave de fechamento do método.

Métodos que retornam void são considerados chamadas de instrução:

System.out.println("Este é tutorialspoint.com!");

Métodos que retornam valor:

int result = sum(6, 9);

Exemplo Completo: Definição e Chamada

public class ExampleMinNumber {
    public static void main(String[] args) {
        int a = 11;
        int b = 6;
        int c = minFunction(a, b);
        System.out.println("Valor Mínimo = " + c);
    }

    /** Retorna o mínimo de dois números */
    public static int minFunction(int n1, int n2) {
        int min;
        if (n1 > n2)
            min = n2;
        else
            min = n1;
        return min;
    }
}

Saída:

Valor Mínimo = 6

A Palavra-chave void

A palavra-chave void permite criar métodos que não retornam valor. No exemplo a seguir, methodRankPoints é um método void:

public class ExampleVoid {
    public static void main(String[] args) {
        methodRankPoints(255.7);
    }

    public static void methodRankPoints(double points) {
        if (points >= 202.5) {
            System.out.println("Rank:A1");
        } else if (points >= 122.4) {
            System.out.println("Rank:A2");
        } else {
            System.out.println("Rank:A3");
        }
    }
}

Saída:

Rank:A1

Passagem de Parâmetros por Valor

Durante a chamada, os argumentos devem ser passados na mesma ordem dos parâmetros na especificação do método. No Java, parâmetros são passados por valor: o valor do argumento é copiado para o parâmetro.

Exemplo: Swapping por Valor

public class SwappingExample {
    public static void main(String[] args) {
        int a = 30;
        int b = 45;
        System.out.println("Antes da troca, a = " + a + " e b = " + b);
        swapFunction(a, b);
        System.out.println("\n**Antes e depois da troca os valores serão os mesmos aqui**:");
        System.out.println("Depois da troca, a = " + a + " e b = " + b);
    }

    public static void swapFunction(int a, int b) {
        System.out.println("Antes da troca (dentro), a = " + a + " b = " + b);
        int c = a;
        a = b;
        b = c;
        System.out.println("Depois da troca (dentro), a = " + a + " b = " + b);
    }
}

Saída:

Antes da troca, a = 30 e b = 45
Antes da troca (dentro), a = 30 b = 45
Depois da troca (dentro), a = 45 b = 30
**Antes e depois da troca os valores serão os mesmos aqui**:
Depois da troca, a = 30 e b = 45

Note que os valores originais não mudam, pois Java passa por valor.

Sobrecarga de Métodos (Method Overloading)

Quando uma classe tem dois ou mais métodos com o mesmo nome, mas parâmetros diferentes, isso é sobrecarga de métodos. É diferente de sobrescrita (overriding), onde o método tem o mesmo nome, tipo e número de parâmetros.

Exemplo: Sobrecarga para int e double

public class ExampleOverloading {
    public static void main(String[] args) {
        int a = 11, b = 6;
        double c = 7.3, d = 9.4;
        int result1 = minFunction(a, b);
        double result2 = minFunction(c, d);
        System.out.println("Valor Mínimo = " + result1);
        System.out.println("Valor Mínimo = " + result2);
    }

    // Para inteiros
    public static int minFunction(int n1, int n2) {
        int min;
        if (n1 > n2) min = n2; else min = n1;
        return min;
    }

    // Para doubles
    public static double minFunction(double n1, double n2) {
        double min;
        if (n1 > n2) min = n2; else min = n1;
        return min;
    }
}

Saída:

Valor Mínimo = 6
Valor Mínimo = 7.3

Usando Argumentos de Linha de Comando

Às vezes, você deseja passar informações para um programa ao executá-lo. Isso é feito passando argumentos de linha de comando para main().

Os argumentos são armazenados como strings no array String[] passado para main().

Exemplo

public class CommandLine {
    public static void main(String args[]) {
        for (int i = 0; i < args.length; i++) {
            System.out.println("args[" + i + "]: " + args[i]);
        }
    }
}

Executando:

$ java CommandLine this is a command line 200 -100

Saída:

args[0]: this
args[1]: is
args[2]: a
args[3]: command
args[4]: line
args[5]: 200
args[6]: -100

A Palavra-chave this

this é uma referência ao objeto da classe atual, usada dentro de métodos de instância ou construtores. Permite referenciar membros da classe como construtores, variáveis e métodos.

Usos principais:

Diferenciar variáveis de instância de variáveis locais com o mesmo nome.
Chamar um construtor de outro na mesma classe (invocação explícita de construtor).

Exemplo: Diferenciação de Variáveis

class Student {
    int age;
    Student(int age) {
        this.age = age;
    }
}

Exemplo: Invocação de Construtor

class Student {
    int age;
    Student() {
        this(20);
    }
    Student(int age) {
        this.age = age;
    }
}

Exemplo Completo

public class This_Example {
    int num = 10;

    This_Example() {
        System.out.println("Este é um programa de exemplo sobre a palavra-chave this");
    }

    This_Example(int num) {
        this();
        this.num = num;
    }

    public void greet() {
        System.out.println("Bem-vindo ao Tutorialspoint");
    }

    public void print() {
        int num = 20;
        System.out.println("Valor da variável local num: " + num);
        System.out.println("Valor da variável de instância num: " + this.num);
        this.greet();
    }

    public static void main(String[] args) {
        This_Example obj1 = new This_Example();
        obj1.print();
        This_Example obj2 = new This_Example(30);
        obj2.print();
    }
}

Saída:

Este é um programa de exemplo sobre a palavra-chave this
Valor da variável local num: 20
Valor da variável de instância num: 10
Bem-vindo ao Tutorialspoint
Este é um programa de exemplo sobre a palavra-chave this
Valor da variável local num: 20
Valor da variável de instância num: 30
Bem-vindo ao Tutorialspoint

Argumentos Variáveis (var-args)

Desde o JDK 1.5, você pode passar um número variável de argumentos do mesmo tipo para um método. A declaração usa reticências:

typeName... parameterName

Apenas um parâmetro var-args é permitido por método, e deve ser o último.

Exemplo

public class VarargsDemo {
    public static void main(String args[]) {
        printMax(34, 3, 3, 2, 56.5);
        printMax(new double[]{1, 2, 3});
    }

    public static void printMax(double... numbers) {
        if (numbers.length == 0) {
            System.out.println("Nenhum argumento passado");
            return;
        }
        double result = numbers[0];
        for (int i = 1; i < numbers.length; i++)
            if (numbers[i] > result)
                result = numbers[i];
        System.out.println("O valor máximo é " + result);
    }
}

Saída:

O valor máximo é 56.5
O valor máximo é 3.0

O Método finalize()

É possível definir um método chamado pouco antes da destruição final de um objeto pelo coletor de lixo. Este método é finalize() e pode ser usado para garantir que um objeto termine de forma limpa (ex.: fechar arquivo aberto).

protected void finalize() {
    // código de finalização aqui
}

A palavra-chave protected impede acesso ao finalize() por código fora da classe. Não se sabe quando (ou se) finalize() será executado; se o programa terminar antes da coleta de lixo, ele não será executado.

Expressões Regulares em Java: Dominando Correspondência de Padrões com java.util.regex Dominando Java I/O: Arquivos, Streams e Fundamentos de Entrada/Saída

Java