Java swing

Java Swing
21 de janeiro de 2008

Sumário
I Sobre essa apostila 2
II Informações Básicas 4
III Java Swing 9
1 O que é o Java Swing 10
2 Plano de ensino 11
2.1 Objetivo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11
2.2 Público Alvo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11
2.3 Pré-requisitos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11
2.4 Descrição . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11
2.5 Metodologia . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12
2.6 Cronograma . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12
2.7 Programa . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12
2.8 Avaliação . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12
2.9 Bibliograﬁa . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13
3 Lição 1 - Visão Geral 14
3.1 Introdução . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14
3.2 API Swing . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14
3.3 Componentes Swing . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15
3.4 Galeria de componentes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17
4 Lição 2 - Containers e Componentes 18
4.1 Containers . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18
4.2 Componentes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21
4.3 Componentes - Parte II . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 24
5 Lição 3 - Gerenciadores de Layout 27
5.1 Gerenciadores de Layout . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27
6 Lição 4 - Manipulando Ações Básicas 36
6.1 Manipulando Ações Básicas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 36
1

CDTC Centro de Difusão de Tecnologia e Conhecimento Brasil/DF
Conteúdo
O conteúdo dessa apostila é fruto da compilação de diversos materiais livres publicados na in-
ternet, disponíveis em diversos sites ou originalmente produzido no CDTC em http://www.cdtc.org.br.
O formato original deste material bem como sua atualização está disponível dentro da licença
GNU Free Documentation License, cujo teor integral encontra-se aqui reproduzido na seção de
mesmo nome, tendo inclusive uma versão traduzida (não oﬁcial).
A revisão e alteração vem sendo realizada pelo CDTC (suporte@cdtc.org.br), desde outubro
de 2006. Criticas e sugestões construtivas são bem-vindas a qualquer tempo.
Autores
A autoria deste conteúdo, atividades e avaliações é de responsabilidade de Alvaro Marcos
Carvalho(alvaro@cdtc.org.br) .
Parte deste curso foi retirada do site www.javanoroeste.com.br/2006/tutoriais/swing_basico.html
(tutorial escrito por Marli Esprega Gonçalves). O texto original faz parte do projeto Centro de
Difusão de Tecnolgia e Conhecimento, que vem sendo realizado pelo ITI em conjunto com outros
parceiros institucionais, atuando em conjunto com as universidades federais brasileiras que tem
produzido e utilizado Software Livre, apoiando inclusive a comunidade Free Software junto a ou-
tras entidades no país.
Informações adicionais podem ser obtidas atráves do email ouvidoria@cdtc.org.br, ou da
home page da entidade, atráves da URL http://www.cdtc.org.br.
Garantias
O material contido nesta apostila é isento de garantias e o seu uso é de inteira responsabi-
lidade do usuário/leitor. Os autores, bem como o ITI e seus parceiros, não se responsabilizam
direta ou indiretamente por qualquer prejuízo oriundo da utilização do material aqui contido.
Licença
Copyright ©2008,Alvaro Marcos Carvalho(alvaro@cdtc.org.br) .
Permission is granted to copy, distribute and/or modify this document under the terms
of the GNU Free Documentation License, Version 1.1 or any later version published by
the Free Software Foundation; with the Invariant Chapter being SOBRE ESSA APOS-
TILA. A copy of the license is included in the section entitled GNU Free Documentation
License.
3

Parte II
Informações Básicas
4

Sobre o CDTC
Objetivo Geral
O Projeto CDTC visa a promoção e o desenvolvimento de ações que incentivem a dissemina-
ção de soluções que utilizem padrões abertos e não proprietários de tecnologia, em proveito do
desenvolvimento social, cultural, político, tecnológico e econômico da sociedade brasileira.
Objetivo Específico
Auxiliar o Governo Federal na implantação do plano nacional de software não-proprietário e
de código fonte aberto, identificando e mobilizando grupos de formadores de opinião dentre os
servidores públicos e agentes políticos da União Federal, estimulando e incentivando o mercado
nacional a adotar novos modelos de negócio da tecnologia da informação e de novos negócios
de comunicação com base em software não-proprietário e de código fonte aberto, oferecendo
treinamento específico para técnicos, profissionais de suporte e funcionários públicos usuários,
criando grupos de funcionários públicos que irão treinar outros funcionários públicos e atuar como
incentivadores e defensores de produtos de software não proprietários e código fonte aberto, ofe-
recendo conteúdo técnico on-line para serviços de suporte, ferramentas para desenvolvimento de
produtos de software não proprietários e de seu código fonte livre, articulando redes de terceiros
(dentro e fora do governo) fornecedoras de educação, pesquisa, desenvolvimento e teste de pro-
dutos de software livre.
Guia do aluno
Neste guia, você terá reunidas uma série de informações importantes para que você comece
seu curso. São elas:
• Licenças para cópia de material disponível
• Os 10 mandamentos do aluno de Educação a Distância
• Como participar dos foruns e da wikipédia
• Primeiros passos
É muito importante que você entre em contato com TODAS estas informações, seguindo o
roteiro acima.
Licença
Copyright ©2008, Alvaro Marcos Carvalho(alvaro@cdtc.org.br) .
5

É dada permissão para copiar, distribuir e/ou modiﬁcar este documento sob os termos
da Licença de Documentação Livre GNU, Versão 1.1 ou qualquer versão posterior
públicada pela Free Software Foundation; com o Capitulo Invariante SOBRE ESSA
APOSTILA. Uma cópia da licença está inclusa na seção entitulada "Licença de Docu-
mentação Livre GNU".
Os 10 mandamentos do aluno de educação online
• 1. Acesso à Internet: ter endereço eletrônico, um provedor e um equipamento adequado é
pré-requisito para a participação nos cursos a distância.
• 2. Habilidade e disposição para operar programas: ter conhecimentos básicos de Informá-
tica é necessário para poder executar as tarefas.
• 3. Vontade para aprender colaborativamente: interagir, ser participativo no ensino a distân-
cia conta muitos pontos, pois irá colaborar para o processo ensino-aprendizagem pessoal,
dos colegas e dos professores.
• 4. Comportamentos compatíveis com a etiqueta: mostrar-se interessado em conhecer seus
colegas de turma respeitando-os e fazendo ser respeitado pelo mesmo.
• 5. Organização pessoal: planejar e organizar tudo é fundamental para facilitar a sua revisão
e a sua recuperação de materiais.
• 6. Vontade para realizar as atividades no tempo correto: anotar todas as suas obrigações e
realizá-las em tempo real.
• 7. Curiosidade e abertura para inovações: aceitar novas idéias e inovar sempre.
• 8. Flexibilidade e adaptação: requisitos necessário à mudança tecnológica, aprendizagens
e descobertas.
• 9. Objetividade em sua comunicação: comunicar-se de forma clara, breve e transparente é
ponto - chave na comunicação pela Internet.
• 10. Responsabilidade: ser responsável por seu próprio aprendizado. O ambiente virtual não
controla a sua dedicação, mas reﬂete os resultados do seu esforço e da sua colaboração.
Como participar dos fóruns e Wikipédia
Você tem um problema e precisa de ajuda?
Podemos te ajudar de 2 formas:
A primeira é o uso dos fóruns de notícias e de dúvidas gerais que se distinguem pelo uso:
. O fórum de notícias tem por objetivo disponibilizar um meio de acesso rápido a informações
que sejam pertinentes ao curso (avisos, notícias). As mensagens postadas nele são enviadas a
6

todos participantes. Assim, se o monitor ou algum outro participante tiver uma informação que
interesse ao grupo, favor postá-la aqui.
Porém, se o que você deseja é resolver alguma dúvida ou discutir algum tópico específico do
curso. É recomendado que você faça uso do Forum de dúvidas gerais que lhe dá recursos mais
efetivos para esta prática.
. O fórum de dúvidas gerais tem por objetivo disponibilizar um meio fácil, rápido e interativo
para solucionar suas dúvidas e trocar experiências. As mensagens postadas nele são enviadas
a todos participantes do curso. Assim, fica muito mais fácil obter respostas, já que todos podem
ajudar.
Se você receber uma mensagem com algum tópico que saiba responder, não se preocupe com a
formalização ou a gramática. Responda! E não se esqueça de que antes de abrir um novo tópico
é recomendável ver se a sua pergunta já foi feita por outro participante.
A segunda forma se dá pelas Wikis:
. Uma wiki é uma página web que pode ser editada colaborativamente, ou seja, qualquer par-
ticipante pode inserir, editar, apagar textos. As versões antigas vão sendo arquivadas e podem
ser recuperadas a qualquer momento que um dos participantes o desejar. Assim, ela oferece um
ótimo suporte a processos de aprendizagem colaborativa. A maior wiki na web é o site "Wikipé-
dia", uma experiência grandiosa de construção de uma enciclopédia de forma colaborativa, por
pessoas de todas as partes do mundo. Acesse-a em português pelos links:
• Página principal da Wiki - http://pt.wikipedia.org/wiki/
Agradecemos antecipadamente a sua colaboração com a aprendizagem do grupo!
Primeiros Passos
Para uma melhor aprendizagem é recomendável que você siga os seguintes passos:
• Ler o Plano de Ensino e entender a que seu curso se dispõe a ensinar;
• Ler a Ambientação do Moodle para aprender a navegar neste ambiente e se utilizar das
ferramentas básicas do mesmo;
• Entrar nas lições seguindo a seqüência descrita no Plano de Ensino;
• Qualquer dúvida, reporte ao Fórum de Dúvidas Gerais.
Perfil do Tutor
Segue-se uma descrição do tutor ideal, baseada no feedback de alunos e de tutores.
O tutor ideal é um modelo de excelência: é consistente, justo e profissional nos respectivos
valores e atitudes, incentiva mas é honesto, imparcial, amável, positivo, respeitador, aceita as
idéias dos estudantes, é paciente, pessoal, tolerante, apreciativo, compreensivo e pronto a ajudar.
7

A classificação por um tutor desta natureza proporciona o melhor feedback possível, é crucial, e,
para a maior parte dos alunos, constitui o ponto central do processo de aprendizagem.’ Este tutor
ou instrutor:
• fornece explicações claras acerca do que ele espera, e do estilo de classificação que irá
utilizar;
• gosta que lhe façam perguntas adicionais;
• identifica as nossas falhas, mas corrige-as amavelmente’, diz um estudante, ’e explica por-
que motivo a classificação foi ou não foi atribuída’;
• tece comentários completos e construtivos, mas de forma agradável (em contraste com um
reparo de um estudante: ’os comentários deixam-nos com uma sensação de crítica, de
ameaça e de nervossismo’)
• dá uma ajuda complementar para encorajar um estudante em dificuldade;
• esclarece pontos que não foram entendidos, ou corretamente aprendidos anteriormente;
• ajuda o estudante a alcançar os seus objetivos;
• é flexível quando necessário;
• mostra um interesse genuíno em motivar os alunos (mesmo os principiantes e, por isso,
talvez numa fase menos interessante para o tutor);
• escreve todas as correções de forma legível e com um nível de pormenorização adequado;
• acima de tudo, devolve os trabalhos rapidamente;
8

Capítulo 1
O que é o Java Swing
Java Swing é um kit de ferramentas GUI(Graphic User Interface) destinadas à construção de
interfaces gráﬁcas com o usuário. O Swing amplia o AWT - Absttract Window Toolkit a partir
da versao Java 1.2 oferecendo uma opçao mais compativel e reutilizável, permitindo inclusive
personalizar a aparência dos componentes utilizando recursos como HTML e ícones. Para um
bom desempenho no curso é necessario que o aluno tenha conhecimento básico de linguagens
orientadas a objetos e logicamente da linguagem Java.
10

Capítulo 2
Plano de ensino
2.1 Objetivo
Qualificar técnicos e programadores da linguagem de programação Java.
2.2 Público Alvo
Técnicos e Programadores que desejam trabalhar com Interfaces Gráficas.
2.3 Pré-requisitos
Os usuários deverão ser, necessariamente, indicados por empresas públicas e ter conheci-
mento básico acerca da lógica de programação Java.
2.4 Descrição
O curso de Java Swing será realizado na modalidade EAD e utilizará a plataforma Moodle
como ferramenta de aprendizagem. Ele é composto de um módulo de aprendizado e um módulo
de avaliação avaliação que serão dados na primeira semana. O material didático estará disponível
on-line de acordo com as datas pré-estabelecidas no calendário. A versão utilizada para o Java
Swing pode ser qualquer versão Java a partir da 1.2.
Todo o material está no formato de lições, e estará disponível ao longo do curso. As lições
poderão ser acessadas quantas vezes forem necessárias. Aconselhamos a leitura de "Ambien-
tação do Moodle", para que você conheça o produto de Ensino a Distância, evitando dificuldades
advindas do "desconhecimento"sobre o mesmo.
Ao final de cada semana do curso será disponibilizada a prova referente ao módulo estudado
anteriormente que também conterá perguntas sobre os textos indicados. Utilize o material de
cada semana e os exemplos disponibilizados para se preparar para prova.
Os instrutores estarão a sua disposição ao longo de todo curso. Qualquer dúvida deve ser
disponibilizada no fórum ou enviada por e-mail. Diariamente os monitores darão respostas e
esclarecimentos.
11

2.5 Metodologia
O curso está dividido da seguinte maneira:
2.6 Cronograma
• Lição 1 - Visão Geral
• Lição 2 - Containers e Componentes
• Lição 3 - Gerenciadores de Layout
• Lição 4 - Manipulando ações básicas
As lições contém o contéudo principal. Elas poderão ser acessadas quantas vezes forem neces-
sárias, desde que esteja dentro da semana programada. Ao final de uma lição, você receberá
uma nota de acordo com o seu desempenho. Responda com atenção às perguntas de cada lição,
pois elas serão consideradas na sua nota final. Caso sua nota numa determinada lição for menor
do que 6.0, sugerimos que você faça novamente esta lição.
Ao final do curso será disponibilizada a avaliação referente ao curso. Tanto as notas das lições
quanto a da avaliação serão consideradas para a nota final. Todos os módulos ficarão visíveis
para que possam ser consultados durante a avaliação final.
Aconselhamos a leitura da "Ambientação do Moodle"para que você conheça a plataforma de
Ensino a Distância, evitando dificuldades advindas do "desconhecimento"sobre a mesma.
Os instrutores estarão a sua disposição ao longo de todo curso. Qualquer dúvida deverá ser
enviada no fórum. Diariamente os monitores darão respostas e esclarecimentos.
2.7 Programa
O curso de Java Swing oferecerá o seguinte conteúdo:
• Visão Geral
• Containers e Componentes
• Gerenciadores de Layout
• Manipulando ações básicas
2.8 Avaliação
Toda a avaliação será feita on-line.
Aspectos a serem considerados na avaliação:
• Iniciativa e autonomia no processo de aprendizagem e de produção de conhecimento;
• Capacidade de pesquisa e abordagem criativa na solução dos problemas apresentados.
Instrumentos de avaliação:
12

• Participação ativa nas atividades programadas.
• Avaliação ao final do curso.
• O participante fará várias avaliações referente ao conteúdo do curso. Para a aprovação e
obtenção do certificado o participante deverá obter nota final maior ou igual a 6.0 de acordo
com a fórmula abaixo:
• Nota Final = ((ML x 7) + (AF x 3)) / 10 = Média aritmética das lições
• AF = Avaliações
2.9 Bibliografia
• Site official: http://java.sun.com
• Guia em Português: http://www.javanoroeste.com.br/2006/tutoriais/swing_basico.html
13

Capítulo 3
Lição 1 - Visão Geral
Nesta lição será apresentada a API Java Swing.
3.1 Introdução
Introdução Swing é uma das 5 APIs que formam a JFC que é abreviatura de Java Foun-
dation Classes, que abrangem um grupo das características para construir Interfaces Gráficas
com o Usuários (GUIs) e adição de ricas funcionalidades e interatividade com aplicações Java.O
Swing veio como uma extensão do AWT(Abstract Window Toolkit) que dependia de componen-
tes específicos de cada plataforma , o que não acontece com Swing pois este contém apenas
códigos java , o que permite rodar em qualquer plataforma(Run Everywhere), entretanto estes
componentes são sensívelmente mais lentos que componentes nativos de qualquer plataforma.
Apesar da criaçao da Swing o AWT ainda é suportado. Para um bom rendimento neste curso o
aluno deve ter um conhecimento básico em Java e ser capaz de criar e compilar um aplicativo
básico nesta linguagem.
3.2 API Swing
A API Swing é poderosa, flexível e imensa, que possui pacotes públicos, cada um com sua
própria finalidade distinta:
javax.swing
Pacote swing de alto nível, consiste primariamente de componentes, adaptadores, modelos
padrão de componentes e interface.
javax.swing.border
O pacote border declara a interface Border e classes, que define especifico estilo de borda.
javax.swing.colorchooser
O pacote colorchooser contem suporte de para classes para componentes color chooser .
javax.swing.event
O pacote de event é para eventos e listeners específicos Swing. Adiciona ao java.awt.event
types, componentes Swing podem gerar seus próprios tipos de eventos.
javax.swing.filechooser
O pacote filechooser contem classes de suporte para componentes de seleção de arquivos.
javax.swing.plaf
14

Plug-in look-and-feel (PLAF) pacote que contém Interfaces com usuário(UI) classes (delega-
das) que implementam diferentes look-and-feel aspects para componentes Swing. Há também
alguns pacotes de PLAF sob a hierarquia.
javax.swing.table
O pacote table contem suporte para interfaces e e classes para o componente Swing table.
javax.swing.text
O pacote text contem classes de suporte para o framework do Swing de documento.
javax.swing.text.html
O pacote text.html contem classes de suporte para HTML versão 3.2 interpretador e analisa-
dor.
javax.swing.text.rtf
O pacote text.rtf contem classes de suporte para um básico interpretados Rich Text Format
(RTF).
javax.swing.tree
O pacote tree contem interface e classes para o componente tree do Swing.
javax.swing.undo
O pacote undo provê classes de suporte para implementar a capacidade de fazer/desfazer
nos GUI.
javax.accessibility
O pacote de acessibilidade da JFC é incluido nas classes Swing. Entretanto, seu uso não
será discutido aqui.
3.3 Componentes Swing
O widget é um termo sem tradução que designa componentes de interface gráﬁca com o
usuário (GUI). Qualquer item de uma interface gráﬁca é chamada de widget, por exemplo: janelas,
botões, menus ítens de menus, ícones, barras de rolagem, etc.
O pacote de acessibilidade da JFC é incluído nas classes Swing. Entretanto, seu uso não
será discutido aqui.
15

Figura1 -Hierarquia de componentes similares ao AWT.
Figura 2 - Hierarquia de componentes novos do Swing.
16

3.4 Galeria de componentes
17

Capítulo 4
Lição 2 - Containers e Componentes
Nesta lição serão apresentados os principais elementos para criação de interfaces com Swing.
4.1 Containers
Quase todas as interfaces gráﬁcas são compostas de uma janela principal ou de alto-nível,onde
são montados os outros componentes. Na Swing essas janelas são geralmente uma instancia
das classes JFrame ou JWindow. A diferênça entre essas duas classes esta na simplicidade,
JWindow não tem a barra de título e não coloca botões na barra de tarefas, portanto utilizaremos
a JFrame.
JFrame é a versão Swing do Frame(AWT) , porém ela é descendente direta da classe Frame, por
isso ao adicionarmos componentes ao JFrame teremos que utilizar o JPanel para gerenciar estes
componentes .
Características da JFrame: Janela com título , bordas, barra de menu (opcional) e componentes
especiﬁcados pelo usuário. Esta pode ser movida , ter o tamanho ajustado e permite a adição de
ícones. Veremos a seguir um exemplo de um JFrame. Código:
import javax.swing.*;
public class ExemploJFrame {
private JFrame f;
public ExemploJFrame(){
f = new JFrame("Exemplo de JFrame");
}
public void CriaFrame(){
f.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
f.setSize(300,300);
f.setVisible(true);
}
public static void main(String args[]){
ExemploJFrame janela = new ExemploJFrame();
janela.CriaFrame();
18

}
}
Copie o código e salve em um arquivo chamado "ExemploJFrame.java" compile com o co-
mando javac "nome_do_arquivo.java" (sem aspas) e rode com o comando java "nome_do_arquivo"
(sem aspas e sem o .java). o resultado esperado é este:
Figura 3 - Exemplo JFrame.
Vamos ver o código: para usar os elementos do java swing temos que utilizar o "import ja-
vax.swing.*", em seguida declaramos a classe ExemploJFrame e instanciamos um JFrame cha-
mado de f com o parâmetro que define o título da janela("Exemplo JFrame"), em seguida temos
o método construtor da classe , o CriaFrame(), neste método utilizamos 3 setings importantes .
O primeiro será utilizado em todos os exemplos do curso e serve para encerrar o programa, ou a
interface, ao clicarmos no botão fechar da janela. Sem esta linha nada aconteceria ao tentarmos
fechar a janela, esta só fecharia ao encerrarmos o programa. O segundo set define o tamanho
da tela, neste caso 300 x 300 pixels, mais à frente no curso veremos que em alguns casos não
será necessário definir o tamanho da tela, vamos utilizar gerênciadores de layout que ajustam
a tela de forma que todos os componentes estejam visíveis. Finalmente o último "set"mostra a
janela na tela. Em Java, a classe Container é a classe abstrata que define as funcionalidades
básicas associadas a um container, tais como adicionar e remover componentes, o que é possível
através dos métodos add() e remove(), respectivamente. É possível também estabelecer qual a
estratégia de disposição de componentes no container, ou seja, qual o método de gerência de
layout, através do método setLayout(). Estudaremos layouts na próxima lição.
Agora vamos adicionar um botão ao exemplo anterior, para isso vamos adicionar um botão
JButton ao JPanel e o JPanel ao JFrame . Veja o código:
public class Exemplo2fb {
public JFrame f;
public JButton botao;
public JPanel p;
19

public Exemplo2fb(){
f = new JFrame("Exemplo2 frame com botao ");
botao = new JButton("pressione");
p = new JPanel();
}
f.setSize(300,300); // tamanho do frame
p.add(botao); // adiciona botao ao JPanel
f.add(p); // adiciona o painel com botão ao frame
f.setVisible(true);
}
Exemplo2fb janela = new Exemplo2fb();
janela.CriaFrame();
}
}
Lembrando que para salvar o arquivo devemos utilizar o mesmo nome da classe ,ou seja, neste
caso seria "Exemplo2fb.java". O resultado do código é:
Figura 4 - JFrame com JPanel e botão.
Agora o aluno deve modificar o código e adicionar o botão diretamente ao frame, retirando as
linhas de código relativas ao JPanel. Ao fazer isto podemos verificar que o botão ocupou todo o
espaço da janela. Em nenhum momento foi definido o tamanho do botão , então porque ele se
comporta de forma diferente quando é adicionado ao JFrame e ao JPanel? A resposta para esta
pergunta pode ser encontrada na lição 3 - Gerenciadores de Layout.
20

Figura 5 - JFrame com Botão.
Podemos ver os containers como o cimento das aplicações em Swing eles agrupam os com-
ponentes que seriam os tijolos , ou seja para a maioria dos programas é necessario utilizar um
container onde serão inseridos os tipos de objetos desejados ou componentes, botões , campos
de texto , etc. Por definição Containers são componentes que podem conter outros componen-
tes. Como exemplo de containers temos JWindow , JFrame e JPanel, porém o JPanel deve ser
adicionado a um dos dois anteriores.
4.2 Componentes
Os componentes são como tijolos nas aplicaçoes Swing, estes podem ser agrupados em
containers para construir uma interface gráfica. Temos uma infinidade de componentes e a mai-
oria deles pode ser configurada de diversas formas o que oferece uma grande flexibilidade no
desenvolvimento de interfaces gráficas.
Neste curso veremos apenas os componentes mais básicos porém conhecendo estes será
muito mais fácil utilizar qualquer outro. Os principais componentes são :
JLabel - JLabel é um componente utilizado principalmente para mostrar textos e nomear
outros componentes. Se comparado ao Label do AWT o JLabel tem 3 vantagens importantes a
primeira é que este pode ser utilizado também para mostrar imagens, a segunda é a possibilidade
de usar bordas delimitando campos em uma janela. E a terceira é a possibilidade de utilizar
HTML para formatar o label, isto é feito adicionando <html> ao início da string do label, assim
ele é interpretado como HTML possibilitando mudar fontes, cores dentre outros efeitos. O JLabel
pode ter fonte, tamanho e cor configurados porém se for utilizado o HTML os controles padrões
do JLabel serão ignorados.
Vejamos alguns exemplos:
public class ExemploJLabel {
public JFrame f;
public JLabel texto;
public JLabel texto2;
public JPanel p;
21

public ExemploJLabel(){
f = new JFrame("Exemplo4 JLabel ");
texto = new JLabel("Este texto é um JLabel");
texto2 = new JLabel("ESTE TEXTO TAMBÉM É UM JLABEL");
p = new JPanel();
}
f.setSize(300,300);
p.add(texto);
p.add(texto2);
f.add(p);
f.setVisible(true);
}
ExemploJLabel janela = new ExemploJLabel();
janela.CriaFrame();
}
}
Resultado:
Figura 6 - ExemploJLabel
Agora usando HTML, veremos icones mais a frente em JButons.
import java.awt.*;
public class ExemploJLabel2{
public JFrame f;
public JLabel label;
22

public JLabel label2;
public JPanel p;
public ExemploJLabel2(){
f = new JFrame("Exemplo5 JLabel ");
label = new JLabel("<html><FONT COLOR=RED><B>JLabel colorido com HTML</B></FO
label.setBorder(BorderFactory.createTitledBorder("JLabel com borda"));
label2 = new JLabel("JLabel comum ");
p = new JPanel();
}
f.setSize(300,300);
p.setLayout(new BorderLayout());
p.add(label, BorderLayout.NORTH);
p.add(label2, BorderLayout.CENTER);
f.add(p);
f.setVisible(true);
}
ExemploJLabel2 janela = new ExemploJLabel2();
janela.CriaFrame();
}
}
Resultado:
23

Figura 7 - Exemplo JLabel com HTML
4.3 Componentes - Parte II
JButton - Botão que pode conter um texto ou um icone, suas funcionalidades são controla-
das pelo actionlistener, existem muitas fucionalidades que podem ser atribuidas a um botão, neste
curso abordaremos apenas principios basicos , assim fica a cargo do aluno pesquisar uma funci-
onalidade especifica na documentação da Sun ou nos varios sites sobre Swing na Internet.Uma
grande vantagem do swing é que você pode redimensionar e arrastar a janela sem configurar
nada e os componentes são reorganizados também de acordo com o layout escolhido.
Exemplo JButton com imagem:
import java.awt.*;
public class Botoes extends JFrame {
public static void main(String[] args) {
new Botoes();
}
public Botoes() {
super("Exemplo JButton");
JFrame frame= new JFrame();
Container content = getContentPane();
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
content.setLayout(new FlowLayout());
JButton botao1 = new JButton("Botao normal");
content.add(botao1);
ImageIcon cdtc = new ImageIcon("f1.png");
JButton botao2 = new JButton(cdtc);
botao2.setBackground(Color.yellow); // Define a cor de fundo do botão
content.add(botao2);
pack(); // monta a janela ajustando o tamanho de acordo com os componentes
setVisible(true);
}
}
24

Resultado:
Figura 8 - Exemplo JButton
JTextField - JtextField é uma área para texto que pode ser muito útil para formulários. Este
componente geralmente é usado combinado com o JLabel que adciona um nome ao campo.
JRadioButton - similar ao JButton porém esse é usado para marcar 1 ou mais opções dentre
as disponíveis.
Exemplo JTextField e JRadioButton :
import java.awt.*;
public class Textfield extends JFrame {
new Textfield();
}
public Textfield() {
super("Exemplo JTextField");
JFrame frame= new JFrame(); // instancia JFrame
Container content = getContentPane(); // Cria o container
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);//finaliza programa ao fechar
setSize(500,120); // determina o tamanho da janela
content.setLayout(new BorderLayout());// define o layout do container
JPanel painel1 = new JPanel(); // cria o painel que conterá o label nome e
//o campo texto
FlowLayout layout = new FlowLayout();//instancia o flowlayout para alinhar os
//componentes
layout.setAlignment(FlowLayout.LEFT);// define alinhamento à esquerda
painel1.setLayout(layout); //define o layout do painel1 flowlayout à esquerda
JPanel painel2 = new JPanel();//cria o painel que conterá o label endereço
//e o texto
painel2.setLayout(layout); //define o layout do painel3 flowlayout à esquerda
JPanel painel3 = new JPanel(); //painel3 contem o label sexo e os botoes
//do tipo radio
painel3.setLayout(layout);
JLabel nome = new JLabel("Nome");//cria um label
painel1.add(nome); //adiciona o label ao painel 1
JTextField nomef = new JTextField(10);
painel1.add(nomef);
25

JLabel endereco = new JLabel("Endereço");
painel2.add(endereco);
JTextField endf = new JTextField(30);
painel2.add(endf);
JLabel sexo = new JLabel("Sexo:");
painel3.add(sexo);
JRadioButton masculino = new JRadioButton("Masculino");
painel3.add(masculino);
JRadioButton fem = new JRadioButton("Feminino");
painel3.add(fem);
content.add(painel1, BorderLayout.NORTH); // define o painel1 como
//parte norte do container
content.add(painel2, BorderLayout.CENTER);// define o painel2 como
//parte centro do container
content.add(painel3, BorderLayout.SOUTH); // define o painel3 como
//parte sul do container
setVisible(true);
}
}
Resultado:
Figura 9 - JTextField com JRadioButton
JPasswordField - este é o campo utilizado para senhas, sua utilização é idêntica ao do JText-
Field e o texto digitado aparece como "*"(o caractere que aparece no JPasswordField também
pode ser conﬁgurado).
JPanel - é container intermediário pois deve ser adicionado a um outro container(JFrame ou
JWindow). É a forma mais simples de se construir uma interface, basta instancia-lo adicionar os
componentes a ele e então adiconar o JPanel a algum container.No exemplo acima utilizamos
3 instâncias do JPanel e adicionamos a cada uma um JLabel e um Componente e em seguida
adicionamos cada JPanel a uma área do JFrame.
Uma das razões de se utilizar o JPanel é que Componentes em um JPanel dentro do frame
não são reajustados, ou seja, podemos aumentar a janela e o tamanho dos componentes perma-
necerá o mesmo, o que observamos que não acontece se adicionarmos direto ao JFrame(como
visto na primeira página desta lição) .
26

Capítulo 5
Lição 3 - Gerenciadores de Layout
Nesta lição serão apresentados alguns exemplos dos responsáveis pela organização de ele-
mentos em uma interface.
5.1 Gerenciadores de Layout
Os gerenciadores de Layout são responsáveis por organizar os componentes em um con-
tainer não só ao adicionarmos mas também quando redimensionamos as janelas, é possível
usar diversos tipos de gerenciadores em uma mesma interface assim como é possivel "desligar"o
gerenciador de layout para um dado container e definir manualmente a posição , o tamanho e
outras configurações de cada componente adicionando ao container. Cada tipo de container tem
um layout padrão porém frequentemente temos que mudar o layout do container para obter a
disposição de componentes desejada. Veremos agora as principais características de alguns
gerenciadores de layout.
FlowLayout
O gerenciador de layout de ?fluxo? apenas posiciona os componentes em fila, um após o
outro, cada qual com suas dimensões mínimas. O FlowLayout imita o fluxo de textos, e pode
alinhar os componentes à direita, à esquerda, ou centraliza-los dentro do container. O uso mais
comum deste layout é para preencher uma linha com maior quantidade possível de componentes,
por exemplo em barras de ferramentas ou de status.
Figura 10 - Exemplo FlowLayout
Figura 11 - Exemplo FlowLayout redimensionado
27

BorderLayout
O BorderLayout posiciona os componentes nas ?bordas? do container, deixando a maior
parte de sua área disponível para o componente inserido no centro. Cada borda é identiﬁcado
por um ponto cardeal(NORTH,SOUTH, EAST, WEST). Apenas um componente será visível em
cada borda, expandindo-se na altura ou largura para ocupar toda a borda do container, porém
assumindo o valor mínimo na outra dimensão. O BorderLayout é o layout padrão do JFrame
,por isso , na lição 2 quando adicionamos um botão ao JFrame ele automaticamente ocupou
a posição central, como os outros pontos (norte, sul, etc.) não foram utilizados o botão ocupa
todo espaço da janela mesmo que ela seja redimensionada. Os pontos norte e sul podem ser
reajustados horizontalmente. Os pontos leste e oeste podem ser reajustados verticalmente, e o
central em todas as direções ( Obs: Experimente adicionar um botão a cada um deles e reajustar
a janela). Note que esta disposição reﬂete o padrão na maioria das aplicações desktop, como
processadores de texto ou programas de desenho: uma barra de ferramentas ao norte, uma barra
de status ao sul, opcionalmente outras barras de ferramentas ao leste e oeste, e uma área de
edição ao centro.
Código:
import java.awt.BorderLayout;
import java.awt.Container;
import java.awt.Dimension;
import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JLabel;
public class DemoBorderLayout {
public static boolean RIGHT_TO_LEFT = false;
public static void addComponentsToPane(Container pane) {
if (!(pane.getLayout() instanceof BorderLayout)) {
pane.add(new JLabel("O Container nÃ¿o usa BorderLayout!"));
return;
}
if (RIGHT_TO_LEFT) {
pane.setComponentOrientation(
java.awt.ComponentOrientation.RIGHT_TO_LEFT);
}
JButton button = new JButton("Boatao 1 (PAGINA_INICIAR)");
pane.add(button, BorderLayout.PAGE_START);
//Faz a centralização de um grande componente, deste que
//tipico do uso de BorderLayout.
button = new JButton("Boatao 2 (CENTRO)");
button.setPreferredSize(new Dimension(200, 100));
pane.add(button, BorderLayout.CENTER);
button = new JButton("Boatao 3 (INICIAR_LINHA)");
28

pane.add(button, BorderLayout.LINE_START);
button = new JButton("NOME-LONGO Boatao 4 (FIM_PAGINA)");
pane.add(button, BorderLayout.PAGE_END);
button = new JButton("5 (FIM_LINHA)");
pane.add(button, BorderLayout.LINE_END);
}
/**
* Cria um GUI e o exibe. Para thread safety,
* este metodo podera invocar para uma thread
* de disparo de evento(event-dispatching thread).
*/
private static void createAndShowGUI() {
//Faz com que tenha uma decoracao de janela.
JFrame.setDefaultLookAndFeelDecorated(true);
//Cria e organiza a janela.
JFrame frame = new JFrame("DemoBorderLayout");
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
//Organiza o conteudo no painel.
addComponentsToPane(frame.getContentPane());
//Uso do conteudo do painel por padrão o BorderLayout.
//Não é necessario definir
//setLayout(new BorderLayout());
//Exibe janela.
frame.pack();
frame.setVisible(true);
}
//Agenda um trabalho para o event-dispatching thread:
//cria e exibe uma aplicacao GUI.
javax.swing.SwingUtilities.invokeLater(new Runnable() {
public void run() {
createAndShowGUI();
}
});
}
}
Resultado:
29

Figura 12 - Exemplo BorderLayout
GridLayout
O GridLayout organiza os componentes em uma ?grade? ou tabela com número de linhas e
colunas pré-ﬁxado no momento da sua criação. Todas as células possuem o mesmo tamanho, e
são expandidas igualmente para ocupar a área total disponível no container. Caso haja menos
componentes do que células, o espaço das células vázias é distribuído entre os componentes;
mas podem ﬁcar células vázias nas últimas colunas da última linha. O GridLayout é adequado
quando se deseja que um grupo de componentes (ex.? Um grupo de botões) tenha dimensões
uniformes, como na caixa de ferramentas de um programa de desenho ou par de botões ?OK? e
?Cancelar? de um diálogo.
Código:
import java.awt.*;
public class DemoGridLayout {
public final static boolean RIGHT_TO_LEFT = false;
pane.setComponentOrientation(
ComponentOrientation.RIGHT_TO_LEFT);
}
pane.setLayout(new GridLayout(0,2));
pane.add(new JButton("Botoao 1"));
pane.add(new JButton("Botao Nome-Longo 4"));
pane.add(new JButton("5"));
}
/**
*/
30

JFrame frame = new JFrame("DemoGridLayout");
//Exibe janela.
frame.pack();
}
public void run() {
createAndShowGUI();
}
});
}
}
Resultado:
Figura 13 - Exemplo GridLayout
GridBagLayout
Com nome estranho(?saco de grades?), o GridBagLayout é o mais poderoso e o mais ﬂexível
dos gerenciadores fornecidos com o J2EE. Ele imita em linhas gerais o funcionamento de uma
tabela HTML, em que um componente pode ocupar várias células, ou seja, se estender por
várias colunas e linhas. Os componentes podem ser expandidos para ocupar toda a área das
suas células, ou serem alinhados em qualquer posição do conjunto de células. Linhas e colunas
assumem as dimensões do maior componente, mas é necessário que tenham todas o mesmo
tamanho. E algumas células podem ser conﬁguradas para ocuparem toda a área disponível no
container.
Este layout tem como base a utilização de um GridBagConstraints para cada componente
inserido. É este objeto que proporcionará a liberdade que queremos com o layout. A GridBag-
Constraints é uma classe que não possui métodos, ela servirá simplesmente para armazenar as
informações para cada componente adicionado. Vamos dar uma olhada nas propriedades da
classe:
31

anchor: Essa propriedade é utilizada somente quando o tamanho do componente é menor
que a área que lhe foi concedida. Normalmente, queremos que nosso componente ocupe toda a
área disponível, mas em casos especiais, não podemos redimensionar os componentes. Sendo
assim, o layout precisa saber em que posição da célula deixará o componente. Os valores para
esse campo são de dois tipos: Absolutos (CENTER, NORTH, NORTHEAST, EAST, SOUTHE-
AST, SOUTH, SOUTHWEST, WEST, e NORTHWEST) e Relativos (PAGE_START, PAGE_END,
LINE_START, LINE_END, FIRST_LINE_START, FIRST_LINE_END, LAST_LINE_START and
LAST_LINE_END). O valor padrão é CENTER.
fill: Determina como redimensionar o componente. Valores possíveis para esta propriedade
são: NONE: Não redimensiona o componente HORIZONTAL: Redimensiona horizontalmente,
fazendo com que o mesmo ocupe toda a área horizontal na célula VERTICAL: Redimensiona ver-
ticalmente, fazendo com que o mesmo ocupe toda a área vertical na célula BOTH: Redimensiona
para ambas as direções. Valor padrão é NONE
gridx e gridy
Especificam a posição X,Y para adicionar o componente. Não é necessário alterar seus valo-
res, pois seu valor padrão é a constante RELATIVE e portanto o layout adicionará após o último
componente que foi colocado. - gridx: Permite especificar qual a posição absoluta horizontal-
mente que o componente será adicionado. - gridy: Permite especificar qual a posição absoluta
verticalmente que o componente será adicionado.
gridheight e gridwidth
Especificam o tamanho do componente baseado em células. É com essa propriedade que
você indicará que um componente seu ocupará duas células, ou ocupurá tantas quanto forem ne-
cessárias para ir até o final da tela. Lembrem-se é células e não pixels Nestes valores podem ser
utilizadas duas constantes: REMAINDER e RELATIVE. REMAINER fará com que o componente
se estique até a última célula. Já o RELATIVE fará com que o componente ocupe todas as casas
com excessão da última. - gridheight: Especifica o número de células que o componente ocupará
verticalmente. Valor padrão é 1. - gridwidth: Especifica o número de células que o componente
ocupará horizontalmente. Valor padrão é 1.
insets
Indica as distãncias entre os componentes do layout. Um Insets possui valores para as 4
direções, cima, baixo, direita e esquerda. Permitindo com isso muita flexibilidade no gerenciador.
Valor padrão é new Insets(0, 0, 0, 0)
weight
Essas propriedades especificam um percentual de crescimento da célula, não do componente,
quando a mesma precisa ser redimensionada. É dito isso, pois se o componente não pode se
redimensionar, pois a propriedade fill do constraint afirma isso, o componente não vai sofrer
as alterações, mas a célula irá aumentar. Com este layout é possível informar que uma célula
redimensionará 75% e o outra 25%, portanto o primeiro componente receberá 3 vezes mais
tamanho do que o segundo.
O valor padrão é 0 e os valores percentuais são dados em casas decimais, por exemplo: 0.03
é igual a 3%, 1.00 é igual a 100% e por aí vai. - weightx: Peso em x. Especifica um peso no
redimensionamento. Este peso será utilizado para um cálculo que o layout faz para determinar
quais as células irão redimensionar horizontalmente, quais não irão, e quais aumentarão mais
que os outros. - weighty: Peso em y. Especifica um peso no redimensionamento. Este peso será
utilizado para um cálculo que o layout faz para determinar quais as células irão redimensionar
verticalmente, quais não irão, e quais aumentarão mais que os outros.
ipadx e ipady
Determina um adicional nas bordas internas do componenete. Essa propriedade modifica o
32

tamanho mínimo de cada componente. O tamanho mínimo será o ipad + o valor mínimo do com-
ponente. - ipadx: Valor para ser adicionado horizontalmente. - ipady: Valor para ser adicionado
verticalmente.
Podemos aﬁrmar com segurança que qualquer disposição de componentes pode ser conﬁgu-
rada em um GridBagLayout. Por outro lado, a quantidade de constraints(propriedades e restrições
de layout) possível para cada componente também deu a este gerenciador a fama de ser difícil
de programar.
Código:
import java.awt.*;
import javax.swing.JButton;
import javax.swing.JFrame;
public class DemoGridBagLayout {
final static boolean shouldFill = true;
final static boolean shouldWeightX = true;
final static boolean RIGHT_TO_LEFT = false;
pane.setComponentOrientation(ComponentOrientation.RIGHT_TO_LEFT);
}
JButton button;
pane.setLayout(new GridBagLayout());
GridBagConstraints c = new GridBagConstraints();
if (shouldFill) {
//altura natural, largura maxima.
c.fill = GridBagConstraints.HORIZONTAL;
}
button = new JButton("Botao 1");
if (shouldWeightX) {
c.weightx = 0.5;
}
c.gridx = 0;
c.gridy = 0;
pane.add(button, c);
c.gridx = 1;
c.gridy = 0;
c.gridx = 2;
c.gridy = 0;
33

button = new JButton("Botao 4 - Nome-Longo");
c.ipady = 40; //faz o componente no alto.
c.weightx = 0.0;
c.gridwidth = 3;
c.gridx = 0;
c.gridy = 1;
button = new JButton("5");
c.ipady = 0; //esvazia por padrao
c.weighty = 1.0; //requisita um espaco vertical extra.
c.anchor = GridBagConstraints.PAGE_END; //espaco em baixo.
c.insets = new Insets(10,0,0,0); //top padding
c.gridx = 1; //alinhamento do botao 2.
c.gridwidth = 2; //2 colunas largas.
c.gridy = 2; //terceira linha.
}
/**
*/
JFrame frame = new JFrame("DemoGridBagLayout");
//Exibe janela.
frame.pack();
}
public void run() {
createAndShowGUI();
34

}
});
}
}
Resultado:
Figura 14 - Exemplo GridBagLayout
35

Capítulo 6
Lição 4 - Manipulando Ações Básicas
Nesta lição serão apresentados métodos para executar ações em uma interface.
6.1 Manipulando Ações Básicas
Agora que você já aprendeu como colocar componentes na tela, você vai saber como res-
ponder às ações do usuário com os componentes. O principal mecanismo para isso é o padrão
Observer, implementado em Swing com os "event listeners"(ou observadores de eventos). Os
componentes emitem notificações sobre eventos, e o event listener recebe essas notificações.
Por exemplo, para executar um código quando o usuário aperta um botão, você deve definir um
listener para o evento "pressionar botão"e ligar o evento a esse botão.
Código:
import java.awt .*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import javax.swing .*;
public class MainFrame extends JFrame{
new MainFrame();
}
public MainFrame (){
super ( "Exemplo ActionListener");
setSize (300,300);
setDefaultCloseOperation (JFrame.EXIT_ON_CLOSE);
Container content = getContentPane ();
content.setLayout (new BorderLayout ());
36

JPanel painel = new JPanel (new FlowLayout ());
JButton botao1 = new JButton ( "Botao 1");
painel.add (botao1);
botao1.addActionListener (new MyButtonListener (this));
painel.add (new JButton ( "Botao 2"));
painel.add (new JButton ( "Botao 3"));
content.add (painel, BorderLayout.SOUTH);
content.add (new JScrollPane (new JTextArea ()), BorderLayout.CENTER);
painel = new JPanel (new FlowLayout ());
painel.add (new JLabel ( "Digite seu nome"));
painel.add (new JTextField (10));
String opcoes[] = new String[]{ "Opção 1", "Opção 2", "Opção 3"};
painel.add(new JComboBox (opcoes));
content.add (painel, BorderLayout.NORTH);
pack();
setVisible(true);
}
private class MyButtonListener implements ActionListener{
private JFrame parentComponent;
MyButtonListener (JFrame parentComponent){
this.parentComponent = parentComponent;
}
public void actionPerformed (ActionEvent e){
JOptionPane.showMessageDialog (parentComponent, "BOTÃO 1 PRESSIONADO!");
37

}
}
}
Figura 15 - Exemplo ActionListener
Figura 16 - Exemplo botão pressionado
Neste exemplo, nós criamos um ActionListener e ligamos apenas ao botão1. A interface do
ActionListener tem apenas um método: actionPerformed. Esse método é chamado quando uma
ação ocorre. O evento ActionEvent é o tipo mais comum em Swing - a maioria dos componen-
tes produzem um ActionEvent. Componentes podem também produzir outros eventos - como a
mudança da seleção atual, texto ou tamanho. Por enquanto, o nosso foco é no ActionEvent. Em
todo o caso, procure ,em uma IDE que exibe métodos de uma classe, por métodos que come-
çam com add e terminam com Listener (por exemplo, addFocusListener) para ver o que tipos de
event/Listener um componente suporta.
Mais uma coisa interessante neste exemplo é a utilização da classe JOptionPane. Essa classe
contém muitos métodos úteis que ajudam na exibição padronizada de diálogos entradas e diálo-
gos de mensagem.
O exemplo acima, não está escrito no estilo usual para Swing. Já que a única fução do
listener é chamar um método, ele é frequentemente escrito como uma classe interna anonima
(inner class).
Código:
Botao1.addActionListener (
new ActionListener ()
{
Público void actionPerformed (ActionEvent e)
{
38

JOptionPane.showMessageDialog(MainFrame.this,"BOTÃOPRESSIONADO!");
}
});
Podemos observar que existem também outras formas de receber notiﬁcações eventos e,em
seguida, instalar um listener para cada objeto na tela. Por exemplo, o código abaixo instala um
listener global para pressionar a tecla F1:
KeyStroke ks=KeyStroke.getKeyStroke(KeyEvent.VK_F1,0);
topComponent.getInputMap ( JComponent.WHEN_ANCESTOR_OF_FOCUSED_COMPONENT).put(ks,"HELP");
topComponent.getActionMap().put("HELP",
new AbstractAction()
{
public void actionPerformed(ActionEvent evt)
{
// coloque um diálogo ou mensagem aqui
}
});
Este curso abordou apenas alguns tópicos do Java Swing já que qualquer abordagem pro-
funda de qualquer tópico da linguagem Java se torna muito extensa.
39

Java swing

Recomendados

Recomendados

Mais conteúdo relacionado

Mais procurados

Mais procurados (20)

Destaque

Destaque (15)

Semelhante a Java swing

Semelhante a Java swing (20)

Mais de Tiago

Mais de Tiago (20)

Último

Último (20)

Java swing