Estude fácil! Tem muito documento disponível na Docsity
Ganhe pontos ajudando outros esrudantes ou compre um plano Premium
Prepare-se para as provas
Estude fácil! Tem muito documento disponível na Docsity
Prepare-se para as provas com trabalhos de outros alunos como você, aqui na Docsity
Os melhores documentos à venda: Trabalhos de alunos formados
Prepare-se com as videoaulas e exercícios resolvidos criados a partir da grade da sua Universidade
Responda perguntas de provas passadas e avalie sua preparação.
Ganhe pontos para baixar
Ganhe pontos ajudando outros esrudantes ou compre um plano Premium
Comunidade
Peça ajuda à comunidade e tire suas dúvidas relacionadas ao estudo
Descubra as melhores universidades em seu país de acordo com os usuários da Docsity
Guias grátis
Baixe gratuitamente nossos guias de estudo, métodos para diminuir a ansiedade, dicas de TCC preparadas pelos professores da Docsity
Neste documento, aprenderá-se a familiarizar-se com a linguagem de programação java e o desenvolvimento de aplicações no ambiente de desenvolvimento netbeans. O aluno aprenderá a utilizar o ambiente e um conjunto de classes da biblioteca java, além de aprender a criar programas com janelas e botões. Será apresentado o desenvolvimento de aplicações de demonstração passo a passo, recomendando-se aos alunos seguirem no ambiente netbeans.
Tipologia: Provas
1 / 14
Esta página não é visível na pré-visualização
Não perca as partes importantes!
Departamento de Engenharia Electrotécnica
3. O MEU PRIMEIRO PROGRAMA COM JANELAS
Para criar um programa com janelas e botões, comece por criar um projeto novo (chame-o de “ OneButton ”). O projeto é da categoria “Java” e é um projeto “Java Application”. Depois de estar criado, selecione o package “ onebutton ” e acrescente um file Type (com o botão direito do rato faça “ new ”, escolhendo a opção “ other ”). A categoria é “ Swing GUI Forms ” e o File Type é “ JFrame Form ”. Chame-lhe “JanelaTopo”. Foi criado um ficheiro chamado “ JanelaTopo.java ” e as janelas do NetBeans mudaram um pouco: Apareceu uma janela central com um quadrado, que é a moldura ( frame ) que se acabou de criar, e duas janelas à direita, sendo a de cima um repositório de outras janelas/classes (do tipo botões, janelas de diálogo, etc.) e a de baixo contém as propriedades do objeto que estiver selecionado na janela central. Pode ver o código de “ JanelaTopo.java ” escolhendo o botão “ Source ”, em vez do “ Design ”. Se fizer isso vai ver que este ficheiro também contém a função “ main ” (o ficheiro “ onebutton.java ” também contém). Um modo simples de resolver este problema é eliminar o ficheiro “ onebutton.java ” pura e simplesmente. Elimine-o. Vamos então começar a colocar objetos gráficos. Começamos por um objeto simples – um rótulo ( label ). Escolha o objeto label e leve-o para a moldura. Pode redimensionar o seu tamanho. O rótulo mostra o nome da sua classe. Não é muito interessante, mas haveremos de mudar a mensagem pelo programa propriamente dito. Arraste agora um botão fazendo o mesmo (escolhendo a classe “ Button ”, arrastando e dimensionando). Será o nosso botão 1. Desta vez mude o nome dele alterando a propriedade respetiva para “Botao 1”. Escolha ainda mais um botão (mude-lhe o nome para “Botao 2”) e depois um “ Text Field ”. Para o “Text File” alongue o seu comprimento, para ficar grande. Vamos começar a escrever código. Se carregar duas vezes no botão 1, é criada uma operação chamada de jButton1ActionPerformed. Esta será a operação que será chamada quando o utilizador carregar no “Botao 1”. A ação que queremos é que quando se carregar no botão, se escreva a
mensagem “Hello World” no objeto Text File. Para isso, dentro desta operação, execute a seguinte instrução
jTextField1.setText ("Hello World");
Vamos correr o programa. Quando o tentar correr, o NetBeans vai perceber que “ onebutton.OneButton ” já não existe e pergunta se queremos que a classe principal seja a “ onebutton.JanelaTopo ”. Diga que sim. Quando aparecer a janela, carregue no botão 1 e veja o que acontece. Termine o programa usando o botão de terminar a janela do seu sistema operativo. O código até ao momento deve estar assim:
/*
private void jButton1ActionPerformed(java.awt.event.ActionEvent evt) { // TODO add your handling code here: jTextField1.setText ("Hello World"); } /**
/* Create and display the form */ java.awt.EventQueue.invokeLater(new Runnable() { public void run() { new JanelaTopo().setVisible(true); } }); } // Variables declaration - do not modify private javax.swing.JButton jButton1; private javax.swing.JButton jButton2; private javax.swing.JLabel jLabel1; private javax.swing.JTextField jTextField1; // End of variables declaration }
Look and feel setting code (optional)
Generated Code
4. PRIMEIRA APLICAÇÃO - SOMADORA
Esta aplicação vai ser realizada em duas fases:
É fornecido aos alunos o projeto NetBeans com a primeira fase realizada. Para aceder ao projeto, o aluno deve começar por descompactar o ficheiro Calculator.zip para uma diretoria local. De seguida, deve selecionar a opção “File”; “Open Project…” (conforme está representado à direita), e abrir o projeto Calculator a partir da diretoria. O código do projeto está dentro de um pacote ( package ) com o nome calculator, e tem dois ficheiros correspondentes às duas classes que o compõem. A figura no início da página 2 reproduz o que se deverá ver depois de abrir o projeto, e se selecionar o ficheiro Calculator.java e o método calc_number. Os alunos deverão analisar esse código seguindo a descrição que é feita nesta secção. Este código servirá de base para realizar a segunda fase, como exercício.
4.1. SOMADORA SIMPLIFICADA
Pretende-se programar uma calculadora que: aceite a introdução de números tanto por um conjunto de botões como através de um vetor de caracteres ( string ) diretamente no écran da calculadora, suporte um conjunto mínimo de operações (“+” e “=”), crie um registo de todas as operações numa janela de texto, e opcionalmente, num ficheiro. A realização vai ser baseada em duas classes: a classe Calc_State é usada para manter as parcelas durante o cálculo e a classe Calculator define a interface gráfica para o utilizador.
4.1.1. Classe Calc_State A abordagem usada na classe Calc_State é dividir as expressões em sequências de pares ( valor , operação ) e realizar os cálculos sequencialmente, um par de cada vez, usando a operação push_operation. A classe mantém como estado a parcela pendente (operand) e a operação pendente (oper) (do tipo char). No início a operação pendente tem o valor de IDLE_OPER, operação nula. Por exemplo, a operação “2+3+4=” é realizada com a composição de três operações: (2, +)(3, +)(4, =). A evolução do estado em Calc_State para cada uma das operações vai ser:
IDLE_OPER (2,+) (5,+) (9,=)
O resultado final do cálculo fica guardado no valor de operand. O código da classe Calc_State é apresentado na caixa seguinte. Inclui a definição de um construtor (corrido quando se invoca a operação new Calc_State()) que inicia o estado do objeto, um método que repõe o estado inicial (reset()) e a declaração das duas variáveis da classe privadas (não acessíveis diretamente). Também inclui uma constante
(2,+) (3,+) (4,=)
(Calc_State.IDLE_OPER), que define um estado sem nenhuma operação pendente na calculadora. Para aceder aos valores das variáveis são definidos dois métodos: last_oper() e operand(). O método principal é push_operation(new_operand, new_operation), que realiza os cálculos atualizando o estado do objeto, retornando true em caso de sucesso, ou false caso contrário.
public class Calc_State { public static final char IDLE_OPER= ' '; // Constant public Calc_State() { /* Constructor / operand= 0; oper= IDLE_OPER; } public char last_oper() { / Returns the last operation */ return oper; }
public long operand() { /* Returns the current operand / return operand; } public void reset() { / Resets the state to the default values / operand= 0; oper= IDLE_OPER; } / Adds a new pair (operand, oper) to the state */ public boolean push_operation(long new_operand, char new_oper) { switch (oper) { // Calculate the pending operation case IDLE_OPER: // First operand operand= new_operand; break; case '+': // Calculate pending addition operand += new_operand; break; case '=': break; default: // Error - operation not supported reset(); return false; } // Memorizes pending operation oper= new_oper; return true; } // Class local variables private long operand ; private char oper ; }
4.1.2. Classe Calculator – Interface gráfica O desenho da interface gráfica é feito usando o modo “ Design ”, representado na figura abaixo. Para desenvolver esta aplicação irão ser necessários vários tipos de componentes gráficos (selecionados na caixa “ Pallete ”, à direita na imagem) que são adicionados a uma janela do tipo JFrame:
7 objetos Button (da pasta ' Swing Controls ') {para fazer os botões 0-1, +, =, C, etc.} 1 objeto ToggleButton (da pasta ' Swing Controls ') {para fazer o botão com estado ‘ToFile’} 1 objeto Text Field (da pasta ' Swing Controls ') { Mostrador da calculadora } 1 objeto Text Area (da pasta ' Swing Controls ') { Janela com o registo das operações }
O botão “ Clear ” apaga o conteúdo da Text Area :
private void jButtonClearActionPerformed (java.awt.event.ActionEvent evt) { jTextArea1.setText(""); }
4.1.3. Classe Calculator – Leitura de Dígitos Quando se carrega no botão de um dígito, o dígito é memorizado na caixa de texto jTextNumber, sendo também usada uma variável Booleana para memorizar se é o primeiro dígito.
private boolean first_digit ; // If it is the first digit of a number
O método handle_digit foi criado para concatenar o dígito number à string já existente na caixa de texto cada vez que se prime um botão numérico:
private void handle_digit(String number) { if ((state.last_oper() == '=') && first_digit) { // If the result from the last addition is not used Log(""); // Add na empty line to the output state.reset(); // Ignore last result } String str= jTextNumber.getText(); // get the string if (first_digit ||str.equals("0")) { // Ignore leading zeros jTextNumber.setText(number); // Sets the string } else { jTextNumber.setText(str+number); // Concatenate digit } first_digit= false; // The next digit is not the first! }
O método anterior é usado pelas funções que tratam os botões numéricos. Por exemplo, para o caso do ‘1’ fica:
private void jButton1ActionPerformed (java.awt.event.ActionEvent evt) { handle_digit("1"); }
A função de tratamento do botão ‘ C ’ remove o último dígito do número. O método jTextNumber.getText() devolve a string com o conteúdo da caixa de texto, e depois o método jTextNumber.setText(str) modifica a string mostrada para o valor de str.
private void jButtonCActionPerformed (java.awt.event.ActionEvent evt) { String str= jTextNumber.getText(); // Get the string if (str.length() > 1) { // Remove the last digit str= str.substring(0, str.length()-1); // substring from 0 to length- jTextNumber.setText(str); // Set new string } else { // Deleted all digits first_digit= true; jTextNumber.setText("0"); } }
4.1.4. Classe Calculator – Cálculo
Para realizar o cálculo vai ser usado o objeto state, da classe Calc_State, private Calc_State state; // Calculation state
inicializado no construtor da classe Calculator:
state= new Calc_State(); // Allocates a new object Calc_State
Foi criado o método calc_number para processar a string na caixa de texto, validando-a, e para invocar a operação push_operation sobre o estado. Adicionalmente, escreve no registo. Observe-se a utilização do try – catch: se o número for válido, invoca o método push_operation e retorna o que esta retornar; se o número não for válido, corre o código em catch, retornando false.
private boolean calc_number (String number, char oper) { try { long value= Long.parseLong(number); // Converts 'String' to long if (state.last_oper() != '=') { Log(number); // Write number } Log(Character.toString(oper)); // Write operation return state.push_operation (value, oper); // Update state } catch (Exception e) { Log("Invalid number: " + e + "\n"); return false; } }
O método que trata o botão ‘+’ tem apenas de invocar o método anterior e preparar a leitura do número seguinte.
private void jButtonPlusActionPerformed (java.awt.event.ActionEvent evt) calc_number(jTextNumber.getText(), '+'); first_digit= true; }
O método que trata o botão ‘=’ é semelhante ao anterior, mas adicionalmente, tem de escrever o resultado da operação.
private void jButtonEqualsActionPerformed (java.awt.event.ActionEvent evt) if (calc_number(jTextNumber.getText(), '=')) { Log(Long.toString(state.operand())); // Writes the result of the operation jTextNumber.setText( Long.toString(state.operand()) ); // Update the number } first_digit= true; // Wait for first digit of next number }
4.1.5. Classe Calculator – Escrita no ficheiro A escrita no ficheiro vai requerer duas variáveis adicionais: o descritor de ficheiro f e o objeto para escrita os. O ficheiro está ativo quando os!=null; caso contrário não está activo e não se escreve no ficheiro.
private File f; // File object private BufferedWriter os ; // File writting objects
O método start_writing_to_file abre uma janela permitindo ao utilizador escolher o ficheiro onde quer guardar o registo das operações, abrindo de seguida o objeto de escrita no ficheiro os. Retorna true em caso de sucesso, ou false caso o ficheiro não seja aberto.
A escrita do conteúdo no ficheiro ocorre apenas quando se fecha o ficheiro. Para garantir que não se perde nada quando se fecha a aplicação, foi acrescentada a função seguinte para tratar o evento windowClosing do objeto JFrame, gerado quando se fecha a janela.
private void formWindowClosing (java.awt.event.WindowEvent evt) { // Main window is closing - close file if it is open stop_writing_to_file(); }
4.1.6. Classe Calculator – Arranque e terminação da aplicação O arranque da aplicação ocorre a partir da função main, integralmente criada pelo NetBeans durante a criação do projeto. Nesta função, e dentro de uma tarefa gerida pelo ambiente gráfico, é criado um novo objeto do tipo Calculator e é tornado visível.
public static void main(String args[]) { java.awt.EventQueue.invokeLater(new Runnable() { // Create and display the form public void run () { new Calculator().setVisible(true); } }); }
O valor inicial das variáveis da classe Calculator é definido no construtor:
public Calculator() { initComponents(); // Start graphical window; created by NetBeans first_digit= true; // Waiting for first number state= new Calc_State(); // Create object with operand and operation state }
Durante o funcionamento da calculadora, é possível repor o estado inicial (excepto a gravação para ficheiro) através do botão CE:
private void jButtonCEActionPerformed(java.awt.event.ActionEvent evt) state.reset(); Log(""); // Add an empty line first_digit= true; jTextNumber.setText("0"); }
4.2. SOMADORA COMPLETA – EXERCÍCIO PARA PRIMEIRA AULA
Na segunda fase desta aula pretende-se completar a calculadora iniciada anteriormente, completando o conjunto de teclas numéricas (‘0’ a ‘9’) e acrescentando uma operação nova (‘*’).
4.2.1. Botões numéricos ‘0’ a ‘9’ Como primeiro exercício, os alunos devem modificar a interface gráfica anterior, de maneira a terem todos os botões numéricos. Para tal, devem abrir o ficheiro “Calculator.java” selecionando o modo “ Design ” do editor. De seguida, devem acrescentar os oito objetos “ Button ” à form , no primeiro painel, modificando o seu nome e texto, de acordo com a figura à direita. Numa segunda fase, devem criar as funções (métodos) de tratamento
dos novos botões, preenchendo o código correspondente. Para resolver este problema, sugere-se uma leitura à secção 4.1.3.
4.2.2. Operação multiplicação Como segundo exercício, pretende-se que se acrescente a operação multiplicação à calculadora. Este exercício tem três fases distintas: Acrescentar botão ‘’ Programar cálculo sem precedência Programar cálculo com precedência A primeira fase é semelhante ao exercício anterior: acrescentar um botão à lista de operações. A segunda e terceira fases obrigam a definir um método para tratar o botão ‘’ e a reprogramar a classe Calc_State, de maneira a esta passar a reconhecer a operação multiplicação. A segunda fase deve ignorar a precedência da multiplicação face à adição e calcular sequencialmente as operações; isto é, “2+22” deve dar o resultado 8. A terceira fase vai novamente incidir sobre a classe Calc_State, mas obriga a acrescentar mais variáveis à classe, para memorizar até duas operações pendentes. No caso de “(2,+)(2,)(2,=)” é necessário guardar (2,+); (2,*) e só depois de receber (2,=) é que se vai realizar os cálculos, obtendo-se o resultado correcto (6).
4.2.3. Temporização Crie um temporizador usando procedimentos parecidos com os mostrados no documento de introdução ao Java. O objetivo é fazer com que a calculadora execute a operação que estiver pendente caso o utilizador não prima nenhuma tecla durante 10 segundos a meio de um cálculo. É como se o utilizador tivesse premido o botão ‘=’. Não se esqueça de reiniciar o relógio, cada vez que o utilizador carregar em certas teclas e de pará-lo quando carregar noutra tecla.
