Base de dados
Maio 8, 2009
Tecnologia JPA:
Exercício:
http://www.netbeans.org/kb/docs/java/gui-db-custom_pt_BR.html
Tecnlogia JDBC, exemplo:
package connectbd;
import java.sql.*;
/**
*
* @author professor
*/
public class acessoBD {
/**
* @param args the command line arguments
*/
public static void main(String[] args) {
// TODO code application logic here
// Create a variable for the connection string.
String connectionUrl = “jdbc:sqlserver://portatil:1433;” +
“databaseName=Taloes;integratedSecurity=true;”;
// Declare the JDBC objects.
Connection con = null;
Statement stmt = null;
ResultSet rs = null;
try {
// Establish the connection.
Class.forName(“com.microsoft.sqlserver.jdbc.SQLServerDriver”);
con = DriverManager.getConnection(connectionUrl);
// Create and execute an SQL statement that returns some data.
String SQL = “SELECT * FROM dbo.Funcionarios”;
stmt = con.createStatement();
rs = stmt.executeQuery(SQL);
// Iterate through the data in the result set and display it.
while (rs.next()) {
System.out.println(rs.getInt(1) + ” ” + rs.getString(2));
}
}
// Handle any errors that may have occurred.
catch (Exception e) {
e.printStackTrace();
}
finally {
if (rs != null) try { rs.close(); } catch(Exception e) {}
if (stmt != null) try { stmt.close(); } catch(Exception e) {}
if (con != null) try { con.close(); } catch(Exception e) {}
}
}
}
Gestão de Componentes
Maio 8, 2009
Menus:
Exemplo de Menu
Para criar um menu é necessário acrescentar ao formulário um JMenuBar, que serve de contentor para menus e items de menu:
De seguida acrescenta-se um Jmenu:
O Jmenu pode comportar:
Para adicionar um atalho deve-se ir à propriedade accelerator, do menu item em questão, e adicionar a combinação de teclas pretendidas:
A cada item deve ser adicionada um evento do tipo ActionPerformed, para que o clique possa ter uma acção.
Exemplo:
private void menuIsalvarActionPerformed(java.awt.event.ActionEvent evt) {
// TODO add your handling code here:
Salvar();
}
Menus de contexto:
Exemplo de Menu que surge quando se clica na tecla direita do rato
Deve ser adicionado o componente JPopupMenu ao formulário
Depois através da janela do Inspector do Netbeans clicar com a tecla direita sobre o JPopupMenu, e em ‘Add From Palette’ adicionar o que entender que seja necessário ao menu de contexto.
Tendo o menu de contexto construído é necessário associa-lo a um componente, que depois em tempo de execução da aplicação, ele aparecerá quando clicar com a tecla direita do rato. Para isso na propriedade componentePopupMenu, do componente em questão, escolhe-se o nome do JPopupMenu anteriormente construído.
Barra de ferramentas:
Deve ser adicionado um JToolBar, que serve de suporte para colocar componentes JButtons ou JToggleButtoms
JButtons ou JToggleButtoms:
Formulário “secundário”:
Para que seja possível, a partir do formulário principal, lançar um formulário “secundário” deve ser adicionado o JDialog ao formulário principal.
Abas:
Exemplo de abas
Para ter abas na aplicação deve ser adicionado um JTabbedPane, ao formulário:
Ao JTabbedPane colocado no formulário é necessário colocar JPanels para que seja possível ter várias abas. Ter em atenção que ao adicionar um JPanel, a ponta do cursor ao arrastar o JPanel deve estar próxima da aba já existente:
Introdução à Programação com Componentes
Programação com componentes
• A tecnologia de programação com componentes é especialmente importante no desenvolvimento de aplicações que são distribuídas por várias máquinas, uma vez que a distribuição dos componentes pelas máquinas é mais fácil do que se forem utilizadas outras tecnologias
• A programação com componentes pretende aumentar o grau de reutilização do software, no entanto, o seu sucesso apenas foi significativo no desenvolvimento das interfaces gráficas das aplicações.
• A ideia base de programação com componentes é possibilitar o desenvolvimento de aplicações apenas através da colagem de peças de software (componentes) já existentes.
O que são componentes?
• Um componente pode ser um bloco de código, uma função, um objecto ou uma aplicação, ao qual foi adicionada lógica para implementar uma interface.
• Um componente é uma peça de software (i.é., executável) que implementa uma determinada funcionalidade (interface) e que pode ser configurada (alterando as propriedades do componente) em função do contexto onde é utilizada.
• Cada componente implementa um conjunto de serviços (i.é., interfaces que implementa) e pode basear-se em serviços fornecidos por outros componentes (i.é., pode utilizar interfaces implementados outros componentes) • Os componentes são frequentemente utilizados em ambientes de programação visual, os quais devem ser capazes de determinar os interfaces implementados por cada componente e os interfaces que cada componente utiliza
Como são construídas as aplicações com componentes
• A programação por componentes permite desenvolver aplicações simplesmente através da colagem de vários componentes, possivelmente de diferentes fabricantes. A “colagem” consiste em identificar as interligações entre componentes as propriedades de cada componente
• Uma forma de desenvolver aplicações baseadas em componentes é utilizando um ambiente visual de programação que permite, através de uma interface gráfica, fazer a configuração da aplicação
Introdução aos Componentes do GUI em Java
Historial do GUI (Graphical User Interface) de Java
• Java 1.0 incluía a versão inicial do Abstract Window Toolkit (AWT), que continha várias limitações, nomeadamente uma GUI medíocre em todos os sistemas e não adoptava uma filosofia orientada por objectos.
• Java 1.1 melhorou o AWT original, com uma aproximação mais “limpa” e orientada ao objecto, juntamente com a adição de JavaBeans, um modelo de programação por componentes orientado para a criação de ambientes de programação visuais
• Java 2 terminou a transformação com a substituição de todos os elementos da GUI por um novo conjunto, designado por Swing (classes javax.swing), presente nas Java Foundation Classes (JFC)
Introdução aos Applets
• São pequenos programas em Java que executam num browser Web
• Por serem executados no browser dos clientes os applets devem ser seguros, razão que leva a que sejam limitadas as operações realizadas, ex: não podem aceder ao disco local, todas as classes necessárias ao applet devem ser empacotadas num ficheiro JAR (Java Archive)
• Não é necessário instalar os applets e estes são verdadeiramente portáveis e seguros.
• Os applets devem estender a classe JApplet, devendo redefinir os seguintes métodos:
void init(); // invocado quando é iniciado
void destroy(); // invocado quando é terminado
void start(); // invocado quando recebe a atenção
void stop(); // invocado quando perde a atenção
os métodos start() e stop() também são invocados, em init() e destroy().
• Exemplo:
import javax.swing.*;
import java.awt.*
public class Applet1 extends JApplet {
public void init() {
getContentPane().add(new JLabel(“App1″));
}
}
• O applet anterior pode ser incorporado numa página www através de seguinte código:
<applet code=Applet1.class width=100 height=50></applet>
• O utilitário appletviewer do JDK permite visualizar um applet.
• É possível construir uma classe que é um applet e que também pode ser executada como uma aplicação normal, a partir da linha de comando.
Para tal basta incluir a applet numa JFrame, adicionando o seguinte main() à definição do applet:
public static void main(String[] str) {
JApplet ap = new Applet1();
JFrame frame = new JFrame(“Appx”);
frame.getContentPane().add(ap);
frame.setSize(100,50);
ap.init(); // simula o focos do browser
ap.start();
frame.setVisible(true); // torna visível
}
Componentes da interface Swing
• O método getContentPane() permite obter o Container actual, o qual utiliza o padrão composto, onde add(Componet c) adiciona um componente ao composto e o método setLayout(LayoutManager mgr) indica a estratégia de posicionamento dos elementos (é um padrão do tipo estratégia). Button(String) é um componente que implementa um botão.
public class Applet1 extends JApplet {
public void init() {
Container ct = getContentPane();
// altera a estratégia de colocação dos elem
ct.setLayout(new FlowLayout());
ct.add(new JButton(“Botão1″));
ct.add(new JButton(“Botão2″));
}
}
Introdução aos Componentes JavaBeans
Programação com componentes em Java (JavaBeans)
• JavaBeans é uma arquitectura de componentes de software em Java, surgindo após o sucesso do Microsoft Visual Basic e do Borland Delphi. Esta arquitectura proporciona a interoperabilidade entre componentes e ferramentas de vários fabricantes, para além da independência da plataforma, assegurada para própria linguagem Java.
• Em JavaBeans, um componente é constituído por uma classe Java, sendo apenas necessárias pequenas alterações para tornar uma classe Java num Bean, o que torna o desenvolvimento de componentes extremamente simples em Java.
• Na programação por componentes é necessária uma ferramenta que permita a configuração e a ligação de um conjunto de beans, formando uma aplicação.
• A arquitectura JavaBeans baseia-se em propriedades que permitem controlar o comportamento do objecto, podendo ser variáveis de estado; em métodos que são invocados para executar código no componente e em eventos que são notificações geradas quando o objecto altera o estado.
• As ferramentas visuais de programação com JavaBeans permitem editar graficamente as propriedades dos componentes e visualmente associar os eventos gerados por um componente a invocações de métodos noutros componentes. Esta última operação é implementada através da utilização do padrão Observador e de Adaptadores para tornar as interfaces compatíveis.
• As ferramentas de desenvolvimento de aplicações por componentes baseiam-se num mecanismo designado por introspecção, que permite determinar as propriedades, eventos e métodos de cada componente.
Bibliotecas
O que é classpath?
No contexto da plataforma Java, é uma variável de ambiente que diz ao compilador e à JVM onde encontrar as classes que o software irá utilizar.
Configurando o Classpath de um Projecto no NetBeans
Na janela Projects, localize o projecto em questão – Registo, no neste caso – clique com o botão direito do rato em Libraries. Selecione Add Library… no menu de contexto.
A janela Add Library irá aparecer, no entanto ainda não adicionamos a API ao conjunto de bibliotecas disponíveis no NetBeans. Por isso, clique em Create.
Defina o nome e o tipo da biblioteca, na caixa de diálogo Create New Library – SwingX e Class Libraries respectivamente.
Clique em Add JAR/Folder… e navegue até o directório onde a API está localizada.
Faça o mesmo nas abas Sources e Javadoc, indicando o caminho para o directório com o código-fonte da biblioteca no primeiro caso, e da documentação, no segundo. Nem sempre, a API inclui o seu código-fonte e documentação. Nesse caso, não há problema – o importante mesmo é o classpath.
Clique em Ok para voltar à caixa de diálogo Add Library, selecione a biblioteca e clique em Add Library.
De seguida vá à palete, clicando com a tecla direita do rato escolha Palette Manager.
Clique em New Palette Category:
A seguir clique em Add form Library e escolha SwingX e clique em Next. O Gerenciador da Paleta irá procurar por componentes disponíveis. Isto é, irá procurar classes que estejam de acordo com a especificação JavaBeans.
SwingX
Contém extensões para o toolkit GUI Swing, incluindo novos e aprimorados componentes que fornecem funcionalidades comummente requisitadas por aplicações. Destaques incluem:
* Ordenamento, filtragem, destaques (highlighting) para tabelas, árvores (trees) e listas
* Find/Search
* Auto-complemento
* Framework para autenticação/login
* Componente TreeTable
* Collapsible Panel (painel dobrável)
* Componente Date Picker (seletor de datas)
* Componente Tip-of-the-Day (dica-do-dia)
SwingX é um subprojecto do SwingLabs, que conta com suporte da Sun Microsystems e com a participação de alguns dos mais importantes engenheiros da Sun responsáveis pelo Swing. Requer pelo menos JDK 5 e é licenciado sob LGPL.
SwingLabs serve para implementação e teste de ideias relacionadas à tecnologia voltada para o desenvolvimento de GUI’s (Graphical User Interface) para clientes ricos. Experimentos bem-sucedidos serão considerados para inclusão em versões futuras do JDK (Java Development Kit).
Todos os componentes do projecto SwingLabs, incluindo portanto os componentes SwingX, são focados para uso em ambiente de produção. Entretanto, a Sun não oferece qualquer garantia de suporte e desenvolvimento presente ou futuro para qualquer desses componentes.
Componentes SwingX
* JXCollapsiblePane
* JXComboBox
* JXDatePicker
* JXEditorPane
* JXErrorPane
* JXFindBar
* JXFindPanel
* JXFrame
* JXGlassBox
* JXHyperlink
* JXImagePanel
* JXList
* JXLoginDialog
* JXLoginPanel
* JXMonthView
* JXPanel
* JXRadioGroup
* JXRootPane
* JXSearchPanel
* JXStatusBar
* JXTable
* JXTableHeader
* JXTaskPane
* JXTaskPaneContainer
* JXTipOfTheDay
* JXTitledPanel
* JXTree
* JXTreeTable
SwingX em IDE’s
Componentes SwingX são JavaBeans, por isso podem ser adicionados à paleta de componentes de uma IDE (NetBeans, Eclipse, Intellij) e usados para a construção de GUI’s.
Classes
Maio 8, 2009
-
Defina e desenvolva uma classe ContaBancaria.
As operações que a Conta Bancaria deve premitir são:
-
saldo() – apresentar o saldo da conta associada;
-
levantamento(x) – caso seja possível, realizar um levantamento de importância x;
-
deposito(x) – realizar um deposito da importância x na conta associada;
-
numDeMovimentos() – indicar o número total de depósitos realizados;
-
Devolver e colocar o nome do titular da conta;
-
A conta possuir um numero único (utilizar o numero de contas que vão sendo criadas);
-
numeroDeContas() – indicar o número de contas do banco;
-
SaltoTotal() – Indicar o saldo total do banco;
Crie uma classe de teste que tenha 3 contas bancárias. Utilize os seus métodos para testa-la.
-
Crie um método de classe que recebe como parâmetro um array de inteiros e imprime o seu conteúdo.
-
Crie um array de inteiros, de seguida peça ao utilizador os valores do array, e imprima-os por ordem inversa.
-
Crie um método de classe que recebe como parâmetro um array de inteiros e devolve o valor máximo.
-
Crie um método de classe que recebe como parâmetro um array de inteiros e devolve a posição do array do valor máximo.
-
Crie um método de classe que recebe como parâmetro um array de inteiros e devolve o valor mínimo.
-
Crie um método de classe que recebe como parâmetro um array de inteiros e devolve a posição do array do valor mínimo.
-
Crie um método de classe que recebe como parâmetro dois arrays de inteiros e efectue a multiplicação de cada um dos valores e apresente o resultado, o valores do array devem ser gerados aleatoriamente.
-
Crie um método de classe que recebe como parâmetro dois arrays de inteiros e determine se o seu conteúdo é igual.
-
Crie um novo Package no projecto, chamado de Pck_Outro_modulo12. Adicione uma nova classe a este projecto (nome da classe: TestarImports). Crie um método nesta classe, chamado de utilizaClasseDeOutroPackge. Chame alguns dos métodos criados nas questões anteriores.
-
Crie um método de classe que recebe como parâmetro um array bidimensinal de inteiros e escreve o seu conteúdo.
-
Escreva um programa que gere aleatoriamente uma matriz bidimensioal quadrada.
-
Escreva um programa que some os elementos da diagonal principal de uma matriz bidimensional quadrada, gerada aleatoriamente.
-
Crie um método de classe que recebe como parâmetro um array bidimensinal de inteiros. O método deverá escrever o somatória, média e valor máximo por linha.
-
Pretende-se um programa que leia e armazene os valores respeitantes aos lucros obtidos em cada mês do ano por uma empresa, num conjunto de 5 lojas distintas. Este programa deverá, no final, apresentar o valor total de lucros da empresa, bem como o valor máximo obtido e em que loja este valor foi obtido.
-
Pretende-se um programa que calcule a média e o desvio padrão de uma sequência de n valores inteiros lidos do utilizador. As fórmulas da média e do desvio-padrão são dadas respectivamente por:
-
Crie um método de classe que cria um array de Contas Bancarias de tamanho passado por parâmetro.
-
Crie um array da classe ContaBancaria. Implemente um método que devolva o número do cliente que tem o saldo maior. Implemente também um método que devolva a média de movimentos das contas existentes.
-
Crie um ArrayList da classe ContaBancaria. Crie 10 contas. Implemente um método que devolva o número do cliente que tem o saldo maior. Implemente também um método que devolva a média de movimentos das contas existentes.
-
Crie um método de class que recebe como parâmetro um array de contas bancárias e escreve o nome dos titulares para um ficheiro: nome_dos_titulres.txt.
-
Crie um ficheiro no notepad chamado de saldos.txt, escreva nele:
4500
300
500
6400
132
De seguida crie um método de class que recebe como parâmetro um array de contas bancárias, que actualiza o valor do saldo das contas com o conteúdo lido do ficheiro.
-
Crie um método de class que escreva para um ficheiro de acesso aleatório uma quantidade de números aleatórios (quantidade definida por parâmetro: int x_elementos). De seguida altere, no ficheiro, valor da posição 3 para 777. Abra agora o ficheiro em modo de leitura e mostre o seu conteúdo no ecrã.
Apoio:
int[] lista; //declaração de uma variável de array
int[] lista = {10,20,25,30}; //declaração com inicialização
int[] lista = new int[20]; //array de inteiros com 20 componentes
———-
int[] a = new int[20];
int x=0;
for(int i;i<a.lenght;i++)
x=x+a[i];
//Array de 2 dimensões:
for (int i = 0; i < tabela2D.length; i++){
for (int j=0; j<tabela2D[0].length; j++){
//…
}
———-
Colecções e Tipos Parametrizados
Métodos disponíveis numa List:
E get(int index);
E set(int index, E element); //optional
boolean add(E element); //optional
void add(int index, E element); //optional
E remove(int index); //optional
abstract boolean addAll(int index, Collection<? extends E> c); //optional
//Search
int indexOf(Object o);
int lastIndexOf(Object o);
//Iteration
ListIterator<E> listIterator();
ListIterator<E> listIterator(int index);
//Range-view
List<E> subList(int from, int to);
Iterator<E>
- São objectos utilizados para percorrer todos os elementos de uma colecção (elemento a elemento)
Métodos disponíveis num Interator:
boolean hasNext();
E next();
void remove();
Exemplo:
Calcula a soma das notas dos alunos da turma
List<Aluno> turma = new ArrayList<Aluno>();
…
int soma = 0;
for (Iterator<Aluno> it = turma.iterator(); it.hasNext(); ) {
soma=soma+(it.next().nota());
}
ou
Ciclo com foreach: (java5) muito eficiente
for(T elem : col_iteravel<T>) instruções
-
Com cada elemento elemento de tipo T obtido da colecção iterável, fazer …
Exemplo anterior com foreach:
(Calcula a soma das notas dos alunos da turma)
List<Aluno> turma = new ArrayList<Aluno>();
…
int soma = 0;
for (Aluno aluno : turma){
soma=soma+(aluno.nota());
DADOS, INSTRUÇÕES DE ATRIBUIÇÃO E SELECÇÃO
Maio 8, 2009
-
Escreva um programa que calcule o perímetro de uma circunferência, sendo pedido ao utilizador o tamanho do seu raio ao utilizador.
-
Escreva um programa que determine o inverso de um número real. Proteja devidamente o código (inversão de zero).
-
Escreva um programa que determine se um número, fornecido pelo utilizador, é par ou ímpar.
-
Escreva um programa que associe um valor quantitativo a uma nota qualitativa. (1 =Mau, 2=Medíocre, 3=Suficiente, 4=6om, 5=Excelente).
-
Escreva um programa que gere um número aleatório, o apresente e classifique como par ou ímpar.
-
Escreva um programa que calcula o máximo, o mínimo, a soma e a média de um conjunto de valores inteiros. O numero de valores a introduzir deve ser também pedido ao utilizador.
-
Escreva um programa que, dados os comprimentos dos lados de um triângulo, determine se esse triângulo é equilátero, isósceles ou escaleno.
-
Escreva um programa que peça ao utilizador um número correspondente a um dia da semana e que apresente o nome desse dia (utilizando o comando switch).
INSTRUÇÕES DE REPETIÇÃO
-
Escreva um programa que imprima todos os números compreendidos entre 1 e 100.
-
Escreva um programa que peça ao utilizador um n.º inteiro positivo e escreva todos os números inteiros entre 1 e esse número.
-
Escreva um programa que calcule o menor e o maior de 10 números inteiros introduzidos pelo utilizador.
-
Escreva um programa que calcule e apresente o factorial de um número introduzido pelo utilizador. Proteja devidamente o código.
-
Escreva um programa que utiliza o seguinte array: int a[]={3, 6, 9, 23, 67, 34, 12, 45, 66}, o programa deve fazer a média entre os índices defenido pelo utilizador
Help:
Execução: java –jar teste1.jar
Introdução de dados:
String valor =JOptionPane.showInputDialog(“Digite o primeiro número:”);
Neste exercício/guião iremos implementar um sistema simples de Registo com o objectivo de explicar como funciona os componentes básicos do framework swing (JTextField, JTextArea, JRadioButton, ButtonGroup, JCheckBox, JComboBox, etc), para isso utilizaremos a IDE NetBeans, para construir a interface, aprenderemos como manipular os métodos mais importantes para se trabalhar com estes componentes, e como manipular as suas propriedades.
Introdução
O NetBeans possui uma boa ferramenta para desenvolver a interface gráfica no estilo “Drag and drop” – Arrastar e soltar. Uma palete com diversos componentes disponíveis, onde se tem tem apenas que arrasta-los para dentro de seu Jframe e pronto! O NetBeans gera todo código automaticamente. No final deste guião será capaz de criar seu próprio projecto fazendo uso de inumeras aplicações possíveis com o construtor de interface do NetBeans.
Item 1: Criar um novo projeto do tipo ‘Java Desktop Application’
Através do menu File… crie um novo projecto.
Note que foi gerado um formulário, onde poderá construir toda a interface gráfica, pode redimensioná-la à vontade. Na barra de menu, a direita do ambiente de trabalho, terá dois grupos: Palete e Propriedades. Em palete estará todos os componentes que você pode usar para criar a interface gráfica.
Item 2: Construindo a Interface
Como vamos fazer um sistema simples de Registo, utilizaremos os seguintes componentes:
JPanel: Painel criado em cima do JFrame (tela inicial), que permite entre outras opções, adicionar cor de fundo e borda. É utilizado para organizar melhor a interface.
JLabel: Permite inserir textos e imagens.
JTextField: Caixa de texto para que o utilizador insira os dados no programa. Importante mencionar que todos os dados inseridos em um JTextField são tratados como String. Portanto se for inserir um dado numérico é necessaria a devida conversão.
JTextArea: Campo semelhante ao JTextField, normalmente usado para entrada de textos maiores. Como críticas, sugestões, etc.
JRadioButton: Botão que permite apenas seleção de uma opção quando relacionado a um ButtonGroup.
ButtonGroup: Componente utilizado para criar grupos de JRadioButtons.
JCheckBox: Caixas de multiplas seleções, permite o utilizador marcar várias opções ao mesmo tempo.
JComboBox: Componente semelhante a um vector, que permite ao utilizador escolher apenas uma opção.
JButton: Botão onde serão implementados os eventos.
Agora que já conhece os componentes, monte a interface abaixo:
Item 3: Explicando passo-a-passo
-No exemplo acima, estamos a usar todos os componentes mencionados anteriormente. O JPanel principal apresenta um título ‘Registo’, para colocarmos borda com título a um JPanel deve ir até o botão propriedades, à direita da tela, ou clicar com o botão direito do rato sobre o JPanel e ir até a propriedade border, clique no botão com ‘…’ várias opções de borda serão exibidas, selecione TitledBorder, e no campo Título escreva o título que desejar para o seu JPanel, no nosso exemplo ‘Registo’. Para o JPanel que contém os JCheckBox o tipo de borda é EtchedBorder.
- Para inserir qualquer componente dentro de um JPanel, deve primeiro inserir o JPanel, em seguida os componentes sobre ele. Outra maneira é arrastando os componentes de fora para dentro do JPanel.
-Para inserir itens no JComboBox da opção ‘Estado’, deverá ir na opção model em propriedades, insira o nome do item que você quer que apareça e clique em adicionar.
-Para inserir uma imagem, coloque um JLabel e na opção icon em propriedades, clique em ‘…’, depois botão ‘Import to Project’ e escolha a imagem que deseja adicionar a sua interface, de preferência em .jpg, em seguida apague o que estiver escrito na opção text para deixar somente a imagem.
- Ao transferir o projecto de um computador para outro, certifique-se de que o caminho da imagem seja o mesmo neste computador. Para permitir que seja marcada apenas uma opção nos JRadioButtons, da opção Sexo do registo, deve adicionar ao projeto o componente ButtonGroup, este componente não apresenta nenhum tipo de interface, ao inseri-lo note que ele será adicionado no inspetor de componentes à esquerda da janela. Em seguida vá até as propriedades dos JRadioButtons, opção buttonGroup e escolha buttonGroup1 (nome padrão para este componente), faça isso para ambos os JRadioButtons.
- Para apagar os nomes que vêem dentro dos JTextField, JRadioButtons, JCheckBox e JButtons basta dar duplo clique sobre eles e apagar o que está escrito, ou então na opção text em propriedades.
Item 4: Manipulando o código
Neste guião vamo-nos limitar apenas à implementação dos métodos necessários para a utilização dos componentes inseridos no projeto. Primeiramente, antes de começar a manipular o código, deve-se alterar o nome da variável de todos os componentes que serão utilizados para processar os eventos (entenda ‘eventos’, como sendo basicamente a funcionalidade que você dará a um botão), para que nosso código fique mais legível e organizado. Para alterar o nome de variável de um componente, clique sobre ele, com o botão direito do rato escolha ‘Change variable name…’ e insira o nome que deseja.
No projecto utilizaremos o seguinte padrão:
Para JTextField: campoNomeDaOpção – Ex: campoNome
Para JComboBox: comboNomeDaOpção – Ex: comboEstado
Para JRadioButton: rbNomeDaOpção – Ex: rbMasculino
Para JCheckBox: cbNomeDaOpção – Ex: cbMusica
Para JTextArea: campoNomeDaOpção – Ex: campoBiografia
Para JButton: btNomeDoBotão – Ex: btSalvar
- JLabels e JPanels não necessitam de alteração pois não serão implementados directamente no
tratamento de eventos.
Vamos implementar um evento no botão ‘Salvar’, onde os dados contidos em todos os componentes serão armazenados em um objecto, para isso deve criar uma classe auxiliar que apresente variáveis para todas as opções do Registo (Nome, endereço, sexo, etc), e instanciar o objecto, deverá criar métodos set e get para todas as variáveis, utilizaremos apenas 1 Registo (poderia utilizar array para armzenar vários registos, no entanto o objetivo é ensinar os métodos necessários a implementação dos componentes.
Para inserir um evento de clique a um botão, clique sobre ele, opção ‘Eventos’ > ‘Action’ >
‘actionPermormed’, veja na imagem abaixo:
Repare que o NetBeans leva-o até à área de edição de código e gera o cabeçalho do método que irá tratar o evento:
private void btSalvarActionPerformed(java.awt.event.ActionEvent evt) {
// TODO adicione seu código de manipulação aqui:
}
- Todo código com fundo azul o NetBeans gera-o automaticamente e não pode ser mudado.
Instancie fora do método criado pelo NetBeans o seu objecto:
ClasseAuxiliar obj = new ClasseAuxiliar();
E começe a implementar o código dentro do método criado pelo NetBeans. Para receber os dados inseridos em um JTextField deve utilizar o método getText() da seguinte forma
obj.setText( campoNome.getText() );
Faça o mesmo para os campos Endereço, E-Mail e Telefone.
Para retornar os campos de um JComboBox deve utilizar o método getSelectedItem(). Entretanto para armazenar em uma variável do tipo String deve converte-lo para String, ficando assim:
obj.setEstado( (String)comboEstado.getSelectedItem() );
Para retornar o sexo (Masculino ou Feminino) deve ser feita uma verificação de qual JRadioButton foi marcado pelo utilizador, o método utilizado para isso é isSelected(), desta forma:
if ( rbMasculino.isSelected() )
obj.setSexo( “Masculino” );
else
obj.setSexo( “Feminino” );
Vamos agora para os JCheckBox, para saber quais foram marcados, você deve fazer uma verificação para cada componente. O método utilizado para isso é o mesmo do JRadioButton, isSelected(), vamos adotar que as variáveis de interesses foram declaradas do tipo boolean em sua classe auxiliar, ficando desta maneira:
if ( cbMusica.isSelected() )
obj.setMusica( true );
if ( cbCinema.isSelected() )
obj.setCinema( true );
if ( cbEsporte.isSelected() )
obj.setEsporte( true );
if ( cbInformatica.isSelected() )
obj.setInformatica( true );
Agora falta apenas o JTextArea, que é implementado igualmente ao JTextField usando o método getText(), assim:
obj.setBiografia( campoBiografia.getText() );
Após ser implementado todo os componentes no evento do botão salvar, coloque uma mensagem de confirmação para o utilizador:
JOptionPane.showMessageDialog(null,”Registo realizado com sucesso”);
O Registo está completo, agora vamos para os métodos de exibição.
Após os dados serem salvos deve apaga-los dos seus respectivos campos para usar os espaço para exibição (ou se quiser implementar mais que um registo). Para isso pode-se criar um botão ‘Apagar’ ou simplesmente os dados serão apagados após serem salvos, que é como faremos aqui.
Para apagar o JTextField e o JTextArea utilização o método setText(), ficando desta forma:
campoNome.setText( “” );
comboEstado.setText( “” );
Um JComboBox funciona como se fosse um vector, onde cada item fica em um índice, para desmarcar um
JComboBox utiliza-se o método setSelectedIndex(int i) que recebe como parâmetro um número inteiro
que representa o índice deste JComboBox. Para desmacar usa-se:
comboEstado.setSelectedIndex(-1);
O -1 indica que nenhum item está selecionado.
Para apagar o JRadioButton selecionado, deve-se apagar o grupo inteiro, ou seja o ButtonGroup, para
isso utilizamos o método clearSelection(), da seguinte forma:
if ( rbMasculino.isSelected() || rbFeminino.isSelected() )
buttonGroup1.clearSelection();
O código assima verifica se algum dos JRadioButtons estão selecionados, se verdadeiro, apaga a seleção. Agora só falta apagar os JCheckBox que foram marcados, para isso basta verificar cada um para ver se estão marcados e então, desmarcar. Utilizando o método setSelected( boolean b ), pode-se mudar o estado de um JCheckBox, onde o parâmetro é do tipo boolean e true representa opção marcada, e false desmarcada.
If ( cbMusica.isSelected() )
cbMusica.setSelected( false );
If ( cbCinema.isSelected() )
cbMusica.setSelected( false );
If ( cbEsporte.isSelected() )
cbMusica.setSelected( false );
If ( cbInformatica.isSelected() )
cbMusica.setSelected( false );
Pronto! Todos os campos serão apagados após serem salvos, e agora podemos exibir os dados armazenados.
Item 5: Exibindo Dados
Para exibir os dados que foram armazenados usaremos os mesmos campos onde são preenchidos os dados (os componentes), caso esteja implementando mais que um registo, utilizando uma array, seria interessante criar dois botões ‘Próximo’ e ‘Anterior’ para navegar entre os registos.
Temos agora que criar um evento para o botão ‘Actualizar’ da mesma forma que foi feito para o botão ‘Salvar’. Dentro do método gerado pelo NetBeans vamos implementar o código.
Para exibir em um JTextField e JTextArea, utiliza-se o método setText()
Ex.:
campoNome.setText( obj.getNome() );
- Repita isto para todos os JTextField e para o JTextArea. Atenção para o nome de variável do componente. Para alterar o estado de um JComboBox usamos o método setSelectedItem(), ficando desta forma:
comboEstado.setSelectedItem( obj.getEstado() );
Para selecionar um JRadioButton e JCheckBox, utilizaremos o método setSelected(), devemos verificar qual opção sexual foi escolhida no registo e quais opções foram marcadas nos Interesses, e então selecioná-las, nosso código ficará assim:
if ( obj.getSexo() == “Masculino” )
rbMasculino.setSelected(true);
else
rbFeminino.setSelected(true);
O código acima verifica se a variável sexo é iqual a “Masculino” (como definimos no evento do botão salvar) , então marca o JRadioButton, senão, marca o JRadionButton referente ao sexo feminino.
Para os JCheckBoxs:
If ( obj.getMusica == true )
cbMusica.setSelected(true);
If ( obj.getCinema == true )
cbCinema.setSelected(true);
If ( obj.getEsporte == true )
cbEsporte.setSelected(true);
If ( obj.getInformatica == true )
cbInformatica.setSelected(true);
Verificamos qual dos interesses foram salvos no registo e marcamos para exibição.
Construimos uma interface, aprendemos a tratar eventos, e inserimos os métodos mais importantes para manipular os componentes básicos da API swing.
