Assertiva Java (Assert)

Neste tutorial, vamos aprender a usar a declaração assertiva do Java (afirmação do Java) com exemplos.

As afirmações no Java ajudam a detectar erros testando o código que consideramos correto.

Use o comando assert para fazer afirmações.

Sua sintaxe é:

assert condition;

Aqui, condition é uma expressão booleana, supondo que seja verdadeira durante a execução do programa.

Ativar afirmativa

Por padrão, as afirmativas estão desativadas no tempo de execução e são ignoradas.

Para ativar a afirmativa, usamos:

java　-ea:arguments

ou

java　-enableassertions:arguments

Se a afirmativa estiver ativada e a condição for true, o programa executará normalmente.

Exemplo1: Java assertiva

class Main {
　　public static void main(String args[]) {
　　　　String[] weekends = {"Friday", "Saturday", "Sunday"};
　　　　assert weekends.length ==　2;
　　　　System.out.println("Essa semana tem ",　+　weekends.length　+　"	weekends");
　　}
}

Resultados de saída

Essa semana tem　3　weekends

Obtemos a saída acima porque o programa não tem erros de compilação e, por padrão, a assertiva está desativada.

Depois de ativar a assertiva, obtemos a seguinte saída:

Exception in thread "main" java.lang.AssertionError

Outra forma de declarar assertiva

assert condition : expression;

Nessa forma de sentença de assertiva, a expressão é passada para o construtor do objeto AssertionError. Se a condição for false, o valor da expressão é exibido como detalhes de erro.

Mensagens detalhadas são usadas para capturar e transmitir informações sobre falha da assertiva, ajudando a depurar problemas.

Exemplo2: Exemplo de Java assertiva com expressão

class Main {
　　public static void main(String args[]) {
　　　　String[] weekends = {"Friday", "Saturday", "Sunday"};
　　　　assert weekends.length==2　: "There are only　2　weekends in a week";
　　　　System.out.println("There are ",　+　weekends.length　+　"	weekends in a week");
　　}
}

Resultados de saída

Exception in thread "main" java.lang.AssertionError: There are only　2　weekends in a week

Como podemos ver no exemplo acima, a expressão é passada para o construtor do objeto AssertionError. Se nossa hipótese estiver correta (false) e a assertiva estiver ativada, uma exceção será lançada e uma mensagem apropriada será exibida.

Essa mensagem ajuda a diagnosticar e corrigir erros que levam ao falha da assertiva.

Ativar a assertiva para classes e pacotes específicos

Se não fornecermos nenhum parâmetro para a opção de linha de comando de assertiva

java　-ea

Isso ativa a assertiva em todas as classes, exceto as classes do sistema.

Também podemos usar parâmetros para ativar a assertiva de classes e pacotes específicos. Os parâmetros que podem ser fornecidos para essas opções de linha de comando são:

Ativar a assertiva no nome da classe

Para ativar a assertiva em todas as classes do programa Main

java　-ea Main

Só ativar uma classe

java　-ea:AnimalClass Main

Ativar assertivas no nome do pacote

Para ativar as assertivas no pacote com.animal e seus subpacotes

java　-ea:com.animal... Main

Ativar assertivas no pacote anônimo

Ativar assertivas no pacote anônimo no diretório de trabalho atual (quando não usamos a语句).

java　-ea:... Main

Ativar assertivas em classes do sistema

Para ativar as assertivas em classes do sistema, usamos comandos de linha de comando diferentes:

java　-esa:arguments

ou

java　-enablesystemassertions:arguments

Os parâmetros fornecidos para essas opções são os mesmos.

Desativar assertivas

Para desativar as assertivas, usamos:

java　-da arguments

ou

java　-disableassertions arguments

Para desativar as assertivas em classes do sistema, usamos:

java　-dsa:arguments

ou

java　-disablesystemassertions:arguments

Os argumentos passados ao desativar as assertivas são os mesmos que ao ativá-las.

Vantagens das assertivas

1. Detecta e corrige rapidamente e eficientemente erros.

2. Verificação de assertivas ocorre apenas durante o desenvolvimento e teste. Elas são automaticamente removidas do código de produção no tempo de execução, portanto, não atrasam a execução do programa.

3. Isso ajuda a remover código de exemplo e tornar o código mais legível.

4. Refatorar e otimizar o código para aumentar a confiança em seu correto funcionamento.

Quando usar assertivas

1.Código inacessível

Código inacessível é o código que não é executado quando tentamos executar o programa. Usamosasserts para garantir que o código inacessível realmente é inacessível.

Vamos dar um exemplo.

void unreachableCodeMethod() {
　　System.out.println("Código acessível");
　　return;
　　//　Código inacessível
　　System.out.println("Código inacessível");
　　assert false;
}

Vamos analisar um exemplo de语句 switch sem caso padrão.

switch (dayOfWeek) {
　　case "domingo":
　　　　System.out.println("É domingo!");
　　　　break;
　　case "segunda-feira":
　　　　System.out.println("É segunda-feira!");
　　　　break;
　　case "terça-feira":
　　　　System.out.println("É terça-feira!");
　　　　break;
　　case "Wednesday":
　　　　System.out.println("É quarta-feira!");
　　　　break;
　　case "Thursday":
　　　　System.out.println("É quarta-feira!");
　　　　break;
　　case "Friday":
　　　　System.out.println("É sexta-feira!");
　　　　break;
　　case "Saturday":
　　　　System.out.println("É sábado!");
　　　　break;
}

A instrução switch acima indica que os dias da semana podem ser apenas os seguintes7um dos valores. Não haver situação padrão significa que o programador acredita que uma dessas situações sempre será executada.

Mas, em alguns casos hipotéticos que são errados, podem ainda não ter sido consideradas algumas situações.

Deve usar afirmações para verificar essa hipótese, para garantir que não se atinja a condição de switch padrão.

default:
　　　　assert false: dayofWeek　+　"é um dia inválido";

Se o valor de dayOfWeek não for uma data válida, lance AssertionError.

2.Registrar hipóteses

Para registrar suas hipóteses básicas, muitos programadores usam comentários. Vamos dar um exemplo.

if (i %　2　== 0) {
　　　　...
} else {　//　Sabemos que (i %　2　==　1)
　　　　...
}

Use afirmações.

À medida que o programa cresce, os comentários podem se tornar obsoletos e des sincronizados. No entanto, teremos que atualizar as afirmações; senão, também podem falhar devido a condições válidas.

if (i %　2　== 0) {
　　　...
} else {
　　　　assert i %　2　==　1　: i;
　　　　...
}

Quando não usar afirmações

1.Verificação de parâmetros em métodos públicos

Os usuários podem fornecer parâmetros em métodos públicos.

Portanto, se usar afirmações para verificar esses parâmetros, a condição pode falhar e causar AssertionError.

Em vez de usar afirmações, é melhor que causem exceções de tempo de execução apropriadas e que essas exceções sejam tratadas.

2.Avaliação de expressões que afetam a operação do programa

Não chame métodos ou avalie exceções que possam afetar a operação do programa sob condições de afirmação.

Vamos usar um exemplo de tabela para ilustrar, a lista weekdays contém os nomes de todos os dias da semana.

ArrayList<String> weekdays = new ArrayList<>(Arrays.asList("Domingo", "Segunda-feira", "Terça-feira", "Quarta-feira", "Quinta-feira", "Sexta-feira", "Sábado"));
ArrayList<String> weekends = new ArrayList<>(Arrays.asList("Domingo", "Sábado"));
assert weekdays.removeAll(weekends);

Aqui, tentamos remover os elementos Saturday e Sunday da ArrayList weekdays.

Se a afirmação estiver ativada, o programa pode funcionar normalmente. No entanto, se a afirmação estiver desativada, os elementos da lista não serão removidos. Isso pode levar ao fracasso do programa.

Em vez disso, atribua o resultado a uma variável e use essa variável para a assertiva.

ArrayList<String> weekdays = new ArrayList<>(Arrays.asList("Domingo", "Segunda-feira", "Terça-feira", "Quarta-feira", "Quinta-feira", "Sexta-feira", "Sábado"));
ArrayList<String> weekends = new ArrayList<>(Arrays.asList("Domingo", "Sábado"));
boolean weekendsRemoved = weekdays.removeAll(weekends);
assert weekendsRemoved;

Desta forma, podemos garantir que todos os fins de semana sejam removidos de weekdays, independentemente da ativação ou desativação de assertivas. Como resultado, isso não afetará as operações do programa futuras.