Cadastro Nacional da Pessoa Jurídica (CNPJ)
Este artigo apresenta como é realizada a validação de um número de CNPJ que é o documento de identificação do contribuinte Pessoa Jurídica perante a Receita Federal.

O CNPJ é um número formado por 14 dígitos dos quais os dois últimos são chamados de dígitos verificadores (DV). Cada DV é calculado com base nos dígitos anteriores e juntos servem para validar o número do CNPJ como um todo. Assim, torna-se importante quando um número de CNPJ é digitado pelo usuário final em uma aplicação utilizar o método isCNPJ(), implementado no pacote "meuPacote" apresentado na Listagem 1, para verificar se o número informado está correto evitando, por exemplo, o cadastro de CNPJs inválidos.

Para exemplificar o algoritmo de verificação do CNPJ será utilizado como exemplo o CNPJ número 14.572.457.0001-85.


O cálculo dos DVs é executado em duas etapas usando para isto o módulo de divisão 11 (módulo de divisão é a parte inteira do resultado de uma divisão):

Para calcular o dígito verificador:
a) Cada um dos doze primeiros números do CNPJ, a partir do 12º número até o 1º, é multiplicado por um peso que começa de 2 e que vai sendo incrementado de 1 a cada passo, somando-se as parcelas calculadas. Sempre que o peso atingir o valor 10 ele deve novamente receber o valor inicial 2:
1 0 0 0 7 5 4 2 7 5 4 1  
X X X X X X X X X X X X  
2 3 4 5 6 7 8 9 2 3 4 5  
2 0 0 0 42 35 32 18 14 15 16 5 soma das parcelas = 179
b) calcula-se o dígito através da seguinte expressão:
  179 % 11 = 3
obs. se o resto da divisão (operador %) calculado for 0 ou 1, o dígito verificador será 0; nos outros casos, o dígito verificador é definido pela expressão: 11 - 3 = 8

Para calcular o dígito verificador:
a) Cada um dos treze primeiros números do CNPJ, a partir do primeiro DV (13º número) até o 1º, é multiplicado por um peso que começa de 2 e que vai sendo incrementado de 1 a cada passo, somando-se as parcelas calculadas. Sempre que o peso atingir o valor 10 ele deve novamente receber o valor inicial 2:
8 1 0 0 0 7 5 4 2 7 5 4 1  
X X X X X X X X X X X X X  
2 3 4 5 6 7 8 9 2 3 4 5 6  
16 3 0 0 0 49 40 36 4 21 20 20 6 soma das parcelas = 215
b) calcula-se o dígito através da seguinte expressão:
  215 % 11 = 6
obs. se o resto da divisão (operador %) calculado for 0 ou 1, o dígito verificador será 0; nos outros casos, o dígito verificador é definido pela expressão: 11 - 6 = 5

Desenvolvendo a Aplicação Java
Criar um novo projeto no ambiente de desenvolvimento NetBeans através da opção do menu "Arquivo|Novo Projeto..." e realizar os dois passos descritos a seguir:
1º Passo:
Criar um pacote Java e identificá-lo com o nome "meuPacote". No pacote criado implementar a classe Java ValidaCNPJ, mostrada na Listagem 1, com os métodos:
a) isCNPJ()- retorna um valor booleano que indica se o número de CNPJ é válido ou inválido;
b) imprimeCNPJ()- retorna o CNPJ formatado na máscara: 99.999.999.9999-99.


Listagem 1. Classe ValidaCNPJ do pacote "meuPacote".
package meuPacote;

import java.util.InputMismatchException;

public class ValidaCNPJ {

  public static boolean isCNPJ(String CNPJ) {
// considera-se erro CNPJ's formados por uma sequencia de numeros iguais
    if (CNPJ.equals("00000000000000") || CNPJ.equals("11111111111111") ||
        CNPJ.equals("22222222222222") || CNPJ.equals("33333333333333") ||
        CNPJ.equals("44444444444444") || CNPJ.equals("55555555555555") ||
        CNPJ.equals("66666666666666") || CNPJ.equals("77777777777777") ||
        CNPJ.equals("88888888888888") || CNPJ.equals("99999999999999") ||
       (CNPJ.length() != 14))
       return(false);

    char dig13, dig14;
    int sm, i, r, num, peso;

// "try" - protege o código para eventuais erros de conversao de tipo (int)
    try {
// Calculo do 1o. Digito Verificador
      sm = 0;
      peso = 2;
      for (i=11; i>=0; i--) {
// converte o i-ésimo caractere do CNPJ em um número:
// por exemplo, transforma o caractere '0' no inteiro 0
// (48 eh a posição de '0' na tabela ASCII)
        num = (int)(CNPJ.charAt(i) - 48);
        sm = sm + (num * peso);
        peso = peso + 1;
        if (peso == 10)
           peso = 2;
      }

      r = sm % 11;
      if ((r == 0) || (r == 1))
         dig13 = '0';
      else dig13 = (char)((11-r) + 48);

// Calculo do 2o. Digito Verificador
      sm = 0;
      peso = 2;
      for (i=12; i>=0; i--) {
        num = (int)(CNPJ.charAt(i)- 48);
        sm = sm + (num * peso);
        peso = peso + 1;
        if (peso == 10)
           peso = 2;
      }

      r = sm % 11;
      if ((r == 0) || (r == 1))
         dig14 = '0';
      else dig14 = (char)((11-r) + 48);

// Verifica se os dígitos calculados conferem com os dígitos informados.
      if ((dig13 == CNPJ.charAt(12)) && (dig14 == CNPJ.charAt(13)))
         return(true);
      else return(false);
    } catch (InputMismatchException erro) {
        return(false);
    }
  }

  public static String imprimeCNPJ(String CNPJ) {
// máscara do CNPJ: 99.999.999.9999-99
    return(CNPJ.substring(0, 2) + "." + CNPJ.substring(2, 5) + "." +
      CNPJ.substring(5, 8) + "." + CNPJ.substring(8, 12) + "-" +
      CNPJ.substring(12, 14));
  }
}

Na implementação de uma classe ou de um conjunto de classes em um pacote Java o código fonte deve ser iniciado com a diretiva package, seguida do nome do pacote (meuPacote). Um pacote ou package em Java nada mais é do que um conjunto de classes (framework). Usualmente, são colocadas em um package classes relacionadas, construídas com um propósito comum; assim, sob certos aspectos, os packages reproduzem a ideia das bibliotecas de código (libraries e unit's) de outras linguagens de programação.

Outro aspecto destacável da programação foi a utilização da estrutura de controle de erros "trycatch" que irá proteger o código para eventuais erros de conversão de tipo feita pelo operador de coerção (int).

2º Passo:
Implementar a classe principal ExemploCNPJ mostrada na Listagem 2.

Listagem 2. Classe principal da aplicação.
import java.util.Scanner;
// importanto a classe "ValidaCNPJ" do pacote "meuPacote"
import meuPacote.ValidaCNPJ;

public class ExemploCNPJ {

  public static void main(String[] args) {
    Scanner ler = new Scanner(System.in);

    String CNPJ;

    System.out.printf("Informe um CNPJ: ");
    CNPJ = ler.next();

    System.out.printf("\nResultado: ");
// usando os métodos isCNPJ() e imprimeCNPJ() da classe "ValidaCNPJ"
    if (ValidaCNPJ.isCNPJ(CNPJ) == true)
       System.out.printf("%s\n", ValidaCNPJ.imprimeCNPJ(CNPJ));
    else System.out.printf("Erro, CNPJ inválido !!!\n");
  }

}

Alguns aspectos da programação utilizada na classe ValidaCNPJ apresentada na Listagem 1 foram abordados no post:
O que são String em Java: Métodos da Classe String: String em Java - Parte 2.


Veja também: Validando o CPF em uma Aplicação Java.

Testando a execução da aplicação da Listagem 2:
1. CNPJ 44.444.444.4444-44 é inválido:

2. CNPJ é um número formado por 14 dígitos:

3. Existem caracteres alfabéticos no CNPJ:

4. CNPJ informado está correto (ou válido):

Obrigado e um abraço.

Prof. Omero Francisco Bertol (http://www.pb.utfpr.edu.br/omero/)
Aplicações Java (http://www.pb.utfpr.edu.br/omero/Java/Fontes.HTM)
Download do Projeto NetBeans IDE (http://www.pb.utfpr.edu.br/omero/Java/Artigos/Aplicacoes.rar)