Validando Cartão de Crédito, CPF e CNPJ
Neste trabalho é apresentada uma aplicação que faz a escolha da validação entre um numero de Cartão de Credito ou de CPF ou de CNPJ. Estes algoritmos foram adaptados do C# para J#. Sobre os códigos fontes dois exemplos estão no livro “Dominando o Visual Studio.Net com C#” para a validação do CPF e CNPJ, a validação do cartão é codificação própria com base na exemplo do livro “” e o procedimento que filtra apenas os números foi baseado num método que é utilizado para retirar acentos nas palavras.
Para começar abra uma nova windows application em J#, no form1 será utilizado dois textbox, dois buttons, um groupbox, três radiobuttons.
O form1 terá a aparência da figura abaixo:
Figura 1.
Nas propriedades dos componentes serão feitas as seguintes alterações:
Button1 |
Button2 |
GroupBox1 | |||
Name: |
btnValidar |
Name: |
btnSair |
Name: |
gpbTipo |
Text: |
Validar |
Text: |
Sair |
Text: |
Tipos de Validações |
Font.Bold: |
true |
Font.Bold: |
true |
Font.Bold: |
true |
Font.Size: |
10 |
Font.Size: |
10 |
|
|
BackColor |
ActiveCaption |
BackColor |
ActiveCaption |
|
|
RadioButton1 |
RadioButton2 |
RadioButton3 | |||
Name: |
rdgCartao |
Name: |
rdgCPF |
Name: |
rdgCNPJ |
Text: |
NºCartão |
Text: |
NºCPF |
Text: |
NºCNPJ |
Font.Bold: |
true |
Font.Bold: |
true |
Font.Bold: |
true |
Label1 | |
Name: |
lblTipo |
Text: |
Insira o número do cartão |
Font.Bold: |
true |
Font.Size |
12 |
Como a aplicação irá trabalhar com números ela precisa de um filtro que retire todos os caracteres que não sejam números para isso e feito o método que recebe o valor da caixa de texto retorne os números da seqüência se caracteres digitados no campo. Neste código uma variável String recebe uma seqüência de números “0123456789” que serão comparados um a um com a seqüência da caixa de texto. O método “Números” vai receber o que foi digitado e retornará com apenas números eliminado espaços e/ou outros caráteres que não sejam numéricos.
public static String Numeros(String n)
{
String lnNova = "";
String soNumero = "0123456789";
for (int i=0;i<=n.length()-1;i++)
{
Item = n.substring(i,i+1);
for (int j=0;j<=soNumero.length()-1;j++)
{
if (soNumero.substring(j,j+1) == item)
{
//Se for um numero item recebe o caracter
Item = n.substring(j,j+1) + lnNova;
}
}
}
//Retorna a nova linha
return lnNova;
}
Nota: O método do substring() no J# que está sendo utilizado tem outro processo para copiar o trecho de uma string ele usa o primeiro índice para o inicio e o segundo com + 1 para a quantidade a ser copiada diferente no uso do C# que seria o índice para indicar o inicio do caracter e é estipulado o tamanho para a copia.
Em seguida ao método Números,construiremos três outros métodos: ValidaCartao,ValidaCPF e ValidaCNPJ .
1º Método
Validar o nº. de cartão de crédito. O Algoritmo deste método verifica o último dígito para detectar erros. Neste método serão verificadas duas quantidades de dígitos, uma com 15 e outra com 16 dígitos. E cada dígito será multiplicado por 1 ou 2 numa seqüência.
Ex: 1,2,1,2,1,2.
Para cartões com 15 dígitos a seqüência começa por 1 e os de 16 por 2. Os resultados serão somados e divididos por 10 se o resultado for 0 o número do cartão digitado e válido.
public void ValidaCartao()
{
// Aqui é utilizado o procedimento Números mostrado anterior-
//mente
String numCartao = Numeros(txtNumCartao.get_Text());
String numString;
int soma = 0;
//Cartão com seqüências de caracteres menor ou igual a 15 dígitos
if (numCartao.length() <= 15)
{
for(int i = 0; i <= numCartao.length(); i++)
{
numString = (numCartao.substring(i,i+1));
if (i % 2 == 0)
{
Soma += (Integer.parseInt(numString) * 1);
}
else
{
if ((Integer.parseInt(numString) * 2) > 9)
{
Soma += ((Integer.parseInt(numString) * 2) - 9);
}
else
{
Soma += ((Integer.parseInt(numString) * 2));
}
}
}
}
//Cartão com seqüências de caracteres maior ou igual a 16 dígitos
if (numCartao.length() >= 16)
{
for(int i = 0; i <= numCartao.length(); i++)
{
numString = (numCartao.substring(i,i+1));
if (i % 2 == 0)
{
if ((Integer.parseInt(numString) * 2) > 9)
{
Soma += ((Integer.parseInt(numString) * 2) - 9);
}
else
{
Soma += ((Integer.parseInt(numString) * 2));
}
}
else
{
Soma +=(Integer.parseInt(numString) * 1);
}
}
}
if (soma % 10 == 0)
{
txtStatus.set_Text("Cartão valido!");
}
else
{
txtStatus.set_Text("Cartão invalido!");
}
}
Nota: Para converter o número em string para o valor interior pode utilizar a função do Java Integer.parseInt() . Tendo então a possibilidade de usar os recursos do Framework.NET e do JDK numa mesma aplicação.
2° Método
Validar o n°. do CPF. O CPF é composto por uma seqüência de 11 dígitos,sendo os dois últimos para verificar a validade. Na estrutura do algoritmo é somado o resultado da multiplicação dos 9 primeiros dígitos.
Esta multiplicação é feita decrescente “10,9,8,7....”.
Tendo a seguinte formula:
Soma = (1°digito * 10) + (2°digito * 9) + (3°digito * 8) ... até o último dígito.
Com a soma é dividida por 11 e multiplicada por 11 e no final subtrai-se o resultado pela soma e se o resultado for igual a 0 o CPF validado.
public void ValidaCPF()
{
String CPF = Numeros(txtNumCartao.get_Text());
String numString = "";
int soma = 0;
int resultado = 0;
for (int i = 0;i < 9;i++)
{
numString = (CPF.substring(i,i+1));
soma += (Integer.parseInt(numString)*(10 -i));
}
Resultado = (11 - (soma% 11));
if (resultado == 10 || resultado == 11)
{
Resultado = 0;
}
if (resultado != Integer.parseInt(CPF.substring(9,10)))
{
txtStatus.set_Text("CPF invalido!");
txtNumCartao.Clear();
txtNumCartao.Focus();
}
Soma = 0;
for (int i = 0;i < 10; i++)
{
numString = (CPF.substring(i,i+1));
soma = (Integer.parseInt(numString) * (11 -i));
}
Resultado = (11 - (soma % 11));
if (resultado == 10 || resultado == 11)
{
Resultado = 0;
}
if (resultado != Integer.parseInt(CPF.substring(10,11)))
{
txtStatus.set_Text("CPF invalido!");
txtNumCartao.Clear();
txtNumCartao.Focus();
}
txtStatus.set_Text("CPF valido!");
}
3° Método
Validar o n°. do CNPJ. O CNPJ ele é composto por 14 dígitos,sendo os dois últimos para verificar. Da mesma forma que o método do CPF é somado o resultado das multiplicações com algumas diferenças. Ao invés de 9 serão 12 e 13 dígitos.
Com os 12 dígitos os cinco primeiros serão multiplicados pela seqüência decrescente começando pelo número 5 e quando chegar ao 1 começa uma nova seqüência que começa pelo número 9. Tendo esta formula:
Soma = (1°digito * 5) +(2°digito * 4) + ... + (5°digito * 1) +(6°digito * 9) + (7°digito * 8) + ... até o fim dos 12 digitos.
Em seguida é dividida a soma por 11 e subtraída por 11 se este resultado for maior ou igual a 10 uma variável recebe 0 senão a variável recebe o resultado anterior.
E com os 13 dígitos os cinco primeiros serão multiplicados pela seqüência decrescente que começa com o número 6 e quando chegar ao 1 começa uma nova seqüência que começa pelo número 9. Em seguida se faz o mesmo calculo com a divisão por 11 e a subtração e outra uma variável recebe 0 se for maior ou igual a 10 ou o resultado do cálculo.
Depois e verificada a variavel1 pelo penúltimo digito e a variável2 pelo ultimo digito se as variáveis for iguais aos dígitos o CNPJ é validado.
public void ValidaCNPJ()
{
String CNPJ = Numeros(txtNumCartao.get_Text());
String numString = "";
int soma = 0;
int mult = 5;
int resultado = 0;
if (CNPJ.length() != 14)
{
txtStatus.set_Text("Número inválido!");
txtNumCartao.Clear();
txtNumCartao.Focus();
}
for(int i =0;i<12;i++)
{
numString = (CNPJ.substring(i,i+1));
soma += (Integer.parseInt(numString) * mult--);
if (mult == 1)
{
Mult = 9;
}
}
resultado = (11 - (soma % 11));
if (resultado >= 10);
{
Resultado = 0;
}
int rest1 = resultado;
soma = 0;
mult = 6;
for(int i =0;i<13;i++)
{
numString = (CNPJ.substring(i,i+1));
soma += (Integer.parseInt(numString) * mult--);
if (mult == 1)
{
Mult = 9;
}
}
resultado = (11 - (soma % 11));
if (resultado >= 10);
{
Resultado = 0;
}
int rest2 = resultado;
//Os dois ultimos digitos são verificados
int digito1 = Integer.parseInt(CNPJ.substring(12,13));
int digito2 = Integer.parseInt(CNPJ.substring(13,14));
if (rest1 == digito1 && rest2 == digito2)
{
//Retorna o alerta na textbox de Status
txtStatus.set_Text("CPF valido!");
txtNumCartao.Clear();
txtNumCartao.Focus();
}
else
{
//Retorna o alerta na textbox de Status
txtStatus.set_Text("CPF invalido!");
txtNumCartao.Clear();
txtNumCartao.Focus();
}
}
Ao fim da construção dos métodos de validação será feito o processo para chamar cada método de acordo com a escolha. Declare uma variável inteira neste ponto da estrutura.
public static void main(String[] args)
{
Application.Run(new Form1());
}
public static int csTipo;
No eventos de cada radiobutton declare o seguinte:
No rdgCartao duplo clique e digite:
lblTipo.set_Text("Insira o número do cartão:");
csTipo = 0;
No rdgCPF:
lblTipo.set_Text("Insira o número do CPF:");
csTipo = 1;
No rdgCNPJ:
lblTipo.set_Text("Insira o número do CNPJ:");
csTipo = 2;
De um clique duplo no botão de validação e faça esta estrutura.
//Conforme o item selecionado é utilizado o procedimento para //validar
switch (csTipo)
{
case 0:
ValidaCartao();
break;
case 1:
ValidaCPF();
break;
case 2:
ValidaCNPJ();
break;
}
E para o botão de sair:
Application.Exit();
Finalmente concluímos a aplicação.
Conclusão
Os J# tem a agilidade de construir aplicações utilizando recursos do Java e do .NET na construção de uma aplicação. Para aqueles que têm o conhecimento em Java ou no C# é uma excelente ferramenta.