Principais Classes Swing AWT

Transcrição

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
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
estendida da
arquitetura
incompatível
é um container de janela e é uma versão
classe java.awt.Frame que adiciona suporte à
dos componentes Swing. Entretanto, ela é
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
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
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);
}
public static void main(String [] args){
TesteJFrame janela = new TesteJFrame();
janela.setVisible(true);
1
2
3
4
5
6
7
}
}
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
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.*;
class TesteJFrame extends JFrame{
public TesteJFrame(){
//Titulo da janela
//tamanho da janela
setSize(275,100);
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);
}
TesteJFrame janela = new TesteJFrame();
}
}
4
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.
import java.awt.*;
class TesteJLabel extends JFrame{
public TesteJLabel(){
//Titulo da janela
//tamanho da janela
setSize(275,100);
//anula o layout padrao
//Cria um JLabel
JLabel jl= criarJLabel();
//insere o JLabel no ContentPane da Janela
getContentPane().add(jl);
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;
}
Dimension screen =
5
}
TesteJLabel janela = new TesteJLabel();
}
}
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.
import java.awt.*;
class TesteJButton extends JFrame{
public TesteJButton(){
//Titulo da janela
//tamanho da janela
setSize(new Dimension(300,100));
//anula o layout padrao
//cor de fundo da janela no padrao RGB (Red Green Blue)
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
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);
centralizar();
}
Dimension screen =
//obtem a altura e largua da minha janela
}
TesteJButton janela = new TesteJButton();
}
}
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
setText(): define o texto do botão
setBounds():
contêiner
define
o
tamanho
e
a
posição
em
seu
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():
horizontal do conteúdo.
define
o
alinhamento
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.
import java.awt.*;
class TesteJTextField extends JFrame{
public TesteJTextField(){
//Titulo da janela
//tamanho da janela
setSize(new Dimension(300,100));
//Cria JTextField
JTextField jt = new JTextField();
jt.setText("Insira texto aqui");
jt.setHorizontalAlignment(JTextField.CENTER);
8
//insere o JTextField no ContentPane da Janela
getContentPane().add(jt);
centralizar();
}
Dimension screen =
}
TesteJTextField janela = new TesteJTextField();
}
}
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
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
Veja o exemplo abaixo.
import java.awt.*;
class TesteFlowLayout extends JFrame{
public TesteFlowLayout(){
//Titulo da janela
setTitle("Teste FlowLayout");
//Define um tamanho inicial para a janela
setSize(300,120);
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
JButton
JButton
JButton
JButton
b1
b2
b3
b4
b5
=
=
=
=
=
new
new
new
new
new
JButton("Botao
JButton("Botao
JButton("Botao
JButton("Botao
JButton("Botao
1");
2");
3");
4");
5");
}
Dimension screen =
}
TesteFlowLayout janela = new TesteFlowLayout();
}
}
11
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
Veja abaixo um exemplo.
import java.awt.*;
class TesteBorderLayout extends JFrame{
public TesteBorderLayout(){
//Titulo da janela
setTitle("Teste BorderLayout");
setSize(350,150);
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
JButton
JButton
JButton
JButton
b1
b2
b3
b4
b5
=
=
=
=
=
new
new
new
new
new
JButton("Botao
JButton("Botao
JButton("Botao
JButton("Botao
JButton("Botao
Norte");
Sul");
Leste");
Oeste");
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);
}
Dimension screen =
}
TesteBorderLayout janela = new TesteBorderLayout();
}
}
13
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.
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
Veja abaixo um exemplo.
import java.awt.*;
class TesteGridLayout extends JFrame{
public TesteGridLayout(){
//Titulo da janela
setTitle("Teste GridLayout");
setSize(300,150);
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
JButton
JButton
JButton
JButton
JButton
b1
b2
b3
b4
b5
b6
=
=
=
=
=
=
new
new
new
new
new
new
JButton("Linha
JButton("Linha
JButton("Linha
JButton("Linha
JButton("Linha
JButton("Linha
1
1
2
2
3
3
-
Coluna
Coluna
Coluna
Coluna
Coluna
Coluna
1");
2");
1");
2");
1");
2");
}
Dimension screen =
}
TesteGridLayout janela = new TesteGridLayout();
}
}
15
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.
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
Veja o exemplo abaixo.
import java.awt.*;
class TesteJPanel extends JFrame{
JButton b1, b2;
JPanel p1, p2;
public TesteJPanel(){
//Titulo da janela
setTitle("Teste JPanel");
//tamanho da janela
setSize(200,200);
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);
}
Dimension screen =
}
TesteJPanel janela = new TesteJPanel();
}
}
17
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
anterior.
a
saída
gerada
pela
execução
do
programa
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
de métodos que devem
classe. Uma interface é
é a implementação de um
um tipo.
valores constantes ou assinaturas
ser implementados dentro de uma
a definição de um tipo, uma classe
tipo e um objeto é uma instância de
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
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 - 273.15;
}
JOptionPane.showMessageDialog(null,"Temperatura em Celsius:
" + tempCelsius);
}
}
19
public class Fahrenheit implements Temperatura {
public void converterTemperatura(double temperatura, String origem){
double tempFahrenheit =0;
if( origem.equals("Celsius")){
tempFahrenheit = temperatura * 1.8 + 32;
}
else if (origem.equals("Kelvin")){
tempFahrenheit = temperatura * 1.8 - 459.67;
}
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
temperatura será convertida.
objeto
correspondente
e
a
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
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
Celsius
Fahrenheit
Para
Kelvin
Kelvin
Fórmula
K = °C + 273.15
K = (°F + 459.67) / 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;
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);
21
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(l1);
}
Dimension screen =
}
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)");
}
TesteEventoAcao janela = new TesteEventoAcao();
}
}
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
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.
Resposta
import java.awt.*;
public class TesteLogonUsuario extends JFrame implements
ActionListener{
JButton btnOk, btnCancelar;
JTextField campoUsuario;
JPasswordField campoSenha;
public TesteLogonUsuario(){
setTitle("Login Usuario");
setSize(300,110);
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
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);
}
}
TesteLogonUsuario tlu = new TesteLogonUsuario();
tlu.setVisible(true);
}
}
2)
Implemente uma classe Java com a seguinte GUI:
Resposta
import java.awt.*;
public class Formulario extends JFrame {
JButton btnOk, btnCancelar;
public Formulario(){
setTitle("Formulario");
setSize(300,160);
//provoca o termino da execucao (encerra o programa)
JLabel labelNome = new JLabel();
labelNome.setText("Nome: ");
getContentPane().add(labelNome);
JTextField campoNome = new JTextField();
getContentPane().add(campoNome);
24
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);
}
Formulario form = new Formulario();
form.setVisible(true);
}
}
3)
Fdfdf
25

Principais Classes Swing AWT

Transcrição

Documentos relacionados

Roteiro de Instalação do Teraterm

baixar o PDF - Giuliano Bertoti

Seiko Instalação do Perfil de Cor no PHOTOPRINT 4.6

Sunny Design para Auto consumo Estimado Cliente, A SMA

CONFIGURAÇÃO DO OUTLOOK EXPRESS

Baixar o arquivo

configuração nettravel/speedtravel para outlook express

O photo Paint pertence ao pacote de aplicativos gráficos do

Opções

17. Como instalar o DVR Client _Software Cliente