Calculadora em Java

Obs: Para aprender a construir a calculadora produzida para esse tutorial, é necessário conhecimento base para construção de aplicações em Java e orientação a objetos. Se não tem esse conhecimento, pode acompanhar o exemplo pela curiosidade de compreender como são feitos aplicativos em Java.

Esse tutorial foi produzido com o objetivo de mostrar como desenvolver uma simples calculadora utilizando a linguagem de programação Java. Vamos ver abaixo uma imagem capturada do programa produzido funcionando:

Imagem capturada do programa calculadora em execução

O código fonte de um programa é o código escrito seguindo as regras da gramática de uma linguagem de programação. Abaixo o exemplo da calculadora produzida em Java:


package calc;

import java.awt.*;
import java.awt.event.*;
import java.text.*;
import javax.swing.*;
import javax.swing.border.*;

class Calc extends JFrame implements ActionListener {
    
    private final static String MAIS = "+";
    private final static String MENOS = "-";
    private final static String MULT = "*";
    private final static String DIV = "/";    
    
    private JTextField num1TF;
    private JTextField num2TF;
    private JComboBox operCBB;
    private JButton calcBT;
    private JTextField resultadoTF;
    
    private DecimalFormat df = new DecimalFormat( "0.00" );

    public Calc() {
        num1TF = new JTextField( 5 );
        num2TF = new JTextField( 5 );
        
        operCBB = new JComboBox();
        operCBB.addItem( MAIS );
        operCBB.addItem( MENOS );
        operCBB.addItem( MULT );
        operCBB.addItem( DIV );
        
        calcBT = new JButton( "Calcular" );
        
        resultadoTF = new JTextField();
        resultadoTF.setEditable( false ); 
        
        JPanel calcPNL = new JPanel();
        calcPNL.setLayout( new FlowLayout( FlowLayout.LEFT ) );
        calcPNL.add( num1TF );
        calcPNL.add( operCBB );
        calcPNL.add( num2TF );
        calcPNL.add( calcBT );
        
        JPanel conteudoPNL = new JPanel();
        conteudoPNL.setBorder( new TitledBorder( "Calculadora aritmética" ) ); 
        conteudoPNL.setLayout( new BorderLayout() );
        conteudoPNL.add( BorderLayout.CENTER, resultadoTF );
        conteudoPNL.add( BorderLayout.SOUTH, calcPNL );
        
        super.setTitle( "Calculadora" ); 
        super.setDefaultCloseOperation( JFrame.EXIT_ON_CLOSE );
        super.setContentPane( conteudoPNL );
        super.pack();
        super.setLocationRelativeTo( this );        
        
        calcBT.addActionListener( this ); 
    }
    
    public void actionPerformed( ActionEvent e ) {        
        boolean num1Ok = true;
        boolean num2Ok = true;
        
        double num1 = 0;
        try {
            num1 = df.parse( num1TF.getText() ).doubleValue();                        
        } catch ( ParseException ex ) {
            num1Ok = false;
        }
        
        double num2 = 0;
        try {
            num2 = df.parse( num2TF.getText() ).doubleValue();            
        } catch ( ParseException ex ) {
            num2Ok = false;
        }
        
        if ( num1Ok && num2Ok ) {            
            boolean divZero = false;            
            double result = 0;
            
            Object selItem = operCBB.getSelectedItem();
            if ( selItem.equals( MAIS ) ) {
                result = num1 + num2;
            } else if ( selItem.equals( MENOS ) ) {
                result = num1 - num2;
            } else if ( selItem.equals( MULT ) ) {
                result = num1 * num2;
            } else if ( selItem.equals( DIV ) ) {
                if ( num2 == 0 ) {
                    divZero = true;
                } else {
                    result = num1 / num2;
                }
            }
            
            if ( divZero ) {
                String msg = "Operação inválida - divisão por zero!";
                JOptionPane.showMessageDialog( null, msg, "Calculadora", JOptionPane.WARNING_MESSAGE );
            } else {
                resultadoTF.setText( df.format( result ) );
            }
        } else {
            if ( num1Ok == false ) {
                String msg = "O valor \"" + num1TF.getText() + "\" não é um numero válido.";
                JOptionPane.showMessageDialog( this, msg, "Calculadora", JOptionPane.WARNING_MESSAGE );
            } else if ( num2Ok == false ) {
                String msg = "O valor \"" + num2TF.getText() + "\" não é um numero válido.";
                JOptionPane.showMessageDialog( this, msg, "Calculadora", JOptionPane.WARNING_MESSAGE );            
            }
        }
    }
    
    public static void main( String[] args ) {
        Calc calc = new Calc();
        calc.setVisible( true ); 
    }
    
}

Um pouco de orientação a objetos

A orientação a objetos é um paradigma de criação um pouco recente que permite associar atributos, métodos, construtores e classes filhas a uma classe. Revolucionou o modo de programar ampliando as possibilidades. Veja abaixo alguns conceitos de orientação a objetos:

Classe: uma classe é uma definição que permite agrupar métodos e atributos a uma classe, para que a mesma seja instanciada para um objeto que possa ser utilizado pelo programa.
Método: uma definição de um subprograma identificado por nome, tipo de retorno e parâmetros, onde os parâmetros podem ser objetos instancias de classes ou tipos primitivos.
Atributo: são variáveis definidas em uma classe.

Tanto classes, métodos e atributos são associados a modificadores de acesso. Em Java, os modificadores de acesso são: public, private, protected, default. Onde default é quando o modificador de acesso é omitido.

Herança: Em java, quando uma classe utiliza a palavra reservada extends, isso indica que ela deve herdar os atributos e métodos públicos e protegidos da classe estendida. A herança é útil para reuso de código e para tornar possível o polimorfismo, isto é, várias classes podem herdar atributos e métodos de uma mesma classe.
Interface: São como classes que permitem a definição, apenas, de um protótipo de um método que deve ser implementado por classes implementadoras da interface. O uso das interfaces é análogo a herança, porém, ao invés da palavra reservada extends, é utilizada a palavra reservada implements. As interfaces são úteis para utilização de polimorfismo.
Polimorfismo: Estratégia que permite que objetos de classes diferentes possam ser passados como parâmetro para um método, desde que os objetos tenham em comum a herança de uma classe ou implementação dos métodos de uma interface.
Encapsulamento: permite que classes limitem o acesso a seus atributos através da criação de métodos “gets” e “sets” para acesso e modificação dos valores dos atributos. No exemplo de código fonte desse tutorial, não foi utilizado encapsulamento para simplificar o exemplo.

O programa “calculadora”

Para construção do programa calculadora foi utilizada a biblioteca SWING disponível na linguagem Java para a criação da interface gráfica com o usuário. A interface gráfica é a parte visível do programa funcionando. Em outras palavras é a parte visível com que o usuário do interage para utilizar o programa.

No código fonte acima é criada uma classe que herda os métodos e atributos públicos e protegidos de uma classe chamada JFrame do pacote Java.swing. Para herança é utilizado à palavra reservada extends logo com a criação da classe “Calc”. A palavra reservada implements é utilizada para indicar que a classe “Calc” implementa os métodos definidos em uma interface de nome ActionListener do pacote Java.awt.event.

Gerenciadores de layout

Os gerenciadores de layout servem para o alinhamento dos componentes de interface gráfica na janela ou painel em que os componentes forem adicionados. Como exemplos de componentes de interface gráfica os componentes JButton e JTextField que são adicionados a um container, no exemplo JanelaSimples o container é a classe JanelaSimples que estende o container JFrame.

No exemplo JanelaSimples foi utilizado como gerenciador de layout o FlowLayout que permitiu alinhar os componentes a esquerda da janela. O exemplo abaixo, escrito em "JanelaSimples", ilustra o uso do gerenciador de layout e a adição de componentes ao container:


Container c = super.getContentPane();
c.setLayout( new FlowLayout( FlowLayout.LEFT ) ); 
c.add( nomeL );
c.add( nomeTF );
c.add( okBT );

Adicionando funcionalidade ao botão "Calcular"

É através da implementação da interface ActionListener e seu método que é possível adicionar funcionalidade ao botão “Calcular”. O método da interface ActionListener é mostrado abaixo:


public void actionPerformed( ActionEvent e ) {
    ...
}

É no método acima onde é definido o código a ser executado quando o botão “Calcular” for clicado.

Na classe “Calc” é definido um atributo de nome “calcBT” que é um objeto instanciado mais a frente no código fonte, recebendo o texto “Calcular” que será mostrado no botão com a visualização da interface gráfica do programa. A linha de código a seguir mostra o modo de adicionar funcionalidade ao botão “Calcular”:


calcBT.addActionListener( this );

No exemplo acima o método addActionListener da classe JButton recebe como parâmetro um objeto instanciado de uma classe que implemente a interface ActionListener, no exemplo desse tutorial a classe que implementa a interface ActionListener é a classe “Calc”. A palavra reservada this indica que o objeto a ser passado para o método addActionListener é uma instancia da própria classe onde o método foi chamado.

Finalizando...

É isso pessoal. Não me aprofundei muito nas explicações. O exemplo da calculadora foi explicado de modo superficial, pois seria necessário um curso de Java, SWING e Orientação a Objetos para o leitor aprender a base necessária para compreender todo o exemplo.

Pretendo escrever no futuro sobre desenvolvimento da lógica de programação. Para isso, a linguagem Pascal é ideal.

Downloads

Download do arquivo Calc.jar: clique aqui.

Download do código fonte: clique aqui.

Se você tiver em seu computador instalado o Java (JRE), pode executar o programa com dois cliques no arquivo Calc.jar após baixá-lo.

Até o próximo!