A CONTA DE LUZ

A conta de luz é dada por uma fórmula meio enrolada. mas basicamente o valor do valorCobrado   e o valorAneel mantem uma relação de forma que é regressivva dada por:

valorAnnel=(1-+imposto)*valorCobrado

Pode ser estranha, mas essa é a regra:

Para a conta exemplo , exibida abaixo siga os mesmos passos da iamgem com fundo verde e comprove

imposto=(cofins+pis+imcs)/100;

valorCobrado=valorAneel/(1-imposto)

contaDaLuz=energia*valorCobrado;

pisCobrado=pis*cantaDaLuz/100;

cofinsCobrado=cofins*contaDaLuz/100;

icmsCobrado=icms*contaDaLuz/100;

Para codifica r no Bean crie as propriedade necessárias e os métodos necessários para produzir na tela os valores tal exibido na figura 2 da conta de luz.

Nota: Os valores usados na Figura 1 são baseados em outra empresa de Energia de luz, enquanto que a conta da Figura 2 é baseada na companhia de Energia Bandeirante. onde os valores do valorAneel é diferente.

Figura 1-  Exemplo de Cálculo

Figura 2- Conta de Luz

O CÓDIGO DA CONTA DA ÁGUA COMENTADO

Para  que o arquivo do JavaBean podemos adicionar a funcionalidade de cálculo do valor da conta de água, simplesmente adicionando a propriedade contaDaAgua.
Após adicionar essa propriedade inserimos o método getter, no caso getContaDaAgua.
Dentro do método getContaDaAgua  codificamos a lógica necessária para a cobrança da água  conforme a faixa de consumo.
Nesta lógica, basicamente usamos estruturas de decisão que verifica em qual faixa se encaixa o consumo do consumidor, e aplica-se a regra correspondente.
Note que a condição para verificar se o consumo de água está entre o) e 10 metros cúbicos é diferente da forma como encontramos na Matemática, em vez de if(0<=agua<=10), em linguagem de programação usamos if(agua>=0&&agua<=10) onde os dois &(e comercial) são usados para garantir se as duas condições são satisfeitas.
Quando as duas condições são satisfeita, então o código entre as chaves é executado, e não é executado mais nenhum teste, apenas a linha do return, que retorna o valor da conta da água.
Quando as duas condições não satisfeitas, então é executado um else if que verifica se o consumo esta dentro da segunda faixa de 10 até  20 metros cúbicos e procede de forma similar ao anterior.
Esse mesmo procedimento é usado para a faixa de 20 até 50 metros cúbicos.
Quando falha todos os testes então é executado apenas um else, que implicitamente  significa se todas regras falharam então se aplica essa última regra, no caso quando o consumo está acima de 50 metros cúbicos.

Figura 1- Código do método getContaDaAgua

Se analisarmos o cálculo  para cada faixa, notamos que a cada faixa acrescentada, a anterior é mantida com o valor máximo da faixa.

            contaDaAgua = 13.06;

          contaDaAgua = 13.06 + 2.04 *(agua - 10) ;

          contaDaAgua = 13.06 + 2.04*10                 + 5.09*(agua - 20) ;

          contaDaAgua = 13.06 + 2.04* 10                + 5.09* 10                  +5.61* (agua - 50);

EXERCÍCIO DAS CONTAS - CONTA DA ÁGUA

Como nós  temos 3 arquivos:

1. Formulário que captura as informações do usuáriO
2. Um JavaBean que responsável por receber os dados vindo do formulário
3. Um  página jsp  responsável por calcular e exibir os resultados.

Basta agora inserirmos uma propriedade denominada contaDaAgua para representar o valor da conta de água a ser paga.

Como  a conta de água pode ter número quebrado, então devemos declará-la como do tipo Double.

Como a conta de água não pode ser setada, apenas calculada para essa propriedade devemos ter somente o mtodo getter.

Dentro do método getter devemos implementar a lógica necessária para o cálculo do valor da conta a ser paga baseado nas regras definidas pelas empresas ou similares.

Como exemplo, segue abaixo  uma conta mensal com 4 faixas de consumo:

  

Por exemplo, para um consumo de 22 m³, na categoria residencial normal, na Região Metropolitana de São Paulo, a cobrança será calculada da seguinte forma:

Faixas de consumo	Valor cobrado em m³	m³ cobrados/faixa	Valor água	Valor esgoto	Total
0 a 10	R$ 13,06	10 (tarifa mínima)	R$ 13,06	R$ 13,06	R$ 26,12
11 a 20	R$ 2,04	10	R$ 20,40	R$ 20,40	R$ 40,80
21 a 50	R$ 5,09	2	R$ 10,18	R$ 10,18	R$ 20,36
Acima de 50	R$ 5,61	0	0	0	0
Total geral da conta					R$ 87,28

Tarifas vigentes a partir de 11 de setembro de 2008

Observação: O serviço de esgotos é cobrado aplicando-se o percentual de 80 ou 100%, dependendo da região, proporcionalmente ao valor da água.

Baseado nestas informações implemente o código necessário para processar os dados lidos e gerar a saída tal como exibido no exemplo.

EXERCÍCIO DAS CONTAS - CALCULA.JSP

Crie uma página jsp com o código abaixo e em seguida rode a aplicação;

Note neste código que passamos a  usar o bean através da tag <jsp:useBean  />
Essas tags permitem a criação de um bean,setar a  proprieade do bean e obter a propriedade de um bean.
E  tudo isto está disponível  na paleta de componentes do NetBean.

Agora preste a atenção quando arrastar  o elemento para setar a propriedade do bean, automaticamente o NetBeans coloca value como sendo String vazia e isto gera erro, porque o Bean tenta converter a String vazia para double. Por isto você deve editar manualmente este atributo da tag <jsp:setProperty manualmente. Basta apagar o atributo. Quando a página for chamada pelo formulário, automaticamente o valor da caixa de texto do formulário será atribuído ao Bean.
No entanto para garantir essa última característica, lembre-se de criar um bean com as propriedades com os mesmos nomes  dos formulários.

<%--
    Document   : calcula
    Created on : 17/03/2011, 11:07:41
    Author     : Leonardo
--%>

<%@page contentType="text/html" pageEncoding="UTF-8"%>
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"
   "http://www.w3.org/TR/html4/loose.dtd">

<html>
    <head>
        <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
        <title>JSP Page</title>
        <jsp:useBean id="meuBean" scope="page" class="beans.BeanConta" />
    
        <jsp:setProperty name="meuBean" property="agua"  />
        <jsp:setProperty name="meuBean" property="energia"  />
        <jsp:setProperty name="meuBean" property="tipo"  />
    </head>
    <body>
        <h1>Hello World!</h1>
        <jsp:getProperty name="meuBean" property="agua" />
        <jsp:getProperty name="meuBean" property="energia" />
        <jsp:getProperty name="meuBean" property="tipo" />
    </body>
</html>

EXERCÍCIO DAS CONTAS - JAVABEANS BÁSICO

Crie uma classe Javabean no pacote beans com o código abaixo::

No NetBeans  basta criar a classe  e declarar as três propriedades agua, energia e tipo . Após fazer pedir para inseir código do tipo getter e setter para cada propriedade e você terá os métodos de acesso e modificadores de cada propriedade.

/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */

package beans;

/**
 *
 * @author Leonardo
 */
public class BeanConta {
    public double agua;
    public double energia;
    public String tipo;

    public String getTipo() {
        return tipo;
    }

    public void setTipo(String tipo) {
        this.tipo = tipo;
    }

    public double getAgua() {
        return agua;
    }

    public void setAgua(double agua) {
        this.agua = agua;
    }

    public double getEnergia() {
        return energia;
    }

    public void setEnergia(double energia) {
        this.energia = energia;
    }


}

EXERCÍCIO DAS CONTAS -FORMULÁRIO

Crie uma aplicação Web no NetBeans com um formulário como abaixo:


<%--
    Document   : novaconta
    Created on : 17/03/2011, 11:03:15
    Author     : Leonardo
--%>

<%@page contentType="text/html" pageEncoding="UTF-8"%>
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"
   "http://www.w3.org/TR/html4/loose.dtd">

<html>
    <head>
        <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
        <title>JSP Page</title>
    </head>
    <body>
         <h1>Prencha os dados</h1>
          <form name="form1" method="get" action="calcula.jsp">
            <p>
              <label><strong>Consumo de agua</strong>
              <input name="agua" type="text" id="agua" value="300.0" size="25">
              </label>
            </p>
            <p>
              <label><strong>Consumo de Energia Elétrica </strong>
              <input name="energia" type="text" id="energia" value="330.0" size="25">
              </label>
            </p>
            <p>Conta:<label>
              <input name="tipo" type="radio" id="conta_0" value="social" >
Social</label>
              <label>
              <input type="radio" name="tipo" value="padrao" id="conta_1" checked>
              Padr?o</label>
              <br>
            </p>
            <p>
              <label></label>
              <input type="submit" name="Calcular" id="Calcular" value="Submit">
            </p>
            <label></label>
          </form>
      
    </body>
</html>

Neste código vale observar o input do tipo radio, onde  cada elemento tem um id diferente, mas o atributo name tem o mesmo valor para ambos. Fazendo desta forma garante que os dois sejam tratados  como um grupo de botão de radio.
Note também que um dos valores tem o atributo checked. Isto garante que esta opção será exibida como selecionada quando a página for aberta.
Um grupo de botão de radio permite que o usuário selecione um opção entre várias.

A LÓGICA DO JAVA

Enquanto que o C# usa uma classe Convert uqe dispõe de vários métodos de conversão tais como toInt,toString,toDouble; a linguagem Java usa outra lógica.

Na linguagem Java, quando se quer converter para double chama-se a classe Double que tem os métodos de conversão, no caso parseDouble.

Se for converter para inteiro usa-se a classe Integer e acessa o método parseInt.

Se for converter para String usa-se a classe String e acessa o método valueOf.

Portanto a Linguagem Java usa uma classe para tipo de dado, enquanto a Linguagem C# uma classe para várias conversões.

Outra coisa, as classes também tem métodos para outras coisas além de conversão.

Exemplo a classe Character tem o método isDigit que verifica se é um dígito.

A classe String te o método isEmpty que verifica se uma String é vazia.

VALIDAÇÃO DE CPF -MÉTODO AUXILIAR: validaDigitosVerificadores

Este método tem por objetivo receber o CPF como String  e devolver  true se o CPF for válido e false  caso contrário.

Para realizar essa tarefa é necessário realizar o algoritmo correspondente.

Basicamente o método  lê como char cada dígito  individualmente através do método charAt(i)   da classe String  e em seguida  converte cada caractere para String. Novamente cada caractere é convertido para inteiro usando o método parseInt(aux1) da classe Integer.

Convertido em número o dígito é multiplicado por (10 –i). Na primeira rodada da repetição vale 0, portanto o dígito é multiplicado por 10.  O resultado é então somado ao valor da soma1. Na primeira rodada, soma1 vale 0, portanto em soma1 é guardado o valor 10, já que o dígito vale 1,

Para soma2 é similar exceto que é multiplicado por 11 em vez de 10, portanto é armazenado o valor 11 em soma2.

Na segunda rodada se repete o procedimento, exceto que agora soma1 e soma2 já tem o valor anterior  diferente de zero.

Esse processo se repete até varrer todos os dígitos.

Após isto, o método getDigito é chamado para calcular o valor do dígito verificador 1.

De posse do dígito verificador 1, o valor da soma2 é alterado de forma a  incluir o valor  do produto de div1*2 conforme solicitado no algoritmo. Ou seja o valor da soma2 depende do valor do dígito verificador 1.

Com o valor da soma2 pronto, o método getDigito é chamado novamente para calcular o dígito verificador 2.

De posse dos valores dos dígitos verificadores 1 e 2 ,basta comparar os valores calculado com os valores lidos. Se forem iguais, o método devolve true. Caso contrário , devolve fase.

Para  acessar o valor do dígito verificador 1  e 2 lidos , veja que foi usado uma linha de código que faz várias operações simultaneamente:

int div1Lido= Integer.parseInt(String.valueOf(str.charAt(10)));

onde charAt(10) acessa o caractere na posição 10 da String, ou seja o div1.

String.valueOf converte o  tipo char para String.

Integer.parseInt converte o  tipo String  para inteiro.

O sinal de =  atribui  o resultado à variável div1Lido.

Int define o tipo de dado, no caso inteiro.

VALIDAÇÃO DE CPF-CALCULO DO DÍGITO VERIFICADOR

Este método recebe a soma e  devolve o valor do dígito verificador.
Se o resto da divisão da soma por 11 for igual a 0 ou 1 então
       O dígito verificador vale 0
Caso contrário
       O dígito verificador vale 11 menos o resto

Figura 1- Código do getDígito

VALIDAÇÃO DE CPF -ESCRITA NA TELA

VALIDAÇÃO DE CPF -MÉTODO AUXILIAR-hasOnlyNumber

O método  hasOnlyNumber  tem a s seguintes características:

Nome do Método	hasOnlyNumber
Argumento ou parâmetro	String  str	É o que está colocado entre os parêntesis
Processamento	Todo código colocado entre as chaves
Tipo de retorno	boolean	Colocado antes do nome do método
Nível de acesso	public	Permite acesso geral, dentro da classe e fora da classe
Assinatura do Método	A primeira linha de código do método	public String hasOnlyNUmer(String str)

Este método tem por objetivo retornar false caso o usuário tenha digitado letra no lugar de número ou não tenha colocado o traço ou o ponto antes dos dígitos verificadores.

Este método declara a  variável hasOnlyNumber do tipo Boolean e atribui  o valor false como valor inicial.

Em seguida, através da estrutura de repetição  baseada no for  verifica se cada caractere digitado   trata-se de um dígito número, exceto o traço.

Assim o for declara i do tipo inteiro  com valor inicial em 0.

Na primeira vez que o código dentro do  for executado, i vale 0, de forma o código dentro do IF é executado,  pois  0 é diferente de 9.

  

Dentro do IF , o método isDigit  da classe Character é responsável por verificar se o caractere trata-se de um dígito numérico. Se for dígito numérico, então a variável hasOnlyNumber recebe  true, caso contrário recebe false.

O segundo IF dentro do primeiro IF é responsável por parar a repetição do for caso hasOnlyNumber receba um false. Ou seja, se ao fazer a varredura e encontrar qualquer coisa diferente de um dígito numérico, a repetição é interrompida pelo break  e a linha de código  return hasOnlyNumber é executada.

Para cada valor de i esse processo se repete, até encontre um false ou até todos os caracteres tenham sido varridos.

Para o valor de i igual a 9 corresponde ao momento em que se está acessando  o traço ou o ponto que separa os dígitos verificadores. Neste momento, o código dentro do else  passa a ser executado.

Dentro do código do else é verificado se existe um traço ou um ponto antes dos dígitos verificadores.  Caso isso ocorra, a repetição é interrompida, e o método retorna false.

VALIDAÇÃO DE CPF - PROCESSAMENTO

O processamento verifica se a caixa de texto está vazia ou tem  números misturados com letras então:

            É solicitado ao usuário para digitar um CPF  no formato correto

caso contrário

          Se o CPF for válido então

                  Confirma que o CPF é válido

          Caso contrário

                  Informa que se trata um CPF inválido

VALIDAÇÃO DO CPF - LEITURA

A leitura dos dados dos formulário, simplesmente basta usar o método request.getParameter("cpf"). O único ponto que merece destaque corresponde ao arguento recebido pelo método. Esse argumento deve ter o mesmo nome da caixa de texto colocada no formulário, colocado entre aspas duplas.

Outro fato, se refere ao tipo de dado lido. No caso  String, portanto a variável que recebe o dado lido é declarada do tipo String .

A variável do tipo String msg será usada par armazenar a mensagem, se o o CPF é válidoou não.

VALIDAÇÃO DE CPF - PROCESSANDO A VALIDAÇÃO

A página cpf-recebe.jsp  será analisada por partes. Clique na Figura para ver a imagem ampliada.
Basicamente temos três partes:

1. Leitura dos dados do formulário. No caso apenas o valor digitado do CPF
2. Processamento. No caso   realizar o processo de validação do CPF. Esta parte está embutida a chamada dos métodos auxiliares
1. getDigito
2. validaDigitosVerificadores
3. hasOnlyNumber
3. Escrita na Tela . Após o obter os resultado, exibí-los na tela

VALIDAÇÃO DO CPF - -FORMULÁRIO

Abaixo segue o código do arquivo cpf-formulario.jsp que tem apenas umm formulário com uma caixa de texto e um botão submit.
Observe que a tag form define o atributo action como sendo cpf-recebe.jsp, portanto os dados serão enviados para esta página.
Como o atributo method não está explícito, vale a regra: todo atributo não explicitado usa o valor padrão. Nesse caso o valor padrão corresponde ao método GET. Ou seja, nesse caso os dados serão enviados anexados ao final da URL na barra de endereço.




<%@page contentType="text/html" pageEncoding="UTF-8"%>
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"
"http://www.w3.org/TR/html4/loose.dtd">

<html>
    <head>
        <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
        <title>Valida CPF</title>
    </head>
    <body>
        <center>
        <h1>Validação de CPF</h1>
        <form name="f1" action="cpf-recebe.jsp">
            CPF:<input type="text" name="cpf" value="123456789-09" />
            <input type="submit" value="Validar" />
        </form>
        </center>
    </body>
</html>

Validação de CPF

A validação de CPF verifica apenas se os dois dígitos finais  são válidos  quando verificados de acordo com a regra de definição dos seus valores. Em outras palavras, os dois dígitos finais dependem dos outros dígitos.

Para exemplificar usaremos o CPF 123456789-09.

Cálculo do Dígito Verificador  1(Div1):

1)Basta fazermos as seguintes operações:
soma=1*10+2*9+3*8+4*7+5*6+6*5+ 7*4+8*3+9*2=210

2)Calcular o resto da divisão por 11:   resto=mod(soma/11)=210%11=1

Lembre-se calcular o resto da divisão usa-se mod no Excel e % na lIngaugem Java

3) Aplica a regra:
Se o resto  for menor que 2 então{
           o dígito verificador 1 é 0
}
Caso contrário{
           o dígito verificador é igual a (11-resto)
}

Portanto Div1=0 pois o resto é menor que 2

          

Cálculo do Dígito Verificador  2 ( Div2):

1)Basta fazermos as seguintes operações:

soma=1*11+2*10+3*9+4*8+5*7+6*6+ 7*5+8*4+9*3 +div1*2=210

2)Calcular o resto da divisão por 11:   resto=mod(soma/11)=210%11=1

Lembre-se calcular o resto da divisão usa-se mod no Excel e % na lIngaugem Java

3)Aplique a regra:

 Se o resto  for menor que 2 então{

           o dígito verificador 1 é 0

}

Caso contrário{

           o dígito verificador é igual a (11-resto)

}

         

Portanto Div2=11-2=9 pois o resto não é menor que 2