Métodos Java e decomposição de programas

Um método é um bloco nomeado de instruções que executa uma tarefa. Definir um método disponibiliza essa tarefa; chamá-lo faz a tarefa ser executada.

Leia o cabeçalho e o corpo

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

A primeira linha é o cabeçalho. Leia suas partes da esquerda para a direita:

• public permite que código de outras classes chame o método.
• static faz o método pertencer à classe. Não é necessário um objeto para chamá-lo.
• void indica que o método não retorna valor.
• printLine nomeia a tarefa.
• () é a lista de parâmetros vazia: este método não precisa de entrada.

As chaves delimitam o corpo, as instruções executadas em uma chamada. Não há ponto e vírgula entre esse cabeçalho e sua chave de abertura.

Coloque a definição na classe

public class Main {
    public static void main(String[] args) {
        System.out.println("Start");
        printLine();
        System.out.println("Middle");
        printLine();
    }

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

main e printLine são métodos separados dentro de Main. A chave de fechamento de main vem antes da definição de printLine. Um método não pode ser definido dentro de outro; uma chave fora do lugar pode produzir “illegal start of expression”.

As definições podem aparecer em qualquer ordem. Mover printLine para cima de main não altera o momento em que ele é executado. Um método que nunca é chamado não é executado apenas porque sua definição aparece no arquivo.

Acompanhe uma chamada e o retorno a quem chamou

A chamada printLine(); consiste no nome, nos parênteses e em um ponto e vírgula, pois a chamada é uma instrução isolada. A execução começa em main:

1. Exibe “Start”.
2. Entra em printLine, exibe dez hífens e continua após a chamada.
3. Exibe “Middle”.
4. Entra novamente em printLine e exibe dez hífens outra vez.

A saída é:

Start
----------
Middle
----------

As duas chamadas usam a mesma definição. Alterar a linha que ela exibe muda os dois lugares que a usam.

Nomeie e chame métodos com precisão

Use um verbo ou expressão verbal em camelCase, começando com letra minúscula: printReceipt, calculateAverage ou isValidCode. Java trata maiúsculas e minúsculas como diferentes: PrintLine() não encontra um método chamado printLine. Escrever printLine; também falha; os parênteses fazem parte da chamada.

Para um método estático de outra classe, escreva primeiro o nome da classe. Math.max(3, 8) resulta em 8, Math.abs(-4) resulta em 4 e Math.sqrt(16.0) resulta em 4.0. Seus próprios métodos na mesma classe podem ser chamados apenas pelo nome.

Estes exemplos usam a forma clássica baseada em classe com public static void main(String[] args). O Java 25 também aceita arquivos-fonte compactos com void main() e sem uma classe envolvendo o código. Mantenha a forma clássica ao executar estes exemplos; seus métodos auxiliares são declarados static. Métodos da biblioteca de Java que você chama, como System.out.println, não precisam ser estáticos.

Um parâmetro permite que um método lide com valores que mudam de uma chamada para outra. Um argumento é o valor fornecido para esse parâmetro quando o método é chamado.

Dê um tipo e um nome a cada entrada

public static void printStars(int count) {
    for (int i = 0; i < count; i++) {
        System.out.print("*");
    }
    System.out.println();
}

int count declara um parâmetro. Em printStars(3);, o argumento 3 se torna o valor inicial de count. O laço é executado três vezes, portanto exibe *** e println() encerra a linha. printStars(8); usa o mesmo corpo com count igual a 8.

O tipo é escrito na definição, não na chamada. Escreva printStars(5);, não printStars(int 5);.

Avalie os argumentos antes de entrar no corpo

Um argumento pode ser um literal, uma variável ou uma expressão:

int n = 4;
printStars(n * 2);

Java avalia n * 2 primeiro. Ele passa o valor resultante 8, portanto o corpo começa com count igual a 8. O nome da variável de quem chama não precisa ser igual ao nome do parâmetro.

Associe vários parâmetros por posição

Cada parâmetro precisa de seu próprio tipo. Um método para desenhar retângulos pode começar com este cabeçalho:

public static void printRectangle(int width, int height)

A chamada printRectangle(5, 2); atribui a width o valor 5 e a height o valor 2. Inverter os argumentos produz um retângulo com 2 de largura e 5 de altura. Ambas as chamadas compilam porque os dois argumentos são int; apenas a forma desejada indica qual ordem está correta. Escrever (int width, height) no cabeçalho falha porque height não tem tipo declarado.

Tipos diferentes tornam alguns erros de ordem mais fáceis de identificar:

public static void printRepeated(String text, int times) {
    for (int i = 0; i < times; i++) {
        System.out.print(text);
    }
    System.out.println();
}

printRepeated("ab", 3); exibe “ababab”. printRepeated(3, "ab"); não corresponde a uma String seguida de um int. A quantidade de argumentos também deve corresponder: printRectangle(5); deixa um parâmetro sem valor.

Verifique tipos numéricos compatíveis

Java converte automaticamente um int em double por ampliação. Um método com parâmetros (double km, double hours) aceita os argumentos (150, 2), recebendo 150.0 e 2.0. Todo valor int pode ser representado exatamente como double.

Java não converte implicitamente um argumento double para um parâmetro int por estreitamento. printStars(2.9); falha porque a conversão perderia a parte fracionária. A conversão explícita em printStars((int) 2.9); produz 2, portanto dois asteriscos são exibidos. Use uma conversão explícita apenas quando descartar essa parte for o comportamento desejado.

Escolha um parâmetro para cada informação necessária à tarefa. Receber um texto e uma contagem permite usar printRepeated com entrada do teclado, uma chamada de teste fixa ou outro método. Seu corpo não precisa decidir de onde vieram esses valores.

Um valor de retorno é um resultado enviado por um método a quem o chamou. Depois que uma chamada termina, ela pode ser usada como uma expressão com o tipo desse resultado.

Declare o que é devolvido

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

int substitui void no cabeçalho porque esse método devolve um inteiro. A instrução return avalia a + b e envia o valor ao ponto da chamada. Para sum(4, 7), esse valor é 11.

Quem chama decide o que acontece em seguida:

int total = sum(4, 7);
System.out.println(sum(4, 7));
int doubled = sum(2, 3) * 2;

A primeira linha armazena 11; a segunda exibe 11; a terceira armazena 10. Um valor retornado também pode ser usado em uma condição, como if (sum(a, b) > 10).

Um resultado int compatível pode ser ampliado ao ser retornado por um método double. Um resultado double não pode ser retornado por um método int sem uma conversão explícita adequada.

Calcule a expressão antes de converter o resultado

public static double average(int a, int b) {
    return (a + b) / 2.0;
}

Para average(3, 4), o numerador é 7. Dividir pelo literal double 2.0 resulta em 3.5. Se a expressão fosse (a + b) / 2, Java primeiro dividiria dois valores int e obteria 3. Só então ampliaria esse valor para o 3.0 retornado. Um tipo de retorno double não corrige uma divisão inteira já realizada dentro do corpo.

Distinga retornar de exibir

Uma chamada void não pode fornecer um valor em uma atribuição ou outra chamada. Se printSum for void, int total = printSum(1, 2); falha mesmo que printSum exiba um número. Use um método que retorna valor para cálculos e deixe que quem chama escolha se vai exibi-lo.

Retorne texto e respostas de sim ou não

Os tipos de retorno também incluem String e boolean. Um método de saudação pode retornar "Hello, " + name + "!", resultando em “Hello, Ana!” para o argumento "Ana". Um método isEven(int n) pode retornar n % 2 == 0.

Um método de formatação transforma um número em texto reutilizável:

public static String formatDuration(int minutes) {
    return minutes / 60 + " h " + minutes % 60 + " min";
}

Para 135, a divisão inteira resulta em 2 horas inteiras e o resto resulta em 15 minutos. O resultado é “2 h 15 min”; para 60, é “1 h 0 min”.

Guarde ou combine o resultado

Uma chamada como sum(4, 7); compila, mas descarta seu resultado. Se square(x) retornar um novo valor, use x = square(x); para armazená-lo em x.

Um resultado também pode se tornar um argumento imediatamente. Em Math.max(sum(1, 2), 4), sum(1, 2) primeiro resulta em 3 e depois Math.max(3, 4) resulta em 4. Avalie a chamada interna antes de usar seu resultado na chamada externa.

Uma instrução return encerra imediatamente a chamada do método atual. Dentro de uma condição ou de um laço, ela ainda encerra o método inteiro, não apenas aquele bloco.

Dê uma resposta a cada caminho

public static int larger(int a, int b) {
    if (a > b) {
        return a;
    }
    return b;
}

larger(9, 4) retorna 9 de dentro do if. Para larger(2, 6), o corpo do if é ignorado e o return final fornece 6. Entradas iguais como (5, 5) também chegam ao return final, que fornece 5. Não é necessário else após o primeiro return porque esse caminho já saiu do método.

Em um método comum que retorna valor, nenhum caminho possível pode chegar à chave de fechamento sem fornecer um valor. Um método de sinal que retorna apenas para entradas positivas e negativas deixa o zero sem resposta:

public static String sign(int n) {
    if (n > 0) {
        return "positive";
    } else if (n < 0) {
        return "negative";
    }
    return "zero";
}

O return final completa o método. Duas instruções if separadas, uma testando n > 0 e outra testando n <= 0, ainda precisam de um return final ou de uma estrutura if/else clara. A verificação de retorno de Java não deduz que essas duas comparações abrangem todos os inteiros. Uma instrução diretamente após um return incondicional no mesmo bloco é inalcançável e rejeitada.

Termine uma busca no momento certo

public static int firstMultipleOf7(int start, int end) {
    for (int i = start; i <= end; i++) {
        if (i % 7 == 0) {
            return i;
        }
    }
    return -1;
}

Para (10, 20), o laço rejeita 10, 11, 12 e 13 e retorna 14. A chamada termina sem verificar de 15 a 20. Para (15, 20), o laço termina sem encontrar correspondência, portanto o return depois dele fornece -1, o sinal combinado de “não encontrado”.

Colocar else { return -1; } dentro do laço encerraria a busca após o primeiro candidato rejeitado. A busca a partir de 10 informaria falha antes de chegar a 14. O retorno de falha deve vir após a verificação de todos os candidatos.

Retorne a própria condição

Uma comparação já produz um booleano. Escreva return n % 2 == 0; em vez de um if/else que retorna true e false separadamente. O nome de um método com retorno booleano geralmente começa com is ou has, de modo que uma chamada possa ser lida naturalmente dentro de um if.

public static boolean isLeapYear(int year) {
    return (year % 4 == 0 && year % 100 != 0)
        || year % 400 == 0;
}

Isso retorna true para 2024 e 2000, mas false para 1900 e 2023. Use if (isLeapYear(y)) diretamente.

Saia antecipadamente de um método void

Um método void usa return; sem valor. Por exemplo, printSquareRoot(double x) pode exibir “No real square root” e retornar imediatamente para uma entrada negativa. Para outras entradas, pode exibir Math.sqrt(x), que resulta em 1.5 para 2.25. Escrever return 5; em um método void falha porque seu cabeçalho promete não retornar valor.

O escopo de uma variável é a região do código em que seu nome pode ser usado. Comece pelas chaves em torno de sua declaração: um nome local pertence a um método ou bloco específico.

As variáveis locais de quem chama permanecem em seu método

public static void main(String[] args) {
    int price = 20;
    printDouble(price);
}

public static void printDouble(int price) {
    System.out.println(price * 2);
}

O price de main e o parâmetro price de printDouble são variáveis distintas. O argumento fornece o valor necessário ao método auxiliar, portanto ele exibe 40.

Remover o parâmetro e chamar printDouble() não permite que o método auxiliar leia o price local de main. Seu corpo falharia com “cannot find symbol”. Chamar um método a partir de outro não une seus escopos. Métodos diferentes podem usar o nome count sem conectar suas variáveis.

Um bloco aninhado cria um escopo menor

Uma variável local pode ser usada de sua declaração até a chave de fechamento de seu bloco. Um parâmetro fica disponível em todo o corpo do método. Um contador declarado em for (int i = 0; i < 3; i++) pertence a esse laço; i não pode ser lido depois dele.

Para manter um resultado após um laço, declare-o antes do laço:

int sum = 0;
for (int i = 1; i <= 5; i++) {
    sum += i;
}
System.out.println(sum);

As somas fazem sum passar por 1, 3, 6, 10 e 15. A exibição final pode ler sum porque o bloco que o contém ainda não terminou. i é necessário apenas para o laço e permanece dentro de seu escopo.

Mover int sum = 0; para o corpo do laço cria um novo sum a cada passagem. Cada um começa em zero e desaparece no fim dessa passagem. Ele não pode manter uma soma acumulada nem ser exibido após o laço.

Verifique nomes e valores iniciais separadamente

Duas variáveis locais com o mesmo nome não podem ter escopos sobrepostos dentro de um método. Um método com um parâmetro x não pode declarar outra variável local x; um laço que declara i não pode declarar outro i em seu corpo. Renomeie a segunda variável ou use a existente.

Dois laços consecutivos podem declarar int i. O escopo do primeiro laço terminou antes da segunda declaração. As chaves, e não o arquivo inteiro, determinam essa reutilização.

Um nome permitido também precisa de um valor antes de ser lido. int total; total++; falha porque ++ precisa ler o valor anterior, e uma variável local não recebe valor inicial automático. Use int total = 0; para uma soma acumulada.

Mantenha uma variável local no menor bloco que precisa dela. Se um método precisa de informações de quem o chama, transforme essas informações em parâmetros. Se quem chama precisa de um resultado, retorne-o. Assim, o cabeçalho e o corpo do método mostram de onde vêm seus dados.

Java passa argumentos por valor. No início de uma chamada, cada parâmetro recebe uma cópia do valor de seu argumento. Atribuir um valor ao parâmetro altera essa variável local.

Rastreie a cópia separadamente

public static void main(String[] args) {
    int score = 10;
    addBonus(score);
    System.out.println(score);
}

public static void addBonus(int score) {
    score = score + 5;
    System.out.println(score);
}

Há duas variáveis chamadas score. Acompanhe seus valores em cada ponto:

O método auxiliar exibe 15, depois main exibe 10. Compartilhar um nome não faz as duas variáveis compartilharem o armazenamento. Renomear o parâmetro não alteraria esse comportamento.

Retorne o novo valor e armazene-o

public static int addBonus(int score) {
    return score + 5;
}

Com esta versão, escreva score = addBonus(score);. Java copia o valor antigo para o parâmetro, calcula 15, retorna esse valor e o atribui à variável de quem chamou. A atribuição em quem chama é a etapa que altera essa variável.

Um resultado também pode ser armazenado em outro lugar. Se triple(int n) multiplicar seu n local por 3 e retorná-lo, então int a = 4; int b = triple(a); deixa a igual a 4 e atribui a b o valor 12. Exibir a + " " + b mostra “4 12”.

Aplique a mesma regra a referências String

Uma variável String armazena uma referência a um objeto String. Java copia essa referência para um parâmetro String:

public static void exclaim(String text) {
    text = text + "!";
}

Se word de quem chama se referir a “hi”, exclaim(word); deixa word se referindo a “hi”. A concatenação cria uma nova String, e a atribuição altera apenas aquilo a que o parâmetro se refere. O conteúdo existente de uma String não pode ser alterado.

Para manter o novo texto, retorne text + "!" de um método String como exclaimed e depois escreva word = exclaimed(word);.

Para objetos mutáveis, como listas, uma referência copiada ainda pode apontar para o mesmo objeto. Um método pode alterar o conteúdo desse objeto por meio da referência copiada. Reatribuir o parâmetro ainda não pode fazer a variável de quem chamou se referir a outro objeto. A regra da referência copiada e a regra do número copiado são ambas passagem por valor.

Você pode reatribuir um parâmetro, mas uma variável local separada como result pode facilitar a leitura de um cálculo mais longo: ela mantém a entrada original disponível e mostra qual valor será retornado.

A pilha de chamadas registra chamadas que começaram, mas ainda não terminaram. Cada chamada recebe um registro de ativação com seus parâmetros, suas variáveis locais e o ponto em que quem chamou continuará.

Empilhe um registro, conclua-o e remova-o

A pilha funciona pelo princípio último a entrar, primeiro a sair. A chamada mais recente fica no topo e é executada enquanto quem a chamou aguarda abaixo. Quando ela retorna, Java remove seu registro e retoma quem chamou.

public static void main(String[] args) {
    int total = totalSeconds(2, 30);
    System.out.println(total);
}

public static int totalSeconds(int minutes, int seconds) {
    int fromMinutes = toSeconds(minutes);
    return fromMinutes + seconds;
}

public static int toSeconds(int minutes) {
    return minutes * 60;
}

Acompanhe o trabalho ainda não concluído:

1. main começa e chama totalSeconds(2, 30). Sua atribuição a total deve esperar.
2. O novo registro tem minutes = 2 e seconds = 30. Ele chama toSeconds(minutes) e aguarda fromMinutes.
3. toSeconds recebe seu próprio minutes = 2. Ele retorna 120 e seu registro é removido.
4. totalSeconds armazena fromMinutes = 120, adiciona 30 e retorna 150. Seu registro é removido.
5. main armazena total = 150 e exibe 150.

No ponto mais profundo, os registros de baixo para cima são main, totalSeconds e toSeconds. Ambos os métodos auxiliares têm um parâmetro chamado minutes, mas esses parâmetros ocupam registros diferentes. As variáveis locais de quem chama e está aguardando não ficam visíveis para o método acima dele.

Uma chamada posterior recebe um novo registro. Um contador local não se lembra de seu valor anterior após o término da chamada; o valor de retorno é o que pode levar um resultado de volta.

Leia um rastreamento da pilha a partir do erro

Uma exceção não tratada exibe um rastreamento da pilha que mostra onde o erro ocorreu e quais chamadas levaram até ele. Veja um arquivo completo:

public class Main {
    public static void main(String[] args) {
        report(300, 0);
    }

    public static void report(int meters, int minutes) {
        int speed = perMinute(meters, minutes);
        System.out.println(speed + " m per minute");
    }

    public static int perMinute(int meters, int minutes) {
        return meters / minutes;
    }
}

A primeira linha da saída é Exception in thread "main" java.lang.ArithmeticException: / by zero. Os registros abaixo dela são:

at Main.perMinute(Main.java:12)
at Main.report(Main.java:7)
at Main.main(Main.java:3)

O registro superior identifica a divisão inteira por zero. Os dois seguintes localizam as chamadas que levaram até ela. Os números de linha pertencem exatamente a esta disposição do arquivo; adicionar uma linha os altera.

A pilha tem espaço finito. Uma cadeia que continua adicionando chamadas sem permitir que terminem pode causar StackOverflowError. A visualização da pilha de um depurador permite examinar a mesma cadeia enquanto o programa está pausado em um ponto de interrupção, incluindo as variáveis separadas de cada chamada em espera.

A sobrecarga dá o mesmo nome a métodos com listas de parâmetros diferentes. Ela é útil quando os métodos realizam a mesma tarefa para quantidades ou tipos diferentes de entrada.

Compare assinaturas

Para esses métodos, uma assinatura consiste no nome e nos tipos dos parâmetros em ordem. A quantidade de parâmetros decorre dessa lista.

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

public static int max(int a, int b, int c) {
    return max(max(a, b), c);
}

public static double max(double a, double b) {
    if (a > b) {
        return a;
    }
    return b;
}

As assinaturas são max(int, int), max(int, int, int) e max(double, double). max(3, 9) retorna 9 usando a primeira. max(3, 9, 5) chama a segunda: a chamada interna com dois valores int retorna 9, depois a chamada externa com dois valores int compara 9 e 5, também retornando 9. max(2.5, 1.0) usa a versão double e retorna 2.5.

Saiba quais alterações não contam

Alterar apenas o tipo de retorno não cria uma sobrecarga. Estes cabeçalhos entram em conflito:

public static int area(int w, int h)
public static double area(int w, int h)

Ambos têm a assinatura area(int, int). Java rejeita a declaração duplicada. Renomear os parâmetros para width e height também mantém a mesma assinatura: quem chama fornece valores por posição, não pelo nome do parâmetro.

A ordem de tipos diferentes conta. describe(String s, int n) e describe(int n, String s) são assinaturas distintas. Elas compilam juntas, mas quem chama precisa lembrar uma ordem fácil de confundir, portanto use esse par apenas quando ele ajudar no projeto.

Deixe uma sobrecarga mais curta fornecer um valor padrão

Java não fornece valores padrão para parâmetros em declarações de métodos. Uma sobrecarga mais curta pode chamar uma mais longa com um argumento fixo:

public static void printLine(int length, char symbol) {
    for (int i = 0; i < length; i++) {
        System.out.print(symbol);
    }
    System.out.println();
}

public static void printLine(int length) {
    printLine(length, '-');
}

printLine(5, '*'); exibe *****. printLine(4); entra no método mais curto, que chama o mais longo com 4 e '-', exibindo ----. O laço fica em um só lugar, portanto alterações na tarefa de exibição se aplicam às duas formas.

A biblioteca de Java também usa sobrecargas. System.out.println aceita um int, um double, um char, um boolean ou uma String por meio de versões diferentes. Math.abs e Math.max oferecem versões para int, long, float e double.

Mantenha um único significado para o nome compartilhado. Exibir um recibo e exibir uma etiqueta são tarefas diferentes; nomes claros como printReceipt e printLabel informam a quem chama qual tarefa será executada.

O compilador escolhe uma sobrecarga a partir da quantidade e dos tipos dos argumentos. Determine essa escolha antes de considerar como o valor retornado será usado.

Comece pelas correspondências exatas

Suponha que uma classe defina show(int x) e show(double x). show(5) usa a versão int porque o literal 5 é int. show(5.0) usa a versão double. Um valor inteiro escrito como 5.0 ainda é uma expressão double.

Para uma chamada com vários argumentos, compare o tipo em cada posição. Um candidato com a quantidade errada de argumentos não pode ser compatível.

Permita a conversão de ampliação quando necessário

Se existir apenas show(double x), show(5) é válido: o int é ampliado para 5.0. Os caminhos de ampliação de tipos primitivos incluem:

byte → short → int → long → float → double
char → int → long → float → double

Com show(long x) e show(double x), um argumento int escolhe long. Esse é o tipo de parâmetro compatível mais específico: um long pode ser ampliado para double, enquanto um double não pode ser ampliado de volta para long.

A ampliação é uma conversão numérica permitida; ela não garante que toda conversão desse tipo preserve todos os algarismos. Em particular, converter um long suficientemente grande em double pode arredondar seu valor. A conversão de int para double usada nos exemplos anteriores preserva exatamente todos os valores int.

Um char também tem valor numérico. Com letter(int code) e letter(String text), letter('A') chama a versão int com 65. Um caractere não se torna uma String para corresponder a um parâmetro. As aspas duplas em "A" criariam um argumento String.

Rejeite o estreitamento implícito

Se houver apenas show(int x), show(5.0) falha. Java não faz o estreitamento de um argumento double apenas porque seu valor é um número inteiro. show((int) 5.0) passa um int após uma conversão explícita.

Da mesma forma, versões de max para dois e três valores int não podem aceitar max(1). Nenhum candidato tem a quantidade necessária de parâmetros, portanto o compilador informa “no suitable method found”. Compare a lista de candidatos com os argumentos fornecidos.

Separe a escolha da sobrecarga da conversão do resultado

Considere int twice(int n) e double twice(double x). Em double d = twice(3);, o argumento seleciona a sobrecarga int. Essa chamada retorna 6, e a atribuição o amplia para 6.0. O destino d não seleciona a sobrecarga double.

Reconheça uma chamada ambígua

public static void combine(int a, double b) { }
public static void combine(double a, int b) { }

combine(1, 2) é compatível com a primeira após ampliar seu segundo argumento e com a segunda após ampliar seu primeiro. Nenhuma assinatura é mais específica nas duas posições. Java informa “reference to combine is ambiguous”; ele não escolhe a definição escrita primeiro.

combine(1, 2.0) é compatível apenas com (int, double), pois a outra assinatura precisaria de uma conversão de estreitamento de 2.0. Um tipo de argumento claro ou um conjunto melhor de sobrecargas elimina a ambiguidade.

Decomposição significa dividir um problema em tarefas menores e resolver cada tarefa em seu próprio método. Escolha tarefas cujos nomes ajudem alguém a entender o plano do programa.

Separe o cálculo da entrada e da saída

Um programa sobre um passeio de bicicleta precisa calcular a velocidade e apresentar um relatório. As duas tarefas usam os mesmos dados, mas têm funções diferentes:

public static double kilometersPerHour(double km, double hours) {
    return km / hours;
}

public static void printRideReport(double speed) {
    System.out.println("Speed: " + speed + " km/h");
}

Para um passeio de 150 km em 2 horas, o cálculo retorna 75.0. O método de relatório recebe esse valor e o exibe. Quem chama conecta as etapas:

double speed = kilometersPerHour(150, 2);
printRideReport(speed);

O método de cálculo não lê entrada do teclado nem exibe um relatório. Outro programa pode usá-lo para comparar passeios ou armazenar velocidades sem alterar seu corpo. Para testá-lo, chame-o com entradas conhecidas e compare o número retornado com o esperado.

Reconheça um método com tarefas demais

Um nome como readAndCheckAndPrint sugere várias ações. Outros indícios incluem seções marcadas por comentários, um corpo maior que uma tela e grupos de variáveis que atendem a finalidades sem relação entre si. Esses são motivos para examinar o método, não limites rígidos para a quantidade de linhas que ele pode ter.

Divida o método em um ponto que faça sentido. O código de entrada pode obter um valor, um método auxiliar com retorno booleano pode verificá-lo, um método de cálculo pode retornar um resultado e um método de relatório pode exibi-lo. Assim, main pode ser lido como uma breve descrição de como essas tarefas se conectam.

Métodos focados são mais fáceis de ler separadamente, reutilizar e testar. Se o formato de um relatório mudar, edite o método de relatório. Se um cálculo estiver errado, teste esse cálculo sem precisar digitar uma sessão inteira de entrada.

Deixe o cabeçalho explicar o fluxo de dados

Em kilometersPerHour(double km, double hours), o nome indica o resultado, os nomes dos parâmetros indicam as grandezas e o tipo de retorno double indica o tipo de resposta. Um breve comentário Javadoc pode acrescentar o significado das entradas e do resultado:

/**
 * Calculates a ride's average speed.
 * @param km distance in kilometers
 * @param hours elapsed time in hours, greater than zero
 * @return speed in kilometers per hour
 */

Coloque esse comentário diretamente acima do cabeçalho do método. Um comentário útil acrescenta informações como unidades ou um requisito para a entrada; ele não precisa narrar cada linha do corpo.

Um método auxiliar necessário apenas à sua própria classe pode ser private static. private impede que outras classes o chamem, enquanto o código da mesma classe ainda pode usá-lo. public static disponibiliza o método auxiliar para outras classes.

Separar cada instrução óbvia em seu próprio método também pode obscurecer o plano. Mantenha um método quando seu nome representar uma etapa significativa ou um cálculo reutilizável. Uma cadeia de métodos auxiliares que apenas repassam a mesma chamada acrescenta mais lugares a examinar sem explicar melhor a tarefa.

Código duplicado repete a mesma tarefa em mais de um lugar. Quando apenas os valores de entrada diferem, um método parametrizado pode manter o trabalho comum em um só lugar.

Encontre o cálculo comum

Suponha que um programa some de 1 a 10 e depois de 1 a 50:

int total1 = 0;
for (int i = 1; i <= 10; i++) {
    total1 += i;
}
System.out.println("Sum 1 to 10: " + total1);
int total2 = 0;
for (int i = 1; i <= 50; i++) {
    total2 += i;
}
System.out.println("Sum 1 to 50: " + total2);

Os dois laços começam em 1, adicionam valores a um total e param em um limite superior. Apenas esse limite muda. Um parâmetro n pode levá-lo a um cálculo compartilhado.

Extraia o método

public static int sumUpTo(int n) {
    int total = 0;
    for (int i = 1; i <= n; i++) {
        total += i;
    }
    return total;
}

n é a entrada variável. total e i são variáveis de trabalho que pertencem ao método auxiliar. Quem chama precisa da soma final, portanto o método auxiliar retorna um int.

Substitua as duas seções repetidas:

System.out.println("Sum 1 to 10: " + sumUpTo(10));
System.out.println("Sum 1 to 50: " + sumUpTo(50));

sumUpTo(10) retorna 55, e sumUpTo(50) retorna 1275. As linhas exibidas são “Sum 1 to 10: 55” e “Sum 1 to 50: 1275”, como antes. As descrições permanecem em quem chama; o laço realiza apenas o cálculo.

Verifique a extração em uma ordem definida

1. Marque as instruções que realizam a tarefa repetida.
2. Identifique cada valor que difere entre as cópias.
3. Transforme esses valores em parâmetros com tipos adequados e retorne qualquer resultado necessário fora do método.
4. Substitua cada cópia por uma chamada usando suas entradas originais.
5. Execute as mesmas entradas antes e depois e compare o comportamento.

Alterar a estrutura do código preservando seu comportamento é refatoração. Deixar uma cópia original significa que uma correção posterior ainda terá dois lugares para atualizar. Mover uma exibição para dentro de um laço ou alterar o limite final de um laço muda o comportamento, mesmo que o código fique mais curto.

Quando duas diferenças têm tipos diferentes, use parâmetros correspondentes. Repetir textos diferentes quantidades diferentes de vezes sugere printRepeated(String text, int times); a palavra é uma String e a contagem é um int.

Código com aparência semelhante nem sempre realiza a mesma tarefa. Um parâmetro booleano que alterna um método entre cálculos sem relação entre si pode dificultar a interpretação das chamadas. Dê nomes diferentes a tarefas diferentes. Extraia a operação repetida apenas quando variar suas entradas preservar um significado claro.

O projeto descendente começa pela tarefa completa e a refina em chamadas de métodos menores. Decida o que cada chamada precisa e retorna antes de preencher todos os detalhes.

Planeje as etapas e os cabeçalhos

Um programa semanal de exercícios lê 7 durações diárias, soma-as e exibe um relatório. Seus métodos auxiliares podem ser planejados assim:

• readMinutes(Scanner scanner, int day) retorna os minutos válidos de um dia.
• isValidMinutes(int minutes) responde se a entrada está entre 0 e 1440.
• formatDuration(int minutes) retorna texto com horas inteiras e minutos restantes.
• averagePerDay(int total, int days) retorna uma média double.
• printSummary(int totalMinutes, int days) exibe o relatório.

O mesmo Scanner é passado a cada chamada de entrada. Um método auxiliar como isValidMinutes não precisa ler a entrada por conta própria.

Use métodos provisórios durante o desenvolvimento

Um método provisório tem seu cabeçalho definitivo, mas um corpo mínimo temporário, como return 0;. Ele permite que o programa compile antes de o método auxiliar ser implementado. Substitua um método provisório, compile e verifique esse método antes de substituir o próximo. Um método provisório que compila ainda é trabalho inacabado; sua resposta fixa não pode verificar um cálculo real.

Veja o programa concluído:

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int total = 0;
        for (int day = 1; day <= 7; day++) {
            total += readMinutes(scanner, day);
        }
        printSummary(total, 7);
    }

    public static int readMinutes(Scanner scanner, int day) {
        System.out.println("Minutes for day " + day + ":");
        int minutes = scanner.nextInt();
        while (!isValidMinutes(minutes)) {
            System.out.println("Enter minutes from 0 to 1440:");
            minutes = scanner.nextInt();
        }
        return minutes;
    }

    public static boolean isValidMinutes(int minutes) {
        return minutes >= 0 && minutes <= 1440;
    }

    public static String formatDuration(int minutes) {
        return minutes / 60 + " h " + minutes % 60 + " min";
    }

    public static double averagePerDay(int total, int days) {
        return (double) total / days;
    }

    public static void printSummary(int totalMinutes, int days) {
        System.out.println("Total: " + formatDuration(totalMinutes));
        System.out.println("Daily average: "
            + averagePerDay(totalMinutes, days) + " min");
        if (totalMinutes >= 150) {
            System.out.println("Weekly goal reached");
        }
    }
}

Para uma entrada inteira, readMinutes repete a verificação do intervalo até que o número seja válido. Com as entradas diárias 30, 45, 0, 60, 90, 45 e 45, o total é 315. A formatação produz “5 h 15 min”, a média é 45.0 minutos e o programa informa que sua meta semanal de 150 minutos foi atingida.

Verifique métodos pequenos e seus valores-limite

Chame cada método de cálculo com resultados conhecidos. formatDuration(0) deve resultar em “0 h 0 min”, 59 resulta em “0 h 59 min”, 60 resulta em “1 h 0 min” e 135 resulta em “2 h 15 min”. As entradas imediatamente abaixo de 60 e no próprio limite verificam a mudança de minutos para uma hora inteira.

Para isValidMinutes, teste -1, 0, 1440 e 1441. Os resultados esperados são false, true, true e false. Exibir os valores esperado e obtido lado a lado torna um erro visível. JUnit automatiza esse tipo de verificação.

O desenvolvimento ascendente começa pela escrita e pelo teste de pequenos métodos auxiliares e depois os une em etapas maiores. Você pode planejar de forma descendente e construir de forma ascendente: defina primeiro o fluxo de dados, comprove que os pequenos cálculos funcionam e depois verifique o programa integrado.