Aula 11 - LPG

Prévia do material em texto

AULA 11 - CCT0024 – Linguagem de Programação 
 
 
Objetivos 
 
 Recordando... 
Até agora nossas aplicações utilizaram uma janela de texto (console) para entrada e saída de 
dados. A maioria dos aplicativos que utilizamos no dia-a-dia, entretanto, utiliza janelas com 
diversos recursos gráficos para interagir com o usuário, como campos de edição, botões e 
outros objetos gráficos que compõem o que se chama uma Interface Gráfica (GUI). 
 
 As Interfaces gráficas em Java 
O Java fornece uma infinidade de funcionalidades para prover comunicação humano-
computado, ou melhor, para desenvolver interfaces. São fornecidas duas bibliotecas para 
desenvolver um GUI
1
. Elas são: 
java.awt : Abstract Window Toolkit (classes básicas); 
javax.swing : Swing Componets – Fornece um conjunto de components alternativos, mais 
funcionais que os conjuntos fornecidos pela java.awt. 
Estas bibliotecas são fornecidas pelo JFC
2.
 
Na figura abaixo, podemos ver a hierarquia das classes das bibliotecas gráficas. 
 
 
 
1 Graphical User Interface 
2 Java Foundation Classes 
 Introduzir o conceito de interfaces gráficas (GUI) 
 Apresentar os componentes Swing e sua hierarquia 
 Criar interfaces gráficas com componentes Swing 
 
 
 
 Portabilidade 
As APIs de interface gráfica do Java favorecem ao máximo o lema de portabilidade da 
plataforma Java. O look and feel do Swing é único em todas as plataformas onde roda 
(Windows, Linux ...); isso quer dizer que a aplicação terá exatamente a mesma interface 
(cores, tamanhos etc). Grande parte da complexidade das classes e métodos do Swing está 
no fato da API ter sido desenvolvida tendo em mente o máximo de portabilidade possível. 
Favorece, por exemplo, o posicionamento relativo de componentes em detrimento do uso de 
posicionamento relativo que poderia prejudicar usuários com resoluções de tela diferentes da 
prevista. Com Swing, não importa qual sistema operacional, qual resolução de tela ou qual 
profundidade de cores: sua aplicação se comportará da mesma forma em todos os ambientes. 
 
 Usando interfaces gráficas 
Uma GUI é construída a partir de componentes, também chamados de controles ou widgets 
(window gadgets) em outras linguagens. Um componente GUI é um objeto com o qual o 
usuário interage via mouse, teclado ou outro formulário de entrada. Exemplos de GUI são as 
janelas de aplicativos como o Internet Explorer, Word, etc,... 
 A biblioteca do Swing está toda no pacote javax.swing (exceto a parte de acessibilidade que 
está em javax.accessibility). Um primeiro exemplo com Swing pode ser a exibição de uma janela 
de mensagem contendo algum texto. Vamos usar para isso a classe JoptionPane, que possui um 
método estático chamado showMessageDialog. 
 
O primeiro argumento recebido pelo método showMessageDialog indica qual é o componente 
pai (no nosso caso, null porque não temos mais componentes); e o segundo indica a mensagem a 
ser exibida. Há outro método sobrecarregado onde se pode configurar o título da janela, o tipo de 
mensagem ou até o ícone a ser exibido. Nesta classe JoptionPane, há ainda outros métodos para 
exibir janelas de confirmação (Ok/Cancelar) e janelas para entrada de dados pelo usuário (input). 
Mais adiante em nosso curso voltaremos a falar nestes métodos desta classe. 
 
 
 
 Hierarquia de classes 
 
 
 Top Level Containers (TLC) 
 
Todo programa Swing deve ter pelo menos um container (também chamado top-level 
container). Normalmente ele é um JFrame (uma janela completa, com decorações). Cada 
JFrame representa uma janela. O JFrame provê o suporte para outros componentes, no tocante 
a hierarquia e trabalho com eventos. 
O JFrame possui duas divisões. Uma delas é o ContentPane, que representa a parte da janela 
onde podemos montar nossa aplicação. O ContentPane na verdade é um JPanel, um outro 
container que normalmente é utilizado para receber componentes que fazem parte do mesmo 
contexto de layout. Isso é necessário para separar o desing de partes da janela. 
 
 
 
 
Exemplo: 
public class MinhaAplicacao { 
.... 
public static void main(String [] args){ 
... 
JFrame frame = new JFrame ("Minha Aplicação"); 
//...cria os componentes e os insere no frame ... 
frame.getComponentPane().add(contents,BorderLayout.CEN TER); 
//Mostra o frame 
frame.addWindowListener(...); 
frame.pack(); 
frame.setVisible(true); 
} 
} 
 
 
No programa principal, a primeira linha cria o JFrame. Depois de incluir os elementos 
desejados na GUI, cria-se o gerenciador de layout que indica aos elementos dentro do 
container como eles devem se comportar. Um objeto do tipo JFrame contém os elementos 
básicos para manipularmos uma janela: abrir, fechar, mover e redimensionar. A uma 
janela poderemos adicionar outros componentes gráficos. 
 
 
 Alguns métodos da classe JFrame: 
 atribuir um título 
setTitle(“My First Subclass"); 
 
 dimensionar a janela 
setSize ( 300, 200 ); // (300 pixels de largura e 200 pixels de altura) 
 
 posicionar a janela no ponto de coordenadas (150, 250) 
setLocation ( 150, 250 ); 
 
 requerer que o programa termine quando a janela éfechada 
setDefaultCloseOperation(EXIT_ON_CLOSE); 
 
 
 
 
Para construir uma interface gráfica podemos definir uma subclasse de JFrame. Nessa 
subclasse iremos adicionar o comportamento necessário à interface que pretendemos. 
A classe Janela1 define uma janela com as características anteriores e com o fundo branco: 
 
import javax.swing.*; 
import java.awt.*; 
public classJanela1extends JFrame{ 
 
private staticfinalintFRAME_WIDTH = 300; 
private staticfinalintFRAME_HEIGHT = 200; 
private staticfinalintFRAME_X_ORIGIN = 150; 
private staticfinalintFRAME_Y_ORIGIN = 250; 
 
publicJanela1(){ 
setTitle( “Subclasse de JFrame com fundo branco" ); 
setSize(FRAME_WIDTH, FRAME_HEIGHT); 
setLocation(FRAME_X_ORIGIN, FRAME_Y_ORIGIN); 
setDefaultCloseOperation( EXIT_ON_CLOSE ); 
alterarCorFundo( ); 
} 
 
private void alterarCorFundo() { 
Containercontentor =getContentPane(); 
contentor.setBackground(Color.white); 
} 
 
public static void main(String[]args) { 
Janela1 j =newJanela1(); 
j.setVisible(true); 
} 
}// fim da classe Janela1 
 
 
 
 
 Componentes Atômicos 
São elementos ou componentes que não permitem conter outros elementos. Podemos 
citar, dentre outros, botões, labels, textFields, sliders, check boxes, scrollbars, etc. 
 
JLabel 
 
São rótulos estáticos que geralmente apresentam 
funcionalidades de outros componentes GUI, como 
por exemplo, campos de texto, ícones, etc. Também 
serve para apresentar um pequeno texto. As 
instruções são mostradas por meio de uma linha de 
texto somente leitura, uma imagem, ou ambos. O 
construtor mais elaborado é JLabel (String, Icon, int). 
Os argumentos representam o rótulo a ser exibido, um 
ícone e o alinhamento, respectivamente. Também é 
possível a exibição de ícones em muito dos componentes Swing. Para JLabels, basta 
especificar um arquivo com extensão png, gif ou jpg no segundo argumento do construtor 
do JLabel, ou utilizar o método setIcon(Icon), o arquivo da imagem algumNome.xxx deve 
encontrar-se no mesmo diretório do programa, ou especifica-se corretamente a estrutura 
de diretórios até ele. 
As constantes SwingConstants, que definem o posicionamento de vários componentes GUI 
e aqui são apropriadas ao terceiro argumento, determinam a locação do ícone em relação 
ao texto. São elas: 
 
• SwingConstants.NORTH, 
• SwingConstants.SOUTH, 
• SwingConstants.EAST, 
• SwingConstants.WEST, 
• SwingConstants.TOP, 
• SwingConstants.BOTTOM, 
• SwingConstants.CENTER, 
• SwingConstants.HORIZONTAL,• SwingConstants.VERTICAL, 
• SwingConstants.LEADING, 
• SwingConstants.TRAILING, 
• SwingConstants.NORTH EAST, 
• SwingConstants.NORTH WEST, 
• SwingConstants.SOUTH WEST, 
• SwingConstants.SOUTH EAST, 
• SwingConstants.RIGHT, 
• SwingConstants.LEFT 
 
 
 
 
 
 
Botões 
É um componente que tem o comportamento semelhante ao de um botão real, quer dizer, 
ao clicarmos ou apertarmos o botão, uma ação é executada. Um programa Java pode 
utilizar vários tipos de botões, incluindo botões de comando, caixas de marcação, botões 
de alternância e botões de opção. Para se criar algum desses tipos de botões, deve-se 
instanciar uma das muitas classes que descendem da classe AbstractButton, a qual define 
muito dos recursos que são comuns aos botões do Swing. Este comportamento semelhante 
ao mundo real ajuda aos usuários na compreensão da interface. 
 
JButton 
 
É um dos componentes mais familiares e intuitivos ao 
usuário. Os botões de comando são criados com a 
classe JButton e seu pressionamento geralmente 
dispara a ação especificada em seu rótulo, que 
também suporta a exibição de pequenas imagens. Ao 
pressionar o botão, é gerado um evento ActionEvent 
que, juntamente com outros eventos, executam algum 
comando desejado. Estudaremos a fundo este 
comportamento na próxima aula. 
 
 
 
 
JCheckBox 
 
A classe JCheckBox dá suporte à criação de botões 
com caixa de marcação, sendo que qualquer número 
de itens pode se selecionado. Quando um item é 
selecionado, um ItemEvent é gerado. O mesmo pode 
ser tratado por um objeto que implemente a 
interface ItemListener. A classe que fornece as 
funcionalidades para este objeto deve definir o 
método itemStateChanged, mas isso será visto na 
próxima aula. 
 
 
 
JRadioButton 
 
Os botões de opção, que são definidos na 
classe JRadioButton, assemelham-se às caixas 
de marcação no que concerne aos seus estados 
(selecionado ou não selecionado). Entretanto, 
costumeiramente são usados em grupo no qual 
apenas um botão de opção pode ser marcado, 
forçando os demais botões ao estado não-
selecionado. 
 
 
 
 
JTextField 
 
Compreende a área de uma única linha que 
suporta a inserção ou exibição de texto. Pode-se 
definir se o texto pode ser manipulado com o 
método setEditable(boolean), utilizando no 
argumento o valor true. Quando o usuário digita 
os dados em uma JTexField e pressiona Enter, 
ocorre um evento de ação. Esse evento é 
processado pelo ouvinte de evento registrado 
que pode usar os dados que estão no JTexField 
no momento em que o evento ocorre. Estes 
procedimentos serão mais bem abordados na 
próxima aula. 
 
 
 
JPasswordField 
 
É uma subclasse de JTextField e acrescenta vários 
métodos específicos para o processamento de 
senhas. Sua aparência e comportamento quase 
nada diferem de uma JTextField, a não ser 
quando o texto é digitado, pois o mesmo fica 
ocultado pelos asteriscos. Tal procedimento se 
justifica para ocultar os caracteres inseridos, 
dado que esse campo contém uma senha. 
 
 
 
JTextArea 
 
É uma área dimensionável que permite 
que múltiplas linhas de texto sejam 
editadas com a mesma fonte. Esta classe é 
herdada de JTextComponent, que define 
métodos comuns para JTextField, 
JTextArea e outros elementos GUI 
baseados em texto. 
As JTextAreas não têm eventos de ação 
como os objetos da classe JTextField, cujo 
o pressionamento de Enter gera um evento. Então, utiliza-se um outro componente GUI 
(geralmente um botão) para gerar um evento externo que sinaliza quando o texto de uma 
JTextArea deve ser processado. Pode-se configurar um texto com setText (String) ou 
acrescentar texto com o método append (String). Para evitar que um longo texto digitado fique 
incluso em somente uma linha, usa-se o método setLineWrap (boolean), que define a quebra 
da linha quando o texto alcançar a borda da JTextArea. Porém, as palavras podem ficar 
“quebradas”, com caracteres em uma linha e outros na próxima, sem nenhum compromisso 
com as normas gramaticais. Uma maneira de sanar paliativamente esse problema é invocar o 
método setWrapStyleWord (boolean), o qual determina que a mudança de linha seja definida 
pelas palavras. 
 
JScrollPane 
 
Objetos dessa classe fornecem a capacidade de rolagem a 
componentes da classe JComponent, quando estes necessitam 
de mais espaço para exibir dados. JScrollpane (Component, int, 
int) é o construtor mais elaborado e recebe um componente 
(JTextArea por exemplo) como primeiro argumento, definindo 
qual será o cliente do JScrollPane, ou seja, para que membro 
será fornecido as barras de rolagem. Os dois próximos 
argumentos definem o comportamento da barra vertical e da 
horizontal, respectivamente. Para isso, pode-se fazer uso das 
constantes definidas na interface ScrollPaneConstants que é 
implementada por JScrollPane. Veja elas: 
 
JScrollPane.VERTICAL SCROLLBAR AS NEEDED 
JScrollPane.HORIZONTAL SCROLLBAR AS NEEDED Indicam que as barras de rolagem devem 
aparecer somente quando necessário. 
JScrollPane.VERTICAL SCROLLBAR ALWAYS 
JScrollPane.HORIZONTAL SCROLLBAR ALWAYS Indicam que as barras de rolagem devem 
aparecer sempre. 
JScrollPane.VERTICAL SCROLLBAR NEVER 
JScrollPane.HORIZONTAL SCROLLBAR NEVER Indicam que as barras de rolagem nunca devem 
aparecer. 
 
É possível configurar o comportamento do JScrollPane para um objeto com os métodos 
setVerticalScrollBarPolicy(int) e setHorizontalScrollBarPolicy(int), valendo-se das mesmas 
constantes como argumentos. 
 
 
 
JSlider 
 
É um marcador que desliza entre um intervalo de valores 
inteiros, podendo selecionar qualquer valor de marca de 
medida em que o marcador repouse. Uma das inúmeras 
utilidades desse controle deslizante é restringir os valores 
de entrada em um aplicativo, evitando que o usuário 
informe valores que causem erros. Os JSlider comportam a 
exibição de marcas de medidas principais, secundárias e 
rótulos de medida. A aderência às marcas (snap to ticks) 
possibilita ao marcador aderir à marca mais próxima, 
quando este situar-se entre dois valores. Este componente 
responde às interações feitas pelo mouse e pelo teclado (setas, PgDn, PgUp, Home e End). Sua 
orientação pode ser horizontal, na qual o valor mínimo está situado na extrema esquerda, ou 
vertical, na qual o valor mínimo está situado na extremidade inferior. As posições de valor 
mínimo e máximo podem ser invertidas, valendo-se do método setInvert(boolean), com um 
argumento true. 
 
 
 
 
JComboBox 
 
Assemelha-se a um botão, porém, quando 
clicado, abre uma lista de possíveis valores ou 
opções. Mais precisamente é uma caixa de 
combinação que permite ao usuário fazer uma 
seleção a partir de uma lista de itens. Atende-
se para que a lista da caixa de combinação, 
quando aberta, não ultrapasse os limites da 
janela da aplicação. Também é possível digitar 
nas linhas de uma caixa de combinação. Elas 
são implementadas com a classe JComboBox, 
herdada de JComponent. Tais caixas de 
combinação geram ItemEvents, assim como as 
JCheckBoxes. 
 
 
Menus 
 
Os menus talvez sejam os componentes que 
mais aparecem nas ferramentas 
computacionais. Geralmente eles são 
encontrados no topo da janela da aplicação, de 
onde dão suporte à organização e agrupamento 
de funções afins em um mesmo contexto visual, 
o que facilita muito a localização e 
entendimento por parte do usuário, já que a 
estrutura de cada menu está delineada pelas 
características dos itens. 
Os menus, que são instanciados a partir da 
classe JMenu, são anexados a uma barra de 
menus com o método add(JMenu) de 
JMenuBar, sendo que instâncias dessa última classe comportam-se como containers para 
menus. A classe JMenuBar fornece os métodos necessários ao gerenciamento da barra onde os 
menus são anexados. A ordenação dos mesmos dependeda ordem em que foram adicionados, 
sendo que são “empilhados” horizontalmente da esquerda para a direita. Evidentemente, só 
pode-se anexar menus a janelas da classe JApplet, JDialog, JFrame e JInternalFrame, e se faz 
isso usando-se o método setJMenuBar(JMenuBar). A classe JMenuItem capacita a criação de 
itens de menu que, por sua vez, devem ser anexados a um menu. Pode-se usar um item de 
menu para executar alguma ação ou para gerir o acionamento de um submenu, o qual fornece 
mais itens que estão relacionados por alguma característica comum. 
 
 
 
 
Passo a passo para montagem de um menu em barras em Java: 
1. Instancie um JMenuBar. Ele é o responsável pela estrutura do menu. 
2. Adicione tantos JMenu’s quantos forem necessários para as opções. 
a. Dentro de cada JMenu, coloque o JMenuItem, que é o responsável pela 
opção a ser escolhida. 
 
Trecho do código para montar a barra de menus apresentada na figura acima: 
 
 jMenuBar1.setName("jMenuBar1"); 
 
 jMenu1.setText("Arquivo")); // Aba Arquivo da barra de opções 
 jMenu1.setName("jMenu1"); 
 
 jMenuItem1.setText("Abrir")); // Opção Abrir do menu 
 jMenuItem1.setName("jMenuItem1"); 
 jMenu1.add(jMenuItem1); 
 
 jMenuItem2.setText("Editar")); // Opção Editar do menu 
 jMenuItem2.setName("jMenuItem2"); 
 jMenu1.add(jMenuItem2); 
 
 jMenuItem3.setText("Salvar")); // Opção Ajuda do menu 
 jMenuItem3.setName("jMenuItem3"); 
 jMenu1.add(jMenuItem3); 
 
 jMenuBar1.add(jMenu1); //Inclui o menu Arquivo na barra de menus 
 
 jMenu2.setText("Ajuda")); // Aba Ajuda da barra de opções 
 jMenu2.setName("jMenu2"); 
 
 jMenuItem4.setText("Ajuda")); // Opção Ajuda do menu 
 jMenuItem4.setName("jMenuItem4"); 
 jMenu2.add(jMenuItem4); 
 
 jMenuItem6.setText("Pesquisa")); // Opção Pesquisa do menu 
 jMenuItem6.setName("jMenuItem6"); 
 jMenu2.add(jMenuItem6); 
 
 jMenuItem5.setText("Sobre")); // Opção Sobre do menu 
 jMenuItem5.setName("jMenuItem5"); 
 jMenu2.add(jMenuItem5); 
 
 jMenuBar1.add(jMenu2); //Inclui o menu Ajuda na barra de menus 
 
 jMenu3.setText("Sair")); // Aba Sair da barra de opções 
 jMenu3.setName("jMenu3"); 
 jMenu3.add(jMenuItem7); 
 
 jMenuBar1.add(jMenu3); //Inclui o menu Sair na barra de menus 
 
 
 
 
 
Nosso primeiro formulário 
A maioria das aplicações gráficas do mundo tem, em algum momento, algum formulário 
para entrada de dados. Vamos criar então um formulário bem simples utilizando Swing. A 
API do Swing traz uma série de componentes visuais prontos para uso. São campos de texto, 
botões, checkboxes, labels, tabelas, árvores e muitos outros. Para começar nosso 
formulário iremos usar dois componentes: um campo de texto (JTextField) e uma 
etiqueta/label (JLabel): 
 
 
 
 
Todo componente Swing deve ser adicionado a um contêiner (Container) que administrará o 
agrupamento e exibição dos mesmos. Usaremos o container mais comum, um Jpanel (algo 
como um painel de componentes). Através de seu método add conseguimos adicionar nossos 
componentes: 
 
 
Por último, para exibirmos nosso formulário simples, precisamos colocar nosso Jpanel em 
uma janela. Usaremos a classe JFrame, que representa uma janela simples. 
 
 
O método pack() de JFrame, chamado acima, serve para redimensionar nosso frame para um 
tamanho adequado baseado nos componentes que ele tem. E o setVisible recebe um boolean 
indicando se queremos que a janela seja visível ou não. Vamos apenas adicionar um último 
comando que indica ao nosso frame que a aplicação deve ser terminada quando o usuário 
fechar a janela. 
 
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); 
 
 
No exemplo completo a seguir, colocamos todas as variáveis como atributos e criamos um 
método chamado montaFormulario com todo o código explicado antes. No método main, 
criamos um novo Formulario e chamamos o método montaFormulario(): 
 
 
Ao rodar este programa, teremos a seguinte tela para digitação do nome: