Parâmetros padrão Java

Java não oferece valores padrão para parâmetros em declarações de métodos. Cada chamada deve fornecer um argumento para cada parâmetro fixo; um parâmetro varargs pode receber zero ou mais argumentos. O compilador não insere um valor quando um argumento fixo é omitido. Para oferecer comportamentos opcionais, defina sobrecargas, aceite uma quantidade variável de valores do mesmo tipo com varargs ou represente explicitamente a ausência na API. Essas alternativas resolvem problemas diferentes. Escolha conforme quem chama precise de algumas opções fixas, de uma lista de tamanho variável ou de uma distinção significativa entre “não informado” e um valor informado.

Java oferece suporte a valores padrão de parâmetros?

Não. A assinatura de um método em Java declara os parâmetros que toda chamada deve fornecer. Por exemplo, não é possível chamar um método declarado como send(String recipient, String subject) informando apenas o destinatário. Java não deduz o assunto nem aplica um valor padrão declarado na assinatura. O corpo do método pode escolher um valor substituto depois de receber um argumento, mas isso é lógica da aplicação, não um valor padrão de parâmetro definido pela linguagem.

Use sobrecarga de métodos para um pequeno número de argumentos opcionais

A sobrecarga de métodos oferece a quem chama algumas formas explícitas de invocar o método. Uma sobrecarga com menos parâmetros pode passar um valor substituto para o método completo. Essa solução funciona bem quando há poucas alternativas comuns, e o valor substituto fica visível no código. No exemplo a seguir, a saudação usa "Hello" como valor padrão quando se chama a sobrecarga com um argumento.

Execute este exemplo:

O código e os rótulos ou saídas exibidos nesta seção permanecem em inglês.

public class GreetingExample {
    static String greet(String name) {
        return greet(name, "Hello");
    }

    static String greet(String name, String greeting) {
        return greeting + ", " + name + "!";
    }

    public static void main(String[] args) {
        System.out.println(greet("Maya"));
        System.out.println(greet("Maya", "Welcome"));
    }
}

Hello, Maya!
Welcome, Maya!

A sobrecarga fornece explicitamente o valor substituto; o compilador não faz isso. As sobrecargas ficam trabalhosas à medida que aumenta o número de argumentos opcionais. Se dois parâmetros opcionais tiverem o mesmo tipo e quem chama puder omitir qualquer um deles, os tipos dos parâmetros na assinatura do método não indicarão qual foi omitido. Por isso, oferecer suporte a muitas combinações pode exigir várias assinaturas distintas. Quando houver muitas combinações, prefira métodos com nomes claros ou um objeto de opções.

Use varargs para uma quantidade variável de argumentos do mesmo tipo

Um parâmetro varargs, escrito como Type... values, permite que um método aceite zero ou mais argumentos daquele tipo. Dentro do método, Java os disponibiliza como um array. Varargs são úteis quando a quantidade de valores realmente varia; não definem um valor substituto para um parâmetro fixo omitido. O método pode decidir o que significa receber zero valores, como neste exemplo, que retorna zero para uma lista vazia.

O código e os rótulos ou saídas exibidos nesta seção permanecem em inglês.

public class SumExample {
    static int sum(int... values) {
        int total = 0;
        for (int value : values) {
            total += value;
        }
        return total;
    }

    public static void main(String[] args) {
        System.out.println(sum());
        System.out.println(sum(4, 7, 9));
    }
}

0
20

Retornar zero quando não há valores é a regra de soma escolhida pelo método. Java não fornece esse valor como argumento padrão. Um método pode ter apenas um parâmetro varargs, que deve ser o último; portanto, os parâmetros fixos precisam vir antes dele.

Use um sentinela ou um wrapper quando a ausência for diferente de um valor

Uma string vazia ("") é uma string válida, sem caracteres. null é um valor de referência distinto, e um argumento omitido simplesmente não é passado. Nem o texto vazio nem null são inseridos automaticamente no lugar de um argumento ausente. Use uma string vazia quando esse for o valor desejado; use null somente quando a API definir o significado da ausência e quem chama puder tratá-lo com segurança.

Quando for necessário distinguir “não informado” de todos os valores válidos, represente esse estado explicitamente. Para uma referência que aceita nulo, uma convenção documentada de null pode ser suficiente, mas não expressa ausência para parâmetros primitivos e pode ser fácil de usar incorretamente. Um wrapper como Optional<String> pode explicitar a presença de um valor de referência; para várias configurações opcionais, uma classe de opções ou um builder costuma ser mais claro. Ainda assim, essas alternativas exigem que quem chama passe o wrapper ou o objeto de opções: elas representam a ausência dentro da API, mas não acrescentam parâmetros padrão nativos a Java.