Calculadora versão 2.0

Introdução

Este projecto de desenvolvimento em linguagem Java de uma máquina calculadora, “Calculator Versão 2.0”, está organizado em quatro partes, com todas as informações prévias, que fomos considerando importantes para o seu total esclarecimento. Deste modo, torna-se importante para o pleno entendimento de cada tutorial, efectuar uma leitura atenta destas notas explicativas. O objectivo no final das quatro fases é ter esta calculadora (fig.1), a funcionar completamente desenhada e programada por si, apenas com o apoio destes tutoriais.

Mas o mais importante é que, após a realização deste trabalho e de outros projectos que iremos disponibilizar aqui no portal, estes servirão de base, possibilitando que você desenvolva as aplicações que entender, no futuro, tendo apenas como limite o céu e a sua imaginação. Portando vale a pena o esforço tendo em conta os benefícios possíveis de alcançar. Irá decerto também apreciar o desenvolvimento em IDE NetBeans.

Preparação do projecto

Antes de começar, deverá instalar o seguinte software no seu computador:

Primeira fase do projecto

Nesta primeira parte vamos criar uma caixa de texto e nomeá-la displayField, um botão (+)ButtonPlus e o botão igual (=)ButtonEqual.
Deverão ainda ser criadas as seguintes variáveis na área de código:

...
String dispFieldText; // que irá receber o texto do displayField esta variável é local
double displayValue=0; // que irá receber a conversão do texto em número
double currentResult =0; // que irá acumular o resultado da soma

O código Java a desenvolver deverá executar as funções apropriadas, de forma a realizar o cálculo da soma de duas parcelas. Assim o código deverá permitir:

a) Introduzir a primeira parcela (número a somar) no campo de texto (displayField);

b) Após ser premido o botão (+), ler o valor, converter o texto em número (double) e guardá-lo. Explicação: o valor introduzido no campo de texto é entendido como texto, não sendo possível efectuar a soma de textos (a soma de textos é uma concatenação e o resultado é um texto não é um número) daí ser necessário converter o texto em número:

String dispFieldText=displayField.getText(); // a string dispFieldText recebe o texto
if(!””.equals(dispFieldText)) { // testa se é diferente de vazio, ou seja se existe texto.
   displayValue=Double.parseDouble(dispFieldText); // displayValue recebe a conversão
}
currentResult=displayValue; // guarda o número em currentResult.

c) Após o número estar guardado é necessário apagar o conteúdo do campo texto para permitir digitar a segunda parcela, (repare que só tem um campo de texto, display, tal como numa máquina de calcular real).

displayField.setText(“”);

d) Introduzir a segunda parcela no campo texto

e) Após ser premido o botão (=), ler o valor, converter o texto em número (double) e somar esta parcela com a primeira que foi previamente guardada.

String dispFieldText=displayField.getText(); // recebe a segunda parcela
if (!"".equals(dispFieldText)){ // testa se é diferente de vazio, ou seja se existe texto.
   displayValue= Double.parseDouble(dispFieldText); // displayValue recebe a nova conversão
}

Nota importante: Em linguagem Java, quando se pretende adicionar um novo valor à variável utiliza-se a expressão +=, ou seja, imagine que o conteúdo de uma determinada variável, var, era 10 se quiser adicionar mais 15. Faça:
var += 15; O conteúdo da variável ficaria com 10+15, ou seja com o número 25.

Poderia ainda ser: var *=15; (*) sinal de multiplicação, o valor seria 10*15, ou seja, 150. Temos então, que o valor que existia em currentResult, vai ser acumulado, agora, com o valor existente no displayValue, sendo a linha de código:

currentResult+=displayValue;

f) Por fim colocar o resultado da soma no campo de texto.

displayField.setText(""+currentResult); // resultado da soma das parcelas

Crie a primeira estrutura de acordo com a imagem acima (fig.2). Abra o NetBeans, escolha menu File --> NewProject -->Java e Java Desktop Application. Prima o botão next. De ao nome do projecto calculadora, marque a opção “Basic Application”, prima a tecla Finish…

Segunda fase do projecto

Nesta segunda fase vamos manter a caixa de texto, o botão (+) e o botão igual (=) e acrescentar onze botões, dez botões que corresponderão aos números 0 a 9 e um botão para o ponto (.) que definirá as casas decimais.

Tente desenhar os botões e colocá-los conforme a imagem em baixo (fig.3), não será muito fácil à primeira, mas com um pouco de paciência vai ver que consegue. A introdução dos botões correspondentes aos números, nesta segunda fase do projecto, possibilitará a introdução de números na caixa de texto, pressionando os botões e não digitando os números directamente na caixa, através do teclado, aliás, vamos inibir esta possibilidade, nas suas propriedades.

Ao inibir o utilizador de escrever directamente na caixa de texto, deve-se a que assim, não será possível escrever texto livre, o que não possibilitaria nenhum cálculo e originava erros na execução do programa, a menos que testássemos que no texto fornecido apenas constavam números e não outros caracteres, antes de proceder à conversão do texto em número.
Relativamente ao código desta fase, devo salientar o seguinte, dando como exemplo o botão 7 (Button7):
Para que o botão 7 escreva o número 7 na caixa de texto displayField, primeiro colocamos na propriedade text do botão o algarismo 7, independentemente do botão estar designado propriedade name Button7. Segundo é necessário colher o texto que está na caixa (porque pode não ser o inicio e não estar vazia), concatenar o 7 e voltar a por tudo outra vez na caixa. Assim temos:

String dispFieldText=displayField.getText();// dispFiedText recebe o texto da caixa displayField
String clickedButtonLabel = Button7.getText(); // clickedButtonLabel recebe o algarismo 7
displayField.setText(dispFieldText + clickedButtonLabel); //voltar a por tudo outra vez na caixa

Repare que a caixa displayField, agora contém o texto que lá estava anteriormente (dispFieldText) + o algarismo 7 (clickedButtonLabel). Todo este código terá que ser repetido para cada um dos botões que representam os números de 0 a 9, mais o ponto decimal.

Terceira fase do projecto

Vamos manter tudo o que criámos das fases anteriores e acrescentar os seguintes botões: o botão da subtracção (-), da multiplicação (*), da divisão (/) e por fim o de sinal (+/-).

Tente desenhar os botões e colocá-los de acordo com a imagem (fig.4). Repare que ficará apenas a faltar o bloco esquerdo da calculadora, constituído por dez botões e a caixa de texto (Memória), para mostrar o resultado dos valores guardados precisamente na memória, que será a fase final do nosso projecto. Posteriormente, faremos um tutorial de revisão, adicionaremos a barra de menu com os itens Help -->About, com abertura de uma janela.

Quando tínhamos só o botão de somar apenas realizávamos a operação currentResult+=displayValue;

Como já dispomos do botão da divisão, da multiplicação e da subtracção, vamos ter de efectuar respectivamente as seguintes operações:

currentResult/=displayValue;
currentResult*=displayValue;
currentResult-=displayValue;

Precisamente quando forem pressionados os botões divisão, multiplicação e subtracção.

Iremos também criar uma variável geral do tipo char: char selectedAction= ' '; e colocar mais estas linhas de código em cada botão de operação:

selectedAction= '+ '; // Botão adição
selectedAction= '- '; // Botão subtracção
selectedAction= '/ '; // Botão divisão
selectedAction= '* '; // Botão multiplicação

Deste modo, por exemplo, para o botão de multiplicação ficará:

String dispFieldText=displayField.getText();
if(!"".equals(dispFieldText)){
   displayValue=Double.parseDouble(dispFieldText);
}
selectedAction='*'; // linha de código acrescentada
currentResult=displayValue;
displayField.setText("");

Para permitir que ao pressionar o botão de igual, testarmos qual o botão que foi anteriormente pressionado e assim realizar a operação em conformidade. O teste a efectuar no botão igual será:

if(selectedAction=='+'){ // testa se foi o botão soma
   currentResult+=displayValue;
   displayField.setText(""+currentResult);
}else if(selectedAction=='-'){ // testa se foi o botão subtracção
   currentResult-=displayValue;
   displayField.setText(""+currentResult);
}else if(selectedAction=='*'){ // testa se foi o botão multiplicação
   currentResult*=displayValue;
   displayField.setText(""+currentResult);
}else if(selectedAction=='/'){ // testa se foi o botão divisão
   currentResult/=displayValue;
   displayField.setText(""+currentResult);
}

Penso que o código anterior dispensa mais explicações. Falta apenas explicar o botão de sinal (+/-). O botão de sinal designado no código como ButtonPlusMinus, ao ser pressionado deverá inverter o sinal do número apresentado no display, assim podem ocorrer as seguintes situações:

a) Se o número não apresentar nenhum sinal, ou seja, é positivo (+) deverá torná-lo negativo, acrescentando (-);
b) Se apresentar o sinal (-) deverá torná-lo positivo, ou seja, retirar o sinal.

Carregamos o valor do display displayField.getText() na variável local signalFieldText. Carregamos na variável local SubStr apenas o primeiro caracter do display substring(0,1) e testamos se é o sinal (-) se for verdade repomos do índex 1 até ao fim (length) da string, ou seja, já não enviamos o sinal pois este figurava no índex 0.

Para a situação a) ainda é mais fácil, basta acrescentar ao display o sinal (-), então no ramo else do if fazemos displayField.setText(“-“+signalFieldText);O código completo é:

String signalFieldText=displayField.getText();
if(!"".equals(signalFieldText)){
   String SubStr=signalFieldText.substring(0,1);
if("-".equals(SubStr)){
   SubStr=signalFieldText.substring(1,signalFieldText.length());
   displayField.setText(""+SubStr);
}else {
   displayField.setText("-"+signalFieldText);
}
}