Curso de Java Módulo II Swing Fábio Mengue fabio@unicamp.br Centro de Computação - Unicamp Conceitos Swing é um pacote de classes que servem para a construção de GUI's (Graphical User Interface). O pacote foi criado em 1997, e inclui tudo que se necessita para a construção de telas, desde botões até tabelas. Além disso, os programas que utilizam o Swing tem a capacidade de alterar sua interface (chamado de Look and Feel, em inglês), trabalhar com conceitos de acessibilidade (para pessoas com dificuldade de visão ou audição), imagens 2D e suporte a Drag and Drop entre aplicativos Java e nativos. Importando pacotes Swing Como todo programa Java, temos que indicar os pacotes de classes que iremos utilizar. Normalmente temos que importar o pacote abaixo: import javax.swing.*; Mas a maioria dos programas Swing trata com eventos; portanto, também importamos os pacotes: import java.awt.*; import java.awt.event.*; Escolhendo o Look and Feel Existem alguns look and feel que o programa pode usar: Java, Windows, CDE/Motif, e outros. O código abaixo (em negrito) indica como uma aplicação especifica o look and feel : 1 public static void main(string[] args) { try { UIManager.setLookAndFeel( UIManager.getCrossPlatformLookAndFeelClassName()); catch (Exception e) {
//Cria e mostra a GUI O código acima indica que o look and feel Java deve ser utilizado (CrossPlatform). Para utilizar outro (por exemplo, Windows), veja alinha abaixo: UIManager.setLookAndFeel( "com.sun.java.swing.plaf.windows.windowslookandfeel"); Temos ainda: "com.sun.java.swing.plaf.motif.motiflookandfeel" (para CDE/Motif) com.sun.java.swing.plaf.windows.windowslookandfeel (para Windows) javax.swing.plaf.mac.maclookandfeel (para Mac). O look and feel padrão (caso nenhum seja especificado) é o Java (também chamado de Metal). Criando o Container e adicionando componentes 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 design de partes da janela. Segue um pedaço de código de 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.getcontentpane().add(contents, BorderLayout.CENTER); //Mostra o frame frame.addwindowlistener(); frame.pack(); frame.setvisible(true); 2
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 ser comportar. Exemplos de componentes Botões, Check Boxes, Radio Buttons, Grupos de Botões, Itens de Menu, Ícones, Campos Texto, ToolTips, Bordas, ScrollPanes (barras de scroll), Mini Editor (JTextPane), Combo (listas drop-down), ListBoxes, Tabbed Pane (lista de arquivos), Caixas de Mensagem, Menus, Janelas Pop-Up, Objetos de desenho, Caixas de Diálogo, Caixas de escolha de Arquivos, Sliders, Árvores, Tabelas, Áreas de Transferência (clipboard), entre outros. Tipos de layout Abaixo temos uma lista dos componentes mais utilizados na montagem de telas Swing. BorderLayout: é o padrão. Divide a tela em cinco regiões (NORTH, SOUTH, EAST, WEST, CENTER). Todo componente adicionado entra automaticamente no centro, empurrando os outros para as bordas. Você pode incluir um componente em outra região como no exemplo: Container cp = getcontentpane(); cp.add(borderlayout.north, new JButton("North")); cp.add(borderlayout.south, new JButton("South")); cp.add(borderlayout.east, new JButton("East")); cp.add(borderlayout.west, new JButton("West")); cp.add(borderlayout.center, new JButton("Center")); FlowLayout: é o mais simples. Ele simplesmente enche o container com componentes da esquerda pra direita, ata terminar o espaço da linha. Daí, ele faz a mesma coisa na linha abaixo. Todos os componentes sempre terão um espaço do tamanho que eles estão ocupando no momento. GridLayout: permite construir uma tabela de componentes. Ao adicioná-los, eles são colocados da esquerda para a direita e de cima para baixo em uma grade. Você pode especificar o número de colunas e linhas que serão necessárias, e todas terão o mesmo tamanho. Se existir menos componentes do que o total de espaços, eles ficarão vazios. Caso contrário, o componente excedente não será mostrado. Por exemplo: Container cp = getcontentpane(); cp.setlayout(new GridLayout(7,3)); 3
GridBagLayout: permite maior controle que o GridLayout. Neste layout você pode definir exatamente como as regiões da sua grade irão se comportar e reformatar caso a janela tenha seu tamanho alterado. Entretanto, é o gerenciador mais complexo de utilizar. Ele foi criado para ser utilizado por programas de criação de GUI s. Absolute positioning: permite posicionamento absoluto dos componentes. É uma das piores maneiras de gerenciar o layout, pois não permite flexibilidade quando a janela tem seu tamanho alterado. Para utiliza-lo: Container cp = getcontentpane(); cp.setlayout(null); E depois utilize o método setbounds() para cada um dos componentes, indicando onde ele inicia e termina. Basta adicionar ao container depois disso. BoxLayout: é uma versão simplificada do GridBagLayout. Permite indicar a localização dos componentes horizontalmente e verticalmente, além de permitir o controle da distância entre eles. Veja o exemplo: JPanel jpv = new JPanel(); jpv.setlayout(new BoxLayout(jpv, BoxLayout.Y_AXIS)); for(int i = 0; i < 5; i++) jpv.add(new JButton("" + i)); JPanel jph = new JPanel(); jph.setlayout(new BoxLayout(jph, BoxLayout.X_AXIS)); for(int i = 0; i < 5; i++) jph.add(new JButton("" + i)); Container cp = getcontentpane(); cp.add(borderlayout.east, jpv); cp.add(borderlayout.south, jph); O construtor do gerenciador BoxLayout é diferente dos outros. Você indica um container que deve ser gerenciado como um primeiro argumento e a direção do layout como segundo argumento. Conclusão: Swing é um pacote muito poderoso. Poucas linhas podem fazer muito. A grande idéia aqui é misturar os gerenciadores, combinando os simples com os complexos. Entretanto, como todo desenho de GUI, é mais produtivo apelar para um produto que permita o desenho com mouse, sem perder tempo precioso desenhando tudo na base do codifica-compila-executa. 4
Outros containers Vimos que por vezes, para que o design saia certo, devemos utilizar vários layout managers simultaneamente. A utilização de qualquer subclasse de Container permite que agrupemos componentes para que eles sejam mostrados e tratados como apenas um conjunto. Normalmente, a preferência sempre recai sobre o JPanel. Disparando eventos A maioria das aplicações deve ter alguns componentes que apresentem a tela da maneira que o usuário quer ver. Esses componentes muitas vezes são apenas informativos e um tanto inertes (como os labels, por exemplo), mas outros são criados com o propósito de realizar serviço (como os botões, por exemplo). Devido à natureza orientada a objetos do Java, o código a ser executado quando um botão é pressionado normalmente pertence a outro objeto, que possui a lógica de negócio. Esse objeto deve ser um método, a ser invocado pelo botão quando este for clicado, por exemplo. A maneira Java de fazer isso é criando ouvidores (chamados de Listeners), ligados ao botão. Do ponto de vista do botão, o Listener é uma lista de objetos a serem invocados quando acontecer uma ação (um clique de mouse, por exemplo). Do ponto de vista do objeto, ele deve implementar um método com um nome especial, e esse método será invocado automaticamente na chamada. Tome como exemplo o código abaixo: MeuExemplo Objeto = new MeuExemplo(); JButton button = new JButton("OK"); button.addactionlistener(objeto); A partir de agora, quando button for clicado, ele irá realizar uma chamada a MeuObjeto. Temos uma lista de tipos de componentes e os eventos por eles gerados a seguir: Evento ActionEvent AdjustmentEvent FocusEvent, KeyEvent, MouseEvent WindowEvent ItemEvent TextEvent Classes que geram esse evento JButton, JList, JTextField, JMenuItem, JCheckBoxMenuItem, Jmenu, JPopupMenu Jscrollbar Component Window, including JDialog, JFileDialog, Jframe JCheckBox, JCheckBoxMenuItem, JComboBox, Jlist JTextComponent, JTextArea, JTextField 5
Lidando com Eventos O trabalho de lidar com eventos quase sempre acompanha as aplicações que utilizam Swing. Mesmo que o aplicativo não tenha botões, pode acontecer o fechamento da janela, o que por si só é um evento. Normalmente existem botões e campos de texto, que eles lidam com eventos criando uma lista de objetos a serem informados. Os objetos, por sua vez, devem criar um método especial para atender o evento. Veja o exemplo: class MeuExemplo implements ActionListener { public void actionperformed(actionevent e) { System.out.println ( Quem causou o evento foi + e.getsource()); A classe deve implementar uma certa interface. A palavra reservada implements exige que essa classe defina um certo método especial que será executado quando o evento ocorrer. A classe pode implementar vários Event Listeners, conseqüentemente possuindo vários métodos especiais. Temos uma lista deles: Interface ActionListener AdjustmentListener ComponentListener ComponentAdapter FocusListener FocusAdapter KeyListener KeyAdapter MouseListener MouseAdapter MouseMotionListener MouseMotionAdapter WindowListener WindowAdapter Métodos da interface actionperformed(actionevent) adjustmentvaluechanged( AdjustmentEvent) componenthidden(componentevent) componentshown(componentevent) componentmoved(componentevent) componentresized(componentevent) focusgained(focusevent) focuslost(focusevent) keypressed(keyevent) keyreleased(keyevent) keytyped(keyevent) mouseclicked(mouseevent) mousereleased(mouseevent) mousedragged(mouseevent) mousemoved(mouseevent) windowopened(windowevent) windowclosing(windowevent) windowclosed(windowevent) windowactivated(windowevent) windowdeactivated(windowevent) windowiconified(windowevent) windowdeiconified(windowevent) 6
Lidando com Threads Se seu programa cria e utiliza a GUI normalmente, seu programa é dito single threaded. Isso quer dizer que apenas componentes incluídos na mesma thread irão manipular a GUI, tornando desnecessária a preocupação com a situação eventual em que outra thread tente acessar a GUI ao mesmo tempo. A construção normal de um programa Swing segue o padrão abaixo: public class MeuPrograma { public static void main(string[] args) { JFrame f = new JFrame(); //Adicione os componentes f.pack(); f.setvisible(true); //Não crie mais nada aqui. //Toda a manipulação -- settext, gettext, etc. -- //deve ser feita usando eventos como actionperformed(). No código acima, a construção da GUI está na thread principal. Você pode construir sua GUI em qualquer thread, desde que você não faça nenhuma chamada depois do pack(), que acontece apenas no método main(). A única instrução que deve vir após é o setvisible(). Essa técnica torna a aplicação thread safe. Entretanto, a linguagem Java permite que se crie programas que utilizam múltiplas threads. No caso da programação Swing, se algum destes códigos afetar a GUI que já está visível sem utilizar os eventos programados (que é onde o Java para tudo para esperar o retorno do método), você tem um problema a mais a tratar. Usando threads A primeira regra para utilizar threads é: evite usar threads. Elas são difíceis de lidar, tornam o programa mais complicado para manutenção e aumentam a chance de erros ocorrerem. Tudo isso acontece porque o programador pode se esquecer de imaginar uma certa situação que pode simplesmente fazer com que o programa pare de responder caso um evento ocorra. Para isso, deve-se tomar precauções para que nenhuma thread crie chamadas para qualquer método de componente Swing. Se a chamada for necessária, ela deve ser feita através de um evento. Apesar de seus perigos, o uso de threads pode ser muito útil, e as vezes, imprescindível. Como fazer com que meu aplicativo continue respondendo ao usuário ao mesmo tempo em que me mostra um relógio? Normalmente as threads são utilizadas em casos onde o programador deseja duas (ou mais) linhas de execução. Meu programa pode contar o tempo, aguardar uma 7
interrupção de uma fonte externa de dados e ao mesmo tempo responder aos comandos do usuário. Veja o exemplo abaixo: CapturaEvento ce = new CapturaEvento(); Button b = new Button( OK ); b.addactionlistener(ce); Definição de CapturaEvento: class CapturaEvento implements ActionListener { public void actionperformed(actionevent e) { tratabotao(); private void tratabotao() { int count = 0; while (true) { Thread.sleep(5); count++; O que deve acontecer no programa acima? Ele funciona? Ao lidar com o evento, o programa irá executar o método tratabotao(). Depois de ficar 5 segundos parado, incrementa o contador, e começa tudo novamente. Note que o programa que gerou o evento (e chamou o CapturaEvento) está esperando um retorno, que nunca irá acontecer, pois o loop feito no método tratabotao() é infinito. Para o usuário, a tela simplesmente congela. Assim, o método tratabotao() deve continuar a contar, mas a interface deve continuar a responder. Deve-se criar outra thread para resolver o problema. A maneira mais fácil é gerando uma subclasse de Thread, como no exemplo abaixo: public class SimpleThread extends Thread { private int countdown = 5; private static int threadcount = 0; private int threadnumber = ++threadcount; public SimpleThread() { System.out.println("Making " + threadnumber); public void run() { 8
while(true) { System.out.println("Thread " + threadnumber + "(" + countdown + ")"); if(--countdown == 0) return; public static void main(string[] args) { for(int i = 0; i < 5; i++) new SimpleThread().start(); System.out.println("All Threads Started"); Quando estamos extendendo a classe Thread, devemos sobrecarregar o método run(), que é a porção de código que irá se repetir em todas as threads. Temos também métodos para iniciar e parar uma thread (start() e terminate()) Qual seria o resultado da execução do código acima? Agora podemos resolver o problema de nosso programa usando uma thread. O truque é colocar o nosso loop infinito dentro de um método run(). No caso de nosso exemplo com Swing, poderíamos fazer algo do tipo: class CapturaEvento implements ActionListener { public void actionperformed(actionevent e) { TrataBotao b = new TrataBotao(); class TrataBotao extends Thread { TrataBotao() { start(); void run() { int count = 0; while (true) { Thread.sleep(5); count++; SwingUtilities.invokeLater(getTextFieldText); System.out.println(myStrings[0] + " " + mystrings[1]); A utilização de Threads implica ainda no entendimento de acessos concorrentes ao mesmo recurso, que pode gerar um deadlock ou mesmo uma exceção. O Java possui uma 9
maneira de controlar essas colisões. É a palavra reservada synchronized. Ela evita que mais de uma thread tenha acesso a um recurso ao mesmo tempo: public synchronized void run() { while (true) { t1.settext(integer.tostring(count1++)); t2.settext(integer.tostring(count2++)); sleep(500); Existe ainda controle de estado de threads (bloquear, parar, terminar, etc.), prioridades, métodos para notificar outras threads, que permite que controlemos nossas threads e implementemos serviços tão complexos quanto daemons. Quando mal utilizadas, o mínimo que acontece é que seu programa fica lento. A complexidade e as patologias (como acabar com os recursos da máquina, entrar em condições de corrida e deadlock) muitas vezes justificam a não utilização deste tipo de recurso. Mas esses assuntos fogem do escopo deste curso. Recomendamos a leitura da bibliografia indicada para maiores informações. Bibliografia The Java Tutorial http://www.sun.com/docs Eckel, Bruce. Thinking in Java, 2nd edition, Revision 12 Horstmann, Cay S., Cornell, Gary. Core Java. Makron Books Proibida a alteração, reprodução e cópia de parte deste material para qualquer finalidade sem a permissão do Centro de Computação da Unicamp. A utilização deste material é permitida desde que conste a autoria do mesmo. 2002 Centro de Computação da Unicamp. 10