1. Visão geral
Existe a chave assert nas linguagens C e C++, que significa afirmação.
Em Java, também existe a palavra-chave assert, que significa afirmação. O uso e o significado são semelhantes.
2. Gramática
Em Java, a palavra-chave assert foi introduzida a partir do JAVA SE 1.4. Para evitar erros causados pelo uso da palavra-chave assert em versões mais antigas do código Java, Java não habilita a verificação de asserção por padrão durante a execução (neste momento, todas as instruções de asserção irão. ser ignorado!), se quiser ativar a verificação de asserção, você precisa ativá-la com a opção -enableassertions ou -ea.
A sintaxe da palavra-chave assert é muito simples e tem dois usos:
1. afirmar <expressão booleana>
Se <expressão booleana> for verdadeira, a execução do programa continua.
Se for falso, o programa lança um AssertionError e encerra a execução.
2. assert <expressão booleana>: <expressão de mensagem de erro>
Se <expressão booleana> for verdadeira, a execução do programa continua.
Se for falso, o programa lança java.lang.AssertionError e insere <expressão de mensagem de erro>.
3. Exemplos de aplicação
Um exemplo é dado abaixo para ilustrar seu uso:
Copie o código do código da seguinte forma:
classe pública AssertFoo {
public static void main(String args[]) {
//O resultado da afirmação 1 é verdadeiro, então continue a execução.
afirmar verdadeiro;
System.out.println("Não há problema com a afirmação 1, vá!");
System.out.println("/n-----------------/n");
//O resultado da afirmação 2 é falso e o programa termina
assert false : "Asserção falhou, as informações desta expressão serão exibidas quando uma exceção for lançada!";
System.out.println("Não há problema com a afirmação 2, vá!");
}
}
Salve o código em C:/AssertFoo.java, execute-o da seguinte maneira e visualize a saída do console:
1. Compilar programa:
C:/>javac AssertFoo.java
2. O programa é executado por padrão sem ativar a opção -ea:
C:/>java AssertFoo
A afirmação 1 está correta, vá!
------------------
A afirmação 2 não é problema, vá!
3. Ative a opção -ea e execute o programa:
C:/>java -ea AssertFoo
A afirmação 1 está correta, vá!
------------------
Exceção no thread "main" java.lang.AssertionError: Asserção falhou, as informações desta expressão serão
Será gerado quando uma exceção for lançada!
em AssertFoo.main(AssertFoo.java:10)
4. Armadilha
A palavra-chave assert é simples de usar, mas usar assert muitas vezes fará você cair em uma armadilha cada vez mais profunda. Deve ser evitado. Após pesquisa, o autor resumiu os seguintes motivos:
1. A palavra-chave assert precisa ser explicitamente habilitada em tempo de execução para ter efeito, caso contrário, sua afirmação não terá sentido. Atualmente, as principais ferramentas Java IDE não habilitam a função de verificação de asserção -ea por padrão. Isso significa que se você usar ferramentas IDE para codificar, terá alguns problemas ao depurar e executar. Além disso, para aplicativos Java Web, o código do programa é implementado no contêiner e você não pode controlar diretamente a execução do programa. Se for necessário ativar a opção -ea, será necessário alterar os parâmetros de configuração de execução do contêiner da Web. Isto traz grandes transtornos para o transplante e implantação de programas.
2. Usar assert em vez de if é a segunda armadilha. O julgamento de assert é semelhante ao da instrução if, mas as funções dos dois são essencialmente diferentes: a palavra-chave assert destina-se a ser usada ao testar e depurar o programa, mas se você acidentalmente usar assert para controlar o processo de negócios do programa, ele não será usado durante o teste e depuração. Remover a palavra-chave assert após a conclusão significa modificar a lógica normal do programa.
3. Se a afirmação falhar, o programa será encerrado. Isso nunca seria tolerado em um ambiente de produção. Erros potenciais no programa geralmente são resolvidos através do tratamento de exceções. Mas usar asserções é muito perigoso. Se falhar, o sistema irá travar.
5. Reflexões sobre afirmação
Como assert é para depuração de programas de teste e não para uso em ambientes formais de produção, você deve considerar testar melhor o JUint para substituir sua função. O JUint fornece ainda mais funções importantes do que assert. Obviamente, a depuração e o teste podem ser realizados por meio de depuração IDE. Deste ponto de vista, o futuro da afirmação é sombrio.
Portanto, você deve evitar usar a palavra-chave assert em Java, a menos que um dia o Java suporte a opção -ea por padrão, então você pode considerá-la. Compare quantos benefícios e quantos problemas o assert pode trazer para você. Este é o princípio para escolhermos se vamos usá-lo.
================================================= ==========
comentário:
Por outro lado, em alguns componentes de código aberto, como validador e junit, o processo de julgamento parece usar um estilo de asserção. É muito provável que um grande número de asserções seja usado, mas o autor não pode ter certeza antes de olhar para o. código fonte.
Se for um teste simples durante a fase de desenvolvimento, o junit é uma ferramenta conveniente e poderosa. Não há razão para não usá-lo ao escrever suas próprias asserções.
================================================= ==========
comentário:
Primeiro, ele pode ser usado no código de teste de unidade. Junit é muito intrusivo. Se uma grande quantidade de código em todo o projeto usar Junit, será difícil removê-lo ou escolher outra estrutura. Se houver muitos códigos de teste de unidade e você quiser reutilizar esses casos de teste de unidade, escolha assert em vez de junit para facilitar o uso de outras estruturas de teste de unidade, como TestNG. Pela mesma razão, Junit não deveria aparecer no código funcional formal e assert deveria ser usado.
assert é adequado principalmente para classes base, classes de estrutura, classes de interface, classes de código principal e classes de ferramentas. Em outras palavras, é necessário utilizá-lo quando o chamador do seu código for um código de negócio escrito por outro programador, ou outro subsistema. Por exemplo, se você criar um algoritmo de classificação rápida
Copie o código do código da seguinte forma:
public static List<int> quickSort(List<int> lista){
lista de declarações! = nulo;
//Inscreva-se para espaço temporário
//Começa a ordenar
for(int i:lista){
//
}
}
Nesse caso, se a exatidão dos parâmetros recebidos não for verificada, um erro inexplicável de ponteiro nulo será lançado. Seus chamadores podem não saber os detalhes do seu código, e depurar um erro de ponteiro nulo profundamente em um sistema é uma perda de tempo. Você deve informar direta e claramente ao chamador que há um problema com os parâmetros passados. Caso contrário, ele suspeitará que seu código tem um BUG. Usar assert pode evitar que dois programadores se culpem por problemas com o código que escreveram.
assert se aplica a erros que você sabe exatamente qual é o erro e você e seu chamador concordaram que seu chamador deve eliminar ou verificar se há erros. Você conta ao seu chamador por meio de uma afirmação. assert não se aplica a erros causados por sistemas externos, como erros nos dados de entrada do usuário ou erros de formato em um arquivo externo. Esses erros não são causados pelo seu chamador, mas pelo usuário, e nem são exceções, pois erros de entrada e erros de formato de arquivo são comuns e esses erros devem ser verificados pelo código comercial.
assert é mais adequado para classes base, código de estrutura, classes de ferramentas, código principal e código de interface chamados com frequência. O código de teste deve ativar o parâmetro -ea durante a fase de teste para facilitar o teste cuidadoso do código principal no sistema.
A razão pela qual Java usa assert com menos frequência é que Java tem um sistema OO muito completo e a conversão forçada de tipo ocorre com menos frequência, portanto, não há necessidade de verificar frequentemente se o tipo do ponteiro está correto e se o ponteiro está vazio como C. Ao mesmo tempo, Java raramente gerencia memória ou buffers diretamente, portanto, não há necessidade de verificar frequentemente se o buffer de entrada está vazio ou ultrapassou o limite.
Mas usar bem o assert pode ajudar a melhorar a correção do código da estrutura e reduzir o tempo de depuração dos usuários do código da estrutura.
================================================= =============
comentário:
O objetivo do assert é permitir que os programadores descubram facilmente seus próprios erros lógicos sem afetar a eficiência do programa. Os erros encontrados por assert não devem ocorrer e não podem ser substituídos por exceções. Exceções são permitidas pelo sistema, ou são “erros” incontroláveis pelo sistema. Não são problemas lógicos do programador.
assert deve ser ativado durante o desenvolvimento e desativado após o lançamento.