terça-feira, 4 de outubro de 2011

Validando o CNPJ em uma Aplicação Java

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úmero14.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 1º 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:
100075427541
XXXXXXXXXXXX
234567892345
2000423532181415165soma 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 2º 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:
8100075427541
XXXXXXXXXXXXX
2345678923456
16300049403642120206soma 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".

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
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 "try– catch" 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.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
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 1foram 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.

Fonte:DevMedia
Postado por às

Nenhum comentário:

Postar um comentário

Assinar: Postar comentários (Atom)