Tratamento de OPERADORES MATEMÁTICOS

Prévia do material em texto

______________________________________________________________________________
2.3. Tratamento de Operadores Matemáticos 
2.3.1. Exemplo de Aplicação: Cálculos Matemáticos
 numa Applet - Applet05
2.3. Tratamento de Operadores Matemáticos
No Capítulo anterior – Tratamento de Constantes e Variáveis, você teve noção rápida de alguns operadores matemáticos, incluindo-se entre eles os sinais de multiplicação (*), divisão (/), soma (+) e subtração (-). Você teve chance de usar estes operadores em algumas fórmulas matemáticas. Entretanto há muito mais a ser aprendido a respeito dos operadores matemáticos, como você descobrirá que ler este capítulo. Aqui, você não só aprenderá um número maior de operadores como também aprenderá sobre a precedência dos operadores, a qual determina a ordem na qual as operações são executadas. 
A linguagem de programação Java disponibiliza cinco operadores matemáticos, a saber: operadores aritméticos; operadores de incremento e decremento; operadores binários; operadores lógicos e operadores de atribuição simples e compostos. 
Operadores Aritméticos 
Os operadores aritméticos são apresentados na tabela abaixo:
++ (incremento);
-- (decremento);
* (multiplicação);
/ (divisão);
% (módulo);
+ (adição);
- (subtração).
Nos exemplos a seguir, vários operadores são usados em expressões aritméticas.
a = b + c – d;
e = f / g * h;
Operadores de Incremento e Decremento
Os operadores de incremento e decremento merecem explicação mais detalhada. Estes operadores podem ser pré ou pós-fixados. Um opera​dor pré-fixado atua antes do valor ser usado na expressão, enquanto que um operador pós-fixado atua depois do valor ser usado na expressão. 
No exemplo seguinte, pode-se verificar o código equivalente ao operador de incremento pré e pós-fixado.
 
 Operador Pré-fixado a = ++b + c; equivale a b = b + 1;
 a = b + c; 
 Operador Pós-fixado a = b++ + c; equivale a a = b + c;
 b = b + 1; 
Operadores Binários 
Os operadores binários atuam bit a bit sobre os valores dos operandos, e podem ser dos seguintes tipos:
<< (deslocamento para a esquerda);
>> e >>> (deslocamento para a direita);
& (E);
| (OU);
^ (OU-EXCLUSÃO);
~ (NÃO);
 
A seguir, alguns exemplos de expressões com operadores:
	Expressão
	Significado
	a = b >> 2;
	b desloca dois bits para a direita.
	c = d << 3;
	d desloca três bits para a esquerda.
	g = h & i;
	h E i.
	J = k | 1;
	J OU 1.
Operadores Lógicos
Os operadores lógicos, listados a seguir, possibilitam comparações.
! (NÃO);
< (menor que);
> (maior que);
>= (maior ou igual a);
<= (menor ou igual a);
instanceof (instância de);
== (igual a);
!= (diferente de);
&& (E);
| | (OU).
	Operadores Lógicos 
	Significado
	If (a > b && c < d)
	Se a maior que b e c menor que d.
	If (x == y) 
	Se x igual a y.
	If (z != w)
	Se z diferente de w.
Operadores de Atribuição Simples e Compostos 
Existem operadores de atribuição simples e compostos. O operador de atribuição simples é representado pelo caracter = (igual) e os operadores de atribuição compostos são representados por: +=, -=, *=, /=, %=, >>=, <<=, >>>=, &=, ^=, |=. Observe a seguir, exemplos onde se apresentam expressões com operadores compostos e seus códigos equivalentes.
	Operadores Compostos
	Significado
	x += y;
	Equivale a x = x + y;
	z -= w
	Equivale a z = z – w;
	v *= c + d;
	Equivale a v = v * c + d;
	x /= w – t;
	Equivale a x = x / w – t; 
	t %= e + f;
	Equivale a t = t % e + f 
2.3.1. Exemplo de Aplicação: Cálculos Matemáticos
 numa Applet – Applet05
Quase todos os computadores executam cálculos matemáticos. Para que você possa especificar os tipos de cálculos a serem executados, as linguagens de programação como Java possuem como recurso operadores matemáticos para operações padrões como a adição, subtração, multiplicação e divisão. 
Entretanto, ao usar estes operadores, lembre-se sempre da precedência de operadores (ou ordem das operações) que determina a ordem na qual cálculos são realizados. Assim como, ao efetuar cálculos em programas, normalmente há necessidade de fazer conversões de valores numéricos para string e vice-versa. 
Descrição do Problema
Uma coisa é aprender a respeito dos operadores matemáticos e como eles são usados para efetuar os cálculos. Outra coisa é efetivamente usá-los num programa real. Isto porque, ao efetuar cálculos em programas, como já afirmamos antes, freqüentemente há necessidade de fazer uma série de conversões de valores string para numérico e vice-versa.
Suponha, por exemplo, que você solicite ao usuário um número necessário para efetuar um cálculo. Ao extrair o número do usuário, ele ainda estará na forma de string. Não é possível usar o caractere de texto “3” numa forma numérica. Assim que tivermos todos os valores convertidos para a forma correta (numérica), podemos prosseguir nos cálculos como será visto neste capítulo. Mas o que acontece quando quisermos mostrar as respostas ao usuário do applet? Novamente é necessário fazer a conver​são, desta vez da forma numérica para a de string.
Desenvolva um programa na Linguagem Java que a partir de dois valores fornecidos pelo usuário, realize as conversões necessárias, some esses valores e exiba o resultado na área de trabalho da applet, de acordo com a figura a seguir: 
Para realizar o processamento da Applet05, primeiramente, dê um clique no primeiro componente para lhe dar o foco, delete o seu conteúdo e digite um novo número e tecle em |Tab| para prosseguir no segundo componente. Repita os procedimentos e tecle <Enter> para que a applet some os dois números e exiba o resultado.
Fluxo de Solução do Programa
Informe a Java que o programa usa classes do pacote awt
Informe a Java que o programa usa classes do pacote applet
Defina a classe Applet05 como classe herdeira da classe Applet de Java {
 Declare objetos textFieldl e textField2 da classe TextField
 Sobregrave o método init() da classe Applet p/dispor e inicializar a área de exibição {
 Crie os dois objetos TextField
 Adicione os dois objetos TextField à área de exibição da applet
 Inicialize o conteúdo texto ou string em ambos os objetos TextField com “0” 
 } 
 Sobregrave o método paint() da classe Applet para que as ações se realizem {
 Declare três inteiros chamados valuel, value2 e sum
 Exiba duas strings de texto das mensagens na área de exibição da applet 
 Obtenha o texto do primeiro objeto TextFleld e Converta o texto num inteiro
 Obtenha o texto do segundo objeto TextFleld e Converta o texto num inteiro
 Adicione os dois valores convertidos. 
 Converta a soma numa string.
 Desenhe ou exiba a string de texto sum na superfície da applet
 }
 Sobregrave o método action() da classe Applet {
 Instrua Java a repintar a área de exibição da applet
 Informe a Java que o método action() finalizou com sucesso
 }
}
Criando o Programa no Ambiente JBuilder
import java.awt.*;
import java.applet.*;
public class Applet05 extends Applet {
 TextField valor1;
 TextField valor2;
 public voidinit() {
 // Rótulo, componente e inicialização
 add(new Label("Informe VALOR 1"));
 add(valor1 = new TextField(25));
 valor1.setText("0");
 // Rótulo, componente e inicialização
 add(new Label("Informe VALOR 2"));
 add(valor2 = new TextField(25));
 valor2.setText("0");
 }
public void paint(Graphics g) {
 // Impressão normal
 g.drawString("Digite um número em cada CAIXA", 20, 75);
 // Cálculo de valores
 int sum=Integer.parseInt(valor1.getText())+Integer.parseInt(valor2.getText());
 // Impressão concatenada
 String s="SOMA dos valores = ";
 g.drawString(s+=String.valueOf(sum), 20, 95); // Operador += (s=s+String.valueOf(sum))
 }
public boolean action(Event event, Object arg) {
 repaint();
 return true;
 }
}
Resultado da Execução do Applet05
Entendendo o Funcionamento do Programa
Embora o código-fonte de Applet05 seja um pouco mais longo do que outras applets vistas por você, ela não é, realmente, muito mais complicada que as demais. Ela simplesmente usa um pouco mais de variáveis para armazenar os valores necessários para seus cálculos. Primeiramente, próximo à parte superior do programa, a Applet05 declara dois obje​tos TextFleld, como segue:
TextField textFieldl; TextField textField2;
Estes objetos TextField definidos anteriormente, representam as caixas de texto do programa nas quais o usuário digita os valores a serem somados e exibidos posteriormente. A seguir o programa sobregrava o método init() da classe Applet. Neste método, ele primeiramente cria dois novos objetos TextField:
textField1 = new TextFteld(5); textField2 = new TextFteld(5);	
programa então adiciona os objetos TextField à applet: add(textFieldl); add(textField2); Finalmente, de modo a garantir que o programa não tente somar dois valores inexis​tentes, init() inicializa o texto contido nos objetos para “0”: textField1.setText (“0”); textField2.setText (“0”); O método setText() da classe TextField configura o texto contido no componente para a string de texto dada como o único argumento do método.
 Sobregravar um método é o processo de substituir o método 
 encontrado na classe-base por uma versão específica para a nova classe. 
 Em outras palavras, a classe Applet a partir da qual Applet05 é derivada 
 também possui um método init(). Se você não sobregravasse init() na 
 Applet05, Java chamaria a versão original Applet. (Veja o exemplo chamado a 
 Encapsulamento, Herança e Polimorfismo no Capítulo 2 para maiores informações).
No método paint() é onde toda a ação se dá. Em paint(), o programa primeira​mente declara três variáveis inteiras: int value1; int value2; int sum;
 Como leva certo tempo para um computador alocar memória 
 para as variáveis, nem sempre é uma boa idéia declarar variáveis
 dentro do método paint() que tem de rodar o mais rápido possível.
 Embora questionável, preferimos adotar esta prática de modo a manter 
 Os exemplos de programas simples e fáceis de serem compreendidos. Entretanto, tenha em mente que o método paint() precisa realizar a menor quantidade de processamento possível de modo a manter-se rodando em velocidade razoável de acessamento.
Após declarar suas variáveis, paint() exibe duas linhas de texto na área de exibição do programa desenvolvido como Applet05. 
g.drawString("Digite um número em cada caixa.", 40, 65);
g.drawString("A soma dos valores é:", 40, 80);
Depois, o programa extrai o texto do primeiro objeto TextField e converte o texto da string para um valor numérico (neste caso, um inteiro):
String s = textField1.getText(); value1 = Integer.parseInt(s);
Você já viu o rnétodo getText() da classe TextField antes. A segunda linha apre​sentada, entretanto, introduz um novo método e classe. A classe Integer oferece muitos métodos que tornam mais fácil o trabalho com inteiros. 
Por exemplo, o método par​seInt() usado na segunda linha permite converter o conteúdo de uma string num inteiro (assumindo-se, é claro, que a string contenha dígitos numéricos).
Após converter a primeira string num inteiro, paint() manipula o segundo objeto TextField exatamente da mesma maneira: s = textField2.getText(); value2 = Integer.parselnt(s).Agora o programa possui dois valores inteiros, armazenados nas variáveis value1 e value2, que podem ser somados e que o programa executa assim: Sum = value1 + value2;
Após Java executar as linhas acima, a resposta do cálculo é armazenada em sum. O programa precisa agora exibir a resposta ao usuário da applet. Entretanto, antes que possa fazer isso, o programa tem de converter o valor numérico contido em sum numa string de texto que possa ser exibida na tela. Sabemos que o método valueOf() da classe String pode tratar esta situação. A última coisa que paint() faz então é converter numa string e exibir a string na tela:
s = String.valueOf(sum); g.drawString(s, 60, 105); O último método em Applet55 é action(), sobre o qual você aprendeu no capítulo anterior. Para revisarmos, Java chama action() sempre que o usuário executar alguma ação com os componentes da applet. Neste caso, action() responde quando o usuário pres​siona <Enter> num dos dois objetos TextField.
Sumário
Quase todos os computadores executam cálculos matemáticos. Para que você possa especificar os tipos de cálculos a serem executados, as linguagens de programação como Java possuem como recursos operadores matemáticos para operações padrões como a adição, subtração, multiplicação e divisão. Entretanto, ao usar estes operadores, lembre-se sempre da precedência de operadores (ou ordem das operações) que determina a ordem na qual os cálculos são realizados.
�PAGE �
�PAGE �49�
Prof. Orlando Pinho de Assis