Principais Classes Swing AWT

Transcrição

1 Principais Classes Swing AWT As classes e interfaces localizadas nos pacotes java.awt e javax.swing são recursos para o desenvolvimento de GUIs (Graphic User Interface Interface Gráfica do Usuário). Uma GUI é desenvolvida utilizando-se componentes, que são objetos visuais que possibilitam ao usuário realizar a interação com o programa por meio do mouse e do teclado. Os componentes mais comuns são: rótulos (Label), botões (button), campo de texto (text field), áreas de texto (text area), caixas de checagem (check box), botões de rádio (radio button), listas (list) e menus. Na versão 1.0 de Java, encontramos um pacote chamado AWT (Abstract Window Toolkit kit de ferramentas de janelas abstratas) contendo todas as classes necessárias para a construção de GUIs. A estratégia adotada, naquele momento, para tratar dos elementos da interface do usuário fora delegar a sua criação e seu comportamento ao kit de ferramentas nativo do sistema operacional específico onde fossem criados. Algum tempo depois se verificou que os componentes apresentavam diferenças entre as diversas plataformas e isto dificultava a construção de GUIs. Além disto, ocorriam erros diferentes com os componentes em cada plataforma, obrigando os desenvolvedores a testar seus aplicativos em cada uma delas. Devido a este problema, a Sun começou a desenvolver uma nova biblioteca de componentes que aperfeiçoasse o método adotado. Essa biblioteca foi chamada de Swing e passou a ser o nome oficial do kit de componentes para a construção de GUIs. O pacote Swing não é sobrecarregado com as complexas capacidades da plataforma em que são utilizados e, por isto, são freqüentemente chamados de peso leve. Ao contrário, os componentes AWT precisam contar com o sistema de janelas da plataforma local para determinar sua funcionalidade, sua aparência e seu comportamento. Entretanto, alguns componentes Swing ainda requerem interação direta com o sistema local de janelas, como é o caso de todas as classes derivadas de Window (como JFrame). Os componentes AWT continuam disponíveis nas últimas versões do J2SDK e encontra-se no pacote java.awt. Os componentes Swing foram dispostos no pacote javax.swing. 1

2 Component A classe Component representa as características comuns de todos os componentes, ou seja, de todos aqueles objetos que possuem uma representação gráfica, que podem interagir com o usuário e que possuem uma aparência e um comportamento. Container A classe Container representa um contêiner,ou seja, um componente que pode abrigar dentro de si outros componentes. Os contêineres criados com a classe Container funcionam como painéis e janelas, que abrigam outros contêineres e/ou componentes que aparecem na tela. A classe javax.swing.jframe JFrame é um container de janela e é uma versão estendida da classe java.awt.frame que adiciona suporte à arquitetura dos componentes Swing. Entretanto, ela é incompatível com a classe Frame. Para adicionar um componente a um JFrame é preciso invocar o método add() do objeto que representa seu painel de conteúdo. Como esse objeto não pode ser acessado diretamente, deve-se recuperá-lo utilizando o método getcontentpane() da janela. A instrução para adição de um componente a um JFrame deve, então obedecer ao seguinte padrão. JFrame f = new JFrame (); f.getcontentpane().add(<nome do Componente>); 2

3 Veja abaixo um exemplo da utilização do container JFrame. import java.awt.*; import javax.swing.*; class TesteJFrame extends JFrame{ public TesteJFrame(){ //Titulo da janela 1 settitle("primeira Janela Swing"); //tamanho da janela 2 setsize(275,100); // anula o layout padrao 3 getcontentpane().setlayout(null); //cor de fundo da janela no padrão RGB (Red Green Blue) 4 getcontentpane().setbackground(new Color(255,255,255)); //provoca o termino da execução (encerra o programa) 5 setdefaultcloseoperation(jframe.exit_on_close); public static void main(string [] args){ 6 TesteJFrame janela = new TesteJFrame(); 7 janela.setvisible(true); A classe TesteJFrame é filha de JFrame, logo herda os atributos e métodos da super classe. Na linha 1 está sendo definido o título da janela. Na linha 2 está sendo definido o tamanho da janela. Na linha 3 está sendo anulado o layout padrão para que seja possível definir manualmente o tamanho e a posição dos componentes que ele abrigará. Na linha 4 está sendo definida a cor de fundo da janela. As cores seguem o padrão RGB (Red Green Blue) e podem ser representadas por números inteiros de 0 a 255 ou por números em ponto flutuante entre 0,0 e 1,0. Na linha 5 estamos definindo o comportamento que será executado quando clicarmos no botão "X" no canto superior direito da janela, ou seja, encerrar a execução do programa. Caso não seja definido este comportamento, a janela irá assumir o comportamento default (HIDE_ON_CLOSE) ou seja, a janela será "escondida", mas o processo continuará executando. Na linha 6 está sendo criado um objeto da classe. Veja que todas as definições da janela estão sendo executadas dentro do método construtor. Na linha 7 a janela torna-se visível para o usuário. 3

4 Veja a janela gerada pela execução do programa anterior. Esta janela não irá aparecer centralizada na tela e caso este seja o objetivo, devemos alterar o código da classe anterior. Veja o exemplo abaixo: import java.awt.*; import javax.swing.*; class TesteJFrame extends JFrame{ public TesteJFrame(){ //Titulo da janela settitle("primeira Janela Swing"); //tamanho da janela setsize(275,100); // anula o layout padrao getcontentpane().setlayout(null); //cor de fundo da janela no padrão RGB (Red Green Blue) getcontentpane().setbackground(new Color(255,255,255)); //provoca o termino da execução (encerra o programa) setdefaultcloseoperation(jframe.exit_on_close); centralizar(); public void centralizar(){ //obtém a altura e largura da resolução vídeo Dimension screen = Toolkit.getDefaultToolkit().getScreenSize(); //obtém a altura e largura da minha janela Dimension janela = getsize(); if (janela.height > screen.height) setsize(janela.width, screen.height); if (janela.width > screen.width) setsize(screen.width, janela.height); setlocation((screen.width - janela.width)/2, (screen.height - janela.height)/2); public static void main(string [] args){ TesteJFrame janela = new TesteJFrame(); janela.setvisible(true); 4

5 Inserindo Textos, Campos de Edição e Botões na Tela A Classe javax.swing.jlabel Um rótulo (JLabel) é uma área para a exibição de um texto, uma imagem ou ambos. Ele não reage a eventos de entrada e, por isto, não pode receber o foco do teclado. Entretanto, pode incluir teclas de atalho para passar o foco para outro componente. Veja o exemplo abaixo: import java.awt.*; import javax.swing.*; class TesteJLabel extends JFrame{ public TesteJLabel(){ //Titulo da janela settitle("primeira Janela Swing"); //tamanho da janela setsize(275,100); //anula o layout padrao getcontentpane().setlayout(null); //cor de fundo da janela no padrão RGB (Red Green Blue) getcontentpane().setbackground(new Color(255,255,255)); //Cria um JLabel JLabel jl= criarjlabel(); //insere o JLabel no ContentPane da Janela getcontentpane().add(jl); //provoca o termino da execução (encerra o programa) setdefaultcloseoperation(jframe.exit_on_close); centralizar(); public JLabel criarjlabel(){ JLabel jl = new JLabel(); jl.settext("jlabel inserido"); jl.setlocation(10, 10); jl.setsize(370, 50); //Torna opaco o fundo do rótulo jl.setopaque(true); jl.setbackground(new Color(255,255,255)); jl.setforeground(new Color(0,0,0)); jl.setfont(new Font("Courier new", Font.BOLD, 12)); jl.settooltiptext("jlabel Exemplo"); jl.sethorizontalalignment(swingconstants.left); jl.setverticalalignment(swingconstants.top); return jl; public void centralizar(){ //obtém a altura e largura da resolução vídeo Dimension screen = Toolkit.getDefaultToolkit().getScreenSize(); //obtém a altura e largura da minha janela Dimension janela = getsize(); 5

6 if (janela.height > screen.height) setsize(janela.width, screen.height); if (janela.width > screen.width) setsize(screen.width, janela.height); setlocation((screen.width - janela.width)/2, (screen.height - janela.height)/2); public static void main(string [] args){ TesteJLabel janela = new TesteJLabel(); janela.setvisible(true); Veja a janela gerada pela execução do programa anterior A Classe javax.swing.jbutton Um botão (button) é um componente que pode ser pressionado pelo usuário, utilizando o mouse ou teclado, para acionar uma ação específica. Veja o exemplo abaixo: import java.awt.*; import javax.swing.*; class TesteJButton extends JFrame{ public TesteJButton(){ //Titulo da janela settitle("primeira Janela Swing"); //tamanho da janela setsize(new Dimension(300,100)); //anula o layout padrao getcontentpane().setlayout(null); //cor de fundo da janela no padrao RGB (Red Green Blue) getcontentpane().setbackground(new Color(255,255,255)); JButton b1, b2; //Cria um JButton "gravar" b1 = new JButton(); b1.settext("gravar"); //50 posição x, 30 posição y, 100 largura, 30 altura b1.setbounds(50, 30, 100, 30); b1.setbackground(new Color(0,0,170)); b1.setforeground(color.yellow); b1.setfont(new Font("Helvetica", Font.BOLD, 12)); b1.settooltiptext("botao b1"); b1.sethorizontalalignment(swingconstants.center); b1.setverticalalignment(swingconstants.center); b1.setenabled(false); 6

7 b1.setmnemonic('g'); b2 = new JButton(); b2.settext("sair"); b2.setbounds(150, 30, 100, 30); b2.setbackground(new Color(0,0,170)); b2.setforeground(color.yellow); b2.setfont(new Font("Helvetica", Font.BOLD, 12)); b2.settooltiptext("botao b2"); b2.sethorizontalalignment(swingconstants.center); b2.setverticalalignment(swingconstants.center); b2.setenabled(true); b2.setmnemonic('s'); //insere os botões no ContentPane da Janela getcontentpane().add(b1); getcontentpane().add(b2); //provoca o termino da execução (encerra o programa) setdefaultcloseoperation(jframe.exit_on_close); centralizar(); public void centralizar(){ //obtém a altura e largura da resolução vídeo Dimension screen = Toolkit.getDefaultToolkit().getScreenSize(); //obtem a altura e largua da minha janela Dimension janela = getsize(); if (janela.height > screen.height) setsize(janela.width, screen.height); if (janela.width > screen.width) setsize(screen.width, janela.height); setlocation((screen.width - janela.width)/2, (screen.height - janela.height)/2); public static void main(string [] args){ TesteJButton janela = new TesteJButton(); janela.setvisible(true); Veja abaixo a saída gerada pela execução do programa acima. Vários métodos da classe JButton realizam as mesmas tarefas realizadas por métodos com nomes idênticos da classe JLabel e já foram analisados. Veja abaixo um resumo desses métodos: 7

8 settext(): define o texto do botão setbounds(): define o tamanho e a posição em seu contêiner setbackground(): define a cor de fundo setforeground(): define a cor do texto setfont(): define o tipo, o estilo e o tamanho da fonte settooltiptext(): define uma dica sethorizontalalignment(): define o alinhamento horizontal do conteúdo. setverticalalignment(): define o alinhamento vertical do conteúdo. Apenas dois métodos utilizados nesse exemplo não haviam sido introduzidos durante o estudo dos Labels (JLabel). São eles: setenabled() e setmnemonic(). setenabled(): exige um argumento booleano e serve para habilitar ou desabilitar o botão. setmnemonic(): define um atalho de teclado para o botão. Deve-se informar para esse método um caracter que exista no seu texto. Posteriormente, o botão poderá ser acessado, a partir de qualquer ponto da janela, pressionando-se a tecla ALT em conjunto com esse caracter. A Classe javax.swing.jtextfield Esta classe representa um campo de texto para digitação pelo usuário, usualmente empregado para campos de cadastro de uma única linha. Veja o exemplo abaixo: import java.awt.*; import javax.swing.*; class TesteJTextField extends JFrame{ public TesteJTextField(){ //Titulo da janela settitle("primeira Janela Swing"); //tamanho da janela setsize(new Dimension(300,100)); //cor de fundo da janela no padrão RGB (Red Green Blue) getcontentpane().setbackground(new Color(200,230,200)); //Cria JTextField JTextField jt = new JTextField(); jt.settext("insira texto aqui"); jt.sethorizontalalignment(jtextfield.center); 8

9 //insere o JTextField no ContentPane da Janela getcontentpane().add(jt); //provoca o termino da execução (encerra o programa) setdefaultcloseoperation(jframe.exit_on_close); centralizar(); public void centralizar(){ //obtém a altura e largura da resolução vídeo Dimension screen = Toolkit.getDefaultToolkit().getScreenSize(); //obtém a altura e largura da minha janela Dimension janela = getsize(); if (janela.height > screen.height) setsize(janela.width, screen.height); if (janela.width > screen.width) setsize(screen.width, janela.height); setlocation((screen.width - janela.width)/2, (screen.height - janela.height)/2); public static void main(string [] args){ TesteJTextField janela = new TesteJTextField(); janela.setvisible(true); Layouts de Tela Gerenciamento de Layout Nos exemplos anteriores, o tamanho e o posicionamento dos componentes nas janelas foram definidos através dos métodos setsize(), setbounds() e setlocation(). Utilizou-se o sistema de coordenadas x e y para posicionar os componentes e a definição de valores absolutos para sua altura e largura. Entretanto, essa forma de organização esbarra em vários inconvenientes. Deve-se evitar o uso de valores absolutos para definição do tamanho e posição de componentes porque eles comprometem duas importantes características da qualidade do software: sua portabilidade e manutenção. Eles comprometem a portabilidade porque os componentes dimensionados e posicionados com valores absolutos se apresentam de forma distinta em diferentes plataformas. Eles também comprometem a manutenibilidade porque o trabalho necessário para realizar ajustes em uma GUI se torna mais complexo, gastando muito mais tempo. 9

10 Em função do exposto acima, é aconselhável evitar o uso de valores absolutos para o dimensionamento e posicionamento de componentes. Para isso, deve-se substituir esse procedimento pelo uso dos gerenciadores de leiaute (layout) disponíveis na API Java. Os gerenciadores de leiaute (layout) nada mais são que classes que aplicam um conjunto de regras predefinidas para determinar o tamanho e a posição de cada componente em um contêiner. Para que os componentes de uma janela ou de um painel sejam organizados, automaticamente, você precisará vincular um gerenciador de leiaute (layout) a esse contêiner e adicionar os componentes a ele. O objetivo de um gerenciador de leiaute (layout) é organizar os componentes em seu contêiner para uma apresentação adequada. Além de serem mais eficientes, eles fornecem capacidades que são muito mais fáceis de utilizar do que a definição de tamanho e posição por valores absolutos. Além disso, utilizando-se gerenciadores de leiaute (layout), os componentes são reorganizados automaticamente, quando a janela em que estão dispostos é redimensionada e se ajustam a mudanças feitas em seu conteúdo. Layout de Fluxo (FlowLayout) O leiaute (layout) de fluxo (flowlayout) alinha os componentes em um fluxo, da esquerda para a direita e de cima para baixo, muito parecido com o texto de um parágrafo. Esse tipo de leiaute (layout) é representado pela classe java.awt.flowlayout. Em um painel cujo gerenciamento de leiaute (layout) é delegado a um objeto da classe FlowLayout, os componentes são dispostos em colunas e linhas, da esquerda para a direita e de cima para baixo, à medida que são adicionados. Quando um componente é adicionado, ele é disposto do lado direito do último componente presente no painel e, se ele não é comportado na mesma linha, ele é posicionado na linha seguinte. 10

11 Veja o exemplo abaixo. import java.awt.*; import javax.swing.*; class TesteFlowLayout extends JFrame{ public TesteFlowLayout(){ //Titulo da janela settitle("teste FlowLayout"); //Define um tamanho inicial para a janela setsize(300,120); //cor de fundo da janela no padrão RGB (Red Green Blue) getcontentpane().setbackground(new Color(255,255,255)); //provoca o termino da execução (encerra o programa) setdefaultcloseoperation(jframe.exit_on_close); centralizar(); //Cria um flowlayout alinhando seus componentes ah esquerda //e definindo o espaçamento horizontal e vertical entre eles FlowLayout fl = new FlowLayout(FlowLayout.LEFT, 10, 10); getcontentpane().setlayout(fl); JButton b1 = new JButton("Botao 1"); JButton b2 = new JButton("Botao 2"); JButton b3 = new JButton("Botao 3"); JButton b4 = new JButton("Botao 4"); JButton b5 = new JButton("Botao 5"); getcontentpane().add(b1); getcontentpane().add(b2); getcontentpane().add(b3); getcontentpane().add(b4); getcontentpane().add(b5); public void centralizar(){ //obtém a altura e largura da resolução vídeo Dimension screen = Toolkit.getDefaultToolkit().getScreenSize(); //obtém a altura e largura da minha janela Dimension janela = getsize(); if (janela.height > screen.height) setsize(janela.width, screen.height); if (janela.width > screen.width) setsize(screen.width, janela.height); setlocation((screen.width - janela.width)/2, (screen.height - janela.height)/2); public static void main(string [] args){ TesteFlowLayout janela = new TesteFlowLayout(); janela.setvisible(true); 11

12 Neste exemplo foi criado um objeto da classe FlowLayout com um de seus construtores que modifica o alinhamento padrão dos componentes (centralizado) para que sejam alinhados à esquerda e definiu-se também o espaçamento horizontal e vertical entre estes componentes. Para definir esse objeto como gerenciador de leiaute (layout) do painel de conteúdo da janela, invocou-se o método setlayout() desse painel e utilizou-se o objeto "fl" como argumento. Neste exemplo, à medida que a janela for redimensionada, os botões serão reorganizados como se fossem palavras em um parágrafo alinhado à esquerda. Se a largura da janela for incrementada, alguns botões podem passar para as linhas precedentes àquelas em que se encontram. Veja abaixo a tela gerada pela execução deste programa. Layout de Bordas (BorderLayout) O leiaute (layout) de bordas é representado pela classe java.awt.borderlayout. Ela posiciona e redimensiona os componentes para ajustarem-se a cinco regiões de seu contêiner: norte, sul, leste, oeste e centro. Cada uma dessas regiões pode conter somente um componente e sua localização é definida por uma constante, como segue: BorderLayout.NORTH: representa a região norte (superior) BorderLayout.SOUTH: representa a região sul (inferior) BorderLayout.EAST: representa a região leste (direita) BorderLayout.WEST: representa a região oeste (esquerda) BorderLayout.CENTER: representa a região central. 12

13 Veja abaixo um exemplo. import java.awt.*; import javax.swing.*; class TesteBorderLayout extends JFrame{ public TesteBorderLayout(){ //Titulo da janela settitle("teste BorderLayout"); //Define um tamanho inicial para a janela setsize(350,150); //cor de fundo da janela no padrão RGB (Red Green Blue) getcontentpane().setbackground(new Color(255,255,255)); //provoca o termino da execução (encerra o programa) setdefaultcloseoperation(jframe.exit_on_close); centralizar(); //Cria um borderlayout definindo o espaçamento horizontal e //vertical entre cada uma das regiões BorderLayout bl = new BorderLayout(5,5); getcontentpane().setlayout(bl); JButton b1 = new JButton("Botao Norte"); JButton b2 = new JButton("Botao Sul"); JButton b3 = new JButton("Botao Leste"); JButton b4 = new JButton("Botao Oeste"); JButton b5 = new JButton("Botao Centro"); getcontentpane().add(b1,borderlayout.north); getcontentpane().add(b2,borderlayout.south); getcontentpane().add(b3,borderlayout.east); getcontentpane().add(b4,borderlayout.west); getcontentpane().add(b5,borderlayout.center); public void centralizar(){ //obtém a altura e largura da resolução vídeo Dimension screen = Toolkit.getDefaultToolkit().getScreenSize(); //obtém a altura e largura da minha janela Dimension janela = getsize(); if (janela.height > screen.height) setsize(janela.width, screen.height); if (janela.width > screen.width) setsize(screen.width, janela.height); setlocation((screen.width - janela.width)/2, (screen.height - janela.height)/2); public static void main(string [] args){ TesteBorderLayout janela = new TesteBorderLayout(); janela.setvisible(true); 13

14 Um objeto da classe BorderLayout foi criado utilizando-se uma versão alternativa do construtor, de modo a ser possível definir um espaçamento horizontal e vertical entre cada uma de suas regiões. Na linha seguinte esse objeto é configurado como gerenciador de leiaute (layout) do painel de conteúdo da janela. Foi utilizado o método add() para adicionar componentes ao contêiner. Como o gerenciador de leiaute (layout) é o borderlayout, foi preciso informar, além do nome do componente, uma das constantes que representa a região onde o botão será inserido. Ao redimensionar a janela, aumentando ou diminuindo tanto a largura quando a altura, os botões adicionados ao seu painel de conteúdo têm largura e/ou altura modificadas, mas matem sempre as mesmas posições. Veja abaixo a tela gerada pela execução deste programa. Layout de Grade (GridLayout) Um gerenciador de leiaute (layout) de grade é aquele que dispõe os componentes em um contêiner em forma de uma grade retangular. O contêiner é dividido em células retangulares de tamanhos iguais e cada componente é disposto em uma célula diferente. O leiaute (layout) de grade (GridLayout) é representado pela classe java.awt.gridlayout e, do mesmo modo que no leiaute (layout) de fluxo, os componentes são dispostos da esquerda para a direita, mas ocupam uma célula da grade e ajustam seu tamanho a ela. 14

15 Veja abaixo um exemplo. import java.awt.*; import javax.swing.*; class TesteGridLayout extends JFrame{ public TesteGridLayout(){ //Titulo da janela settitle("teste GridLayout"); //Define um tamanho inicial para a janela setsize(300,150); //cor de fundo da janela no padrão RGB (Red Green Blue) getcontentpane().setbackground(new Color(255,255,255)); //provoca o termino da execução (encerra o programa) setdefaultcloseoperation(jframe.exit_on_close); centralizar(); /* Número de linhas(3), o número de colunas(2), o espaçamento horizontal(0) e o espaçamento vertical(0) entre os componentes (em pixels) */ GridLayout gl = new GridLayout(3,2,0,0); getcontentpane().setlayout(gl); JButton b1 = new JButton("Linha 1 - Coluna 1"); JButton b2 = new JButton("Linha 1 - Coluna 2"); JButton b3 = new JButton("Linha 2 - Coluna 1"); JButton b4 = new JButton("Linha 2 - Coluna 2"); JButton b5 = new JButton("Linha 3 - Coluna 1"); JButton b6 = new JButton("Linha 3 - Coluna 2"); getcontentpane().add(b1); getcontentpane().add(b2); getcontentpane().add(b3); getcontentpane().add(b4); getcontentpane().add(b5); getcontentpane().add(b6); public void centralizar(){ //obtém a altura e largura da resolução vídeo Dimension screen = Toolkit.getDefaultToolkit().getScreenSize(); //obtém a altura e largura da minha janela Dimension janela = getsize(); if (janela.height > screen.height) setsize(janela.width, screen.height); if (janela.width > screen.width) setsize(screen.width, janela.height); setlocation((screen.width - janela.width)/2, (screen.height - janela.height)/2); public static void main(string [] args){ TesteGridLayout janela = new TesteGridLayout(); janela.setvisible(true); 15

16 No exemplo acima foi instanciado um novo objeto da classe GridLayout, chamado "gl", utilizando-se uma versão do construtor que exige quatro números inteiros como argumentos. Eles representam, respectivamente: o número de linhas, o número de colunas, o espaçamento horizontal e o espaçamento vertical entre os componentes (em pixels). Na instrução seguinte o objeto "gl" é definido como o gerenciador de leiaute (layout) do painel de conteúdo da janela. A partir deste momento, todos os componentes adicionados a esse painel serão posicionados na grade de três linhas e duas colunas que ele representa. Se a janela for redimensionada, todos os componentes também serão redimensionados na mesma proporção para ocuparem todo o seu espaço. Veja abaixo a tela gerada pela execução deste programa. Painéis - Inserindo novos containeres a tela a partir do JPanel Os painéis agem como contêineres que servem para dividir a janela. Eles são utilizados para possibilitar maior controle da organização de interfaces gráficas mais complexas e, em conjunto com os gerenciadores de leiaute (layout), permitem mais exatidão no posicionamento dos componentes. A classe javax.swing.jpanel representa um contêiner genérico. Ela deriva da classe Jcomponent, que é uma classe derivada de Java.awt.Container. Pode-se dizer que todo painel, representado como um objeto da classe Jpanel, é um contêiner e pode abrigar componentes, inclusive outros painéis. 16

17 Veja o exemplo abaixo. import java.awt.*; import javax.swing.*; class TesteJPanel extends JFrame{ JButton b1, b2; JPanel p1, p2; public TesteJPanel(){ //Titulo da janela settitle("teste JPanel"); //tamanho da janela setsize(200,200); // anula o layout padrao getcontentpane().setlayout(null); //cor de fundo da janela no padrão RGB (Red Green Blue) getcontentpane().setbackground(new Color(255,255,255)); //provoca o termino da execução (encerra o programa) setdefaultcloseoperation(jframe.exit_on_close); centralizar(); p1 = new JPanel(); p1.setlayout(null); p1.setbounds(10, 10, 170, 70); p1.setbackground(color.blue); p2 = new JPanel(); p2.setlayout(null); p2.setbounds(10,90,170,70); p2.setbackground(color.yellow); b1 = new JButton("Gravar"); b1.setbounds(35, 30, 100, 30); b2 = new JButton("Sair"); b2.setbounds(35, 30, 100, 30); p1.add(b1); p2.add(b2); getcontentpane().add(p1); getcontentpane().add(p2); public void centralizar(){ //obtém a altura e largura da resolução vídeo Dimension screen = Toolkit.getDefaultToolkit().getScreenSize(); //obtém a altura e largura da minha janela Dimension janela = getsize(); if (janela.height > screen.height) setsize(janela.width, screen.height); if (janela.width > screen.width) setsize(screen.width, janela.height); setlocation((screen.width - janela.width)/2, (screen.height - janela.height)/2); public static void main(string [] args){ TesteJPanel janela = new TesteJPanel(); janela.setvisible(true); 17

18 O objetivo deste exemplo é criar dois painéis e adiciona-los ao painel de conteúdo da janela e, em seguida, adicionar um botão em cada um dos painéis criados. Para facilitar o exemplo, os gerenciadores de leiaute (layout) não foram utilizados, logo o leiaute (layout) padrão desses painéis foi anulado pela chamada as instruções setlayout(null). Com isto foi possível adicionar componentes e posicioná-los utilizando posições absolutas (coordenadas x e y). Veja abaixo a saída gerada pela execução do programa anterior. Interface Interface é um recurso da programação orientada a objetos que define ações (comportamentos) que devem ser obrigatoriamente executadas, porém cada classe que implementa esta interface pode executar de forma diferente. Interfaces possuem valores constantes ou assinaturas de métodos que devem ser implementados dentro de uma classe. Uma interface é a definição de um tipo, uma classe é a implementação de um tipo e um objeto é uma instância de um tipo. A interface define um tipo porque muitos objetos (instâncias de classes) podem possuir a mesma ação (método ou comportamento), porém podem executar esta ação de forma diferente. Para exemplificar o conceito de interface, vamos definir uma interface chamada País que possui a assinatura do método criarconstituicao(). Ou seja, toda classe que implementar País deve definir como criar uma constituição por meio do método criarconstituicao(). Devido a isto, se eu tenho uma classe chamada Brasil e outra chamada México, 18

19 ambas implementando a interface País, cada uma deverá obrigatoriamente codificar a forma como a constituição será criada. (Existe uma opção para não codificar utilizando a palavra abstract que não será abordada no curso). Uma interface pode ser criada da mesma forma que uma classe, basta utilizar a palavra chave "interface" no lugar de class. Veja o exemplo abaixo: interface InterfaceName { método(args); Uma classe pode estender suas funcionalidades obtendo as características de outra classe num processo chamado de herança. Uma interface não é herdada, mas sim implementada. Todo o código dos métodos da interface deve ser escrito dentro da classe que implementa a interface. Com isto, obtemos as assinaturas dos métodos da interface em uma classe utilizando a palavra chave implements. A vantagem das interfaces está no fato de que não há limites para a quantidade de interfaces que uma classe pode implementar. Isto ajuda no caso de herança múltipla que não é suportada pela linguagem Java, pois uma classe apenas pode herdar as características e comportamentos de uma única classe. Vamos analisar o exemplo abaixo: public interface Temperatura { void convertertemperatura(double temperatura, String origem); import javax.swing.joptionpane; public class Celsius implements Temperatura { public void convertertemperatura(double temperatura, String origem) { double tempcelsius=0; if( origem.equals("fahrenheit")){ tempcelsius = (temperatura - 32) / 1.8; else if (origem.equals("kelvin")){ tempcelsius = temperatura ; JOptionPane.showMessageDialog(null,"Temperatura em Celsius: " + tempcelsius); 19

20 import javax.swing.joptionpane; public class Fahrenheit implements Temperatura { public void convertertemperatura(double temperatura, String origem){ double tempfahrenheit =0; if( origem.equals("celsius")){ tempfahrenheit = temperatura * ; else if (origem.equals("kelvin")){ tempfahrenheit = temperatura * ; JOptionPane.showMessageDialog(null, "Temperatura em Fahrenheit: " + tempfahrenheit); A interface Temperatura define o método convertertemperatura(), já as classes Celsius e Fahrenheit implementam o método convertertemperatura() de formas diferentes, ou seja, cada implementação do método utiliza fórmulas diferentes para converter a temperatura, pois o objetivo do método convertertemperatura() da classe Celsius é converter a temperatura para Celsius, já na classe Fahrenheit o objetivo é converter a temperatura para Fahrenheit. Curiosidade: Em interfaces, os métodos são públicos abstratos(public abstract) e os atributos são constantes estáticas (final static), mesmo que o desenvolvedor não defina essas palavras na assinatura do método. A classe Java abaixo foi criada apenas para testar o exemplo acima descrito. Veja que são solicitadas ao usuário três informações: 1) Um valor de temperatura (origem); 2) Qual unidade está a temperatura (origem) informada; 3) Para qual temperatura deve-se converter a temperatura; Em seguida é criado o objeto correspondente e a temperatura será convertida. import javax.swing.joptionpane; public class TestaConversao { public static void main(string[] args) { String temperatura = JOptionPane.showInputDialog("Digite o valor da temperatura (origem)"); String origem = JOptionPane.showInputDialog("Digite a unidade da temperatura"); String destino = JOptionPane.showInputDialog("Informe a unidade da temperatura destino"); if(destino.equals("celsius")){ Celsius c = new Celsius(); double temp = Double.parseDouble(temperatura); c.convertertemperatura(temp, origem); else if(destino.equals("fahrenheit")){ 20

21 Fahrenheit f = new Fahrenheit(); double temp = Double.parseDouble(temperatura); f.convertertemperatura(temp, origem); Como exercício, crie a classe Kelvin, implemente o método convertertemperatura() e faça as modificações necessárias na classe TestaConversao.java para a mesma também calcular a temperatura em graus Kelvin. Fórmulas para conversão: De Para Fórmula Celsius Kelvin K = C Fahrenheit Kelvin K = ( F ) / 1.8 Eventos de Clique (Ação) Eventos de clique (ação) são eventos de alto nível gerados por um componente (como um botão) quando a ação especificada por ele ocorrer (como ser pressionado). Quando um evento desse tipo ocorre, o componente gerador envia um objeto da classe ActionEvent para cada ouvinte, registrado através do método addactionlistener(). Cada vez que um botão é pressionado, o ouvinte será notificado através de um objeto do tipo ActionEvent, que contém informações acerca do evento ocorrido. Se ele é ouvinte de dois ou mais botões, é preciso determinar qual deles foi pressionado para tomar a decisão correta. Isso pode ser feito invocando-se o método getsource(), que retornará uma referência ao objeto que gerou o evento. Veja o exemplo abaixo import java.awt.*; import java.awt.event.actionevent; import java.awt.event.actionlistener; import javax.swing.*; class TesteEventoAcao extends JFrame implements ActionListener{ JLabel l1; JButton b1, b2; int i1, i2; public TesteEventoAcao(){ settitle("teste Evento Acao"); //tamanho da janela setsize(240,100); // anula o layout padrao getcontentpane().setlayout(null); //cor de fundo da janela no padrão RGB (Red Green Blue) getcontentpane().setbackground(new Color(255,255,255)); 21

22 //provoca o termino da execução (encerra o programa) setdefaultcloseoperation(jframe.exit_on_close); centralizar(); i1 = i2 = 0; b1 = new JButton("Gravar"); b1.setbounds(10, 10, 100, 30); b1.addactionlistener(this); b2 = new JButton("Sair"); b2.setbounds(120, 10, 100, 30); b2.addactionlistener(this); l1 = new JLabel("Pressione os botões"); l1.setbounds(5, 50, 220, 20); getcontentpane().add(b1); getcontentpane().add(b2); getcontentpane().add(l1); public void centralizar(){ //obtém a altura e largura da resolução vídeo Dimension screen = Toolkit.getDefaultToolkit().getScreenSize(); //obtém a altura e largura da minha janela Dimension janela = getsize(); if (janela.height > screen.height) setsize(janela.width, screen.height); if (janela.width > screen.width) setsize(screen.width, janela.height); setlocation((screen.width - janela.width)/2, (screen.height - janela.height)/2); public void actionperformed(actionevent e){ if (e.getsource() == b1) l1.settext("botão gravar pressionado " + ++i1 + " vez(es)"); if (e.getsource() == b2) l1.settext("botão sair pressionado " + ++i2 + " vez(es)"); public static void main(string [] args){ TesteEventoAcao janela = new TesteEventoAcao(); janela.setvisible(true); Exercícios Sobre Interface Gráfica 1) Implemente uma classe Java que faça uso de interface gráfica. Faça uma tela de login de usuário com os seguintes componentes: Um rótulo (label) com a descrição "Usuário" Um rótulo (label) com a descrição "Senha" Uma caixa de texto (TextField) para o usuário digitar o seu nome Uma caixa de senha (PasswordField) para o usuário digitar a sua senha Dois botões: Um "Ok" e outro "Cancelar" 22

23 Resposta Quando o usuário clicar no botão "Cancelar" o programa deve ser encerrado (Utilize o comando System.exit(0) para isto). Quando o usuário clicar no botão "Ok" valide o usuário e senha e caso sejam informações corretas, utilize um JOptionPane para informar ao usuário que ele foi logado ao sistema e em seguida encerre o programa (Utilize o comando System.exit(0) para isto). Caso as informações não estejam corretas, utilize um JoptionPane para informar ao usuário que as informações de login não estão corretas, e diga para o usuário digitar as informações novamente. import java.awt.*; import java.awt.event.actionevent; import java.awt.event.actionlistener; import javax.swing.*; public class TesteLogonUsuario extends JFrame implements ActionListener{ JButton btnok, btncancelar; JTextField campousuario; JPasswordField camposenha; public TesteLogonUsuario(){ settitle("login Usuario"); setsize(300,110); GridLayout gl = new GridLayout(3,2,1,1); getcontentpane().setlayout(gl); //provoca o termino da execução (encerra o programa) setdefaultcloseoperation(jframe.exit_on_close); JLabel labelusuario = new JLabel(); labelusuario.settext("usuario: "); getcontentpane().add(labelusuario); campousuario = new JTextField(); getcontentpane().add(campousuario); JLabel labelsenha = new JLabel(); labelsenha.settext("senha: "); getcontentpane().add(labelsenha); camposenha = new JPasswordField(); getcontentpane().add(camposenha); btnok = new JButton("Ok"); getcontentpane().add(btnok); btnok.addactionlistener(this); btncancelar = new JButton("Cancelar"); getcontentpane().add(btncancelar); btncancelar.addactionlistener(this); public void actionperformed(actionevent e){ if (e.getsource() == btnok){ 23

24 String usu = campousuario.gettext(); String senha = String.valueOf(campoSenha.getPassword()); if (usu.equals("glauco") && senha.equals("752")){ JOptionPane.showMessageDialog(null, usu + ", você foi logado ao sismtema."); System.exit(0); else{ JOptionPane.showMessageDialog(null, "Usuario ou senha invalidos. Tente novamente"); if (e.getsource() == btncancelar){ System.exit(0); public static void main(string[] args) { TesteLogonUsuario tlu = new TesteLogonUsuario(); tlu.setvisible(true); 2) Implemente uma classe Java com a seguinte GUI: Resposta import java.awt.*; import java.awt.event.actionevent; import java.awt.event.actionlistener; import javax.swing.*; public class Formulario extends JFrame { JButton btnok, btncancelar; public Formulario(){ settitle("formulario"); setsize(300,160); GridLayout gl = new GridLayout(6,2,1,1); getcontentpane().setlayout(gl); //provoca o termino da execucao (encerra o programa) setdefaultcloseoperation(jframe.exit_on_close); JLabel labelnome = new JLabel(); labelnome.settext("nome: "); getcontentpane().add(labelnome); JTextField camponome = new JTextField(); getcontentpane().add(camponome); 24

25 JLabel labelendereco = new JLabel(); labelendereco.settext("endereco: "); getcontentpane().add(labelendereco); JTextField campoendereco = new JTextField(); getcontentpane().add(campoendereco); JLabel labeltelefone = new JLabel(); labeltelefone.settext("telefone: "); getcontentpane().add(labeltelefone); JTextField campotelefone = new JTextField(); getcontentpane().add(campotelefone); JLabel labelcpf = new JLabel(); labelcpf.settext("cpf: "); getcontentpane().add(labelcpf); JTextField campocpf = new JTextField(); getcontentpane().add(campocpf); JLabel labelrg = new JLabel(); labelrg.settext("rg: "); getcontentpane().add(labelrg); JTextField camporg = new JTextField(); getcontentpane().add(camporg); btnok = new JButton("Ok"); getcontentpane().add(btnok); btncancelar = new JButton("Cancelar"); getcontentpane().add(btncancelar); public static void main(string[] args) { Formulario form = new Formulario(); form.setvisible(true); 3) Fdfdf 25