Artigos Java Assertivas Java: Desmistificando a Certificação SCJP6 Parte IX - Parte 3

Assertivas

Avalie o seguinte exemplo.


        private void doSomething(int num){

        if(num>=0){

        //fazer algo

        }else{

        System.out.println("Número negativo: "+num);

        }

        }

Vamos reescrever o doSomething() do exemplo acima.


        package br.com.devmedia;

        public class AssertExemplo {

        private static void doSomething(int num){

        assert(num>=0);

        }

        /**

        * @param args

        */

        public static void main(String[] args) {

        metodoA(99);

        metodoA(-22);// lança um AssertionError

        }

        }

As assertivas trabalham de modo bastante simples. Você sempre vai assumir que algo é verdadeiro e, se realmente for, não ocorrerá problemas. Nesse caso o código continuará a ser executado adequadamente.

Porém, se sua assertiva se mostrar incorreta (false), então será lançado um AssertionException, que você não deve manipular. Sendo assim, você pode corrigir a falha na lógica que levou a falha. Vejamos um primeiro código: 


        private void fazerAlgumaCoisa(){

        assert(a>b);

        //código executado, admitindo que a seja maior do que b

        }

No código acima, se a não for maior que b e as assertivas estiverem habilitadas, então um erro será gerado. Esse erro facilitará a compreensão do que houve. O exemplo abaixo usa um mecanismo de assertivas um pouco mais sofisticado. 


        private void fazerAlgumaCoisa(){

        assert(a>b):”A: ”+a+” B: ”+b;

        }

Habitualmente, as assertivas são ativadas quando um programa é depurado e testado e são desativadas quando é distribuído. Elas ainda estarão no código, embora sejam desprezadas pela JVM, desse modo se você tiver um programa distribuído que comece a apresentar um comportamento inadequado, sempre poderá ter como opção ativar as assertivas para testes adicionais.

Para utilização das assertivas, primeiramente é necessário saber como realizar a compilação com elas presentes no seu código e como será a execução com as assertivas ativadas.

As duas situações requerem (no mínimo) a versão 1.4 ou superior e isso nos leva ao primeiro problema. Antes da versão 1.4 o exemplo abaixo poderia ser escrito sem nenhum problema. 


        int assert = getValue();

        if(assert == getFinalResult ()) {

        //código

        }

Note que, nesse código, assert é utilizado como um identificador. Ao invés de assert poderíamos ter colocado qualquer identificador válido. Isso não é problema antes da 1.4, devido a assert ainda não ser uma palavra-chave.

No que se refere a prova, você sempre usará a versão 5. O compilador Java 5 utilizará a palavra-reservada assert por padrão.

Uma ocasião que for escrito um código que reconheça suas assertivas, ou seja, um código que entenda assert como uma palavra-chave para realmente executar as assertivas em tempo de execução, você poderá optar por ativá-las ou desativá-las. Não se esqueça que as assertivas vêm desativadas por default. 


        Ativar: java –ea br.com.devmedia.SuaClass

        ou: java –enableassertions br.com.devmedia.SuaClass

        Desativar: java –da br.com.devmedia.SuaClass

        ou: java –disableassertions br.com.devmedia.SuaClass

Na maioria das vezes, você não irá querer um código de acesso público que somente funcione condicionalmente, dependendo das assertivas estarem ou não ativadas. Se você tiver que fazer a validação de argumentos de métodos public, poderá utilizar exceções para lançar, digamos uma IllegalArgumentException se os valores passados ao método não forem apropriados.

Ao fazer um método private, é quase certo que tenha escrito, ou que controle, todos os códigos que o invocarão. Quando quiser prever que a lógica que invoca seu método private está certa, poderá avaliar essa suposição com uma instrução assert.

Na próxima parte desse artigo, testaremos nosso conhecimento aplicando um mini-teste

Leia todos artigos da série