Embed Size (px)
Citation preview
UNIVERSIDADE ESTÁCIO DE SÁ
SISTEMAS DE INFORMAÇÃO
RESUMO PROGRAMAÇÃO ORIENTADA A OBJETOS - JAVA
Prof. Fernando André da Silva
1º Semestre/2012
2
INDICE
INTRODUÇÃO À LINGUAGEM JAVA ................................................................................................... 4
BREVE HISTÓRIA DO JAVA ........................................................................................ 4
VANTAGENS DA LINGUAGEM JAVA .......................................................................... 4 PROGRAMAÇÃO ORIENTADA A OBJETOS .................................................................. 8 CLASSE ..................................................................................................................... 8 CONSTRUTORES ...................................................................................................... 15 MÉTODOS ............................................................................................................... 17
CONTROLE DE FLUXO – ESTRUTURAS DE SELEÇÃO E REPETIÇÃO .......................... 20 ENCAPSULAMENTO ................................................................................................. 24 SOBRECARGA DE MÉTODOS .................................................................................... 27
INTERFACES ............................................................................................................ 28 TRY-CATCH-FINALLY .............................................................................................. 32
UNIDADE 1 – INTERFACES GRÁFICAS USANDO JFC/SWING ..................................................... 37
1.1 INTRODUÇÃO .................................................................................................... 37 1.1.2 Componentes Swing ................................................................................................. 37 1.1.3 Componentes A.W.T. ................................................................................................ 38 1.1.4 Look and Feel .......................................................................................................... 38
1.2 HIERARQUIA DE CLASSE ................................................................................... 40 1.2.1 java.lang.Object ....................................................................................................... 40 1.2.2 java.awt.Component ................................................................................................ 41 1.2.3 java.awt.Container ................................................................................................... 43 1.2.4 javax.swing.JCompontent ........................................................................................ 44
1.3 MODELOS DE DESENVOLVIMENTO .................................................................... 45 1.3.1 Desenvolvimento do Swing ...................................................................................... 45
1.3.1.1 JDialog ........................................................................................................... 45 1.3.1.2 Exercícios....................................................................................................... 54
1.3.2 JFrame ..................................................................................................................... 56 1.3.3 JPainel ..................................................................................................................... 58 1.3.4 JLabel....................................................................................................................... 58 1.3.5 Gerenciador de Layout ............................................................................................ 60
1.3.5.1 FlowLayout .................................................................................................... 60 1.3.5.2 BorderLayout ................................................................................................. 62 1.3.5.3 GridLayout ..................................................................................................... 64 1.3.5.4 BoxLayout ..................................................................................................... 65 1.3.5.5 CardLayout .................................................................................................... 67 1.3.5.6 GridBagLayout .............................................................................................. 71 1.3.5.7 SpringLayout ................................................................................................. 71
1.3.6. JTextField ............................................................................................................... 71 1.3.6.1 Exercícios....................................................................................................... 74
1.3.7 Listas (JComboBox) ................................................................................................. 77 1.3.8. Eventos de Botões ................................................................................................... 78
Exemplo3: .................................................................................................................. 82 1.3.8.1 Exercícios....................................................................................................... 84
1.3.7 Manipulação de Aspectos Visuais ............................... Erro! Indicador não definido. 1.3.8 Variação de Componentes Visuais.............................. Erro! Indicador não definido. 1.3.9 JTextArea .................................................................... Erro! Indicador não definido. 1.3.10 JPasswordField......................................................... Erro! Indicador não definido. 1.3.11 JTabbedPane............................................................. Erro! Indicador não definido.
LISTA 3 DE EXERCICIOS ...................................... ERRO! INDICADOR NÃO DEFINIDO. 1.3.11 JInternalFrame ......................................................... Erro! Indicador não definido.
UNIDADE 2 – TRATAMENTO DE EVENTOS......................... ERRO! INDICADOR NÃO DEFINIDO.
2.1 DELEGAR TRATAMENTO DE EVENTOS .......... ERRO! INDICADOR NÃO DEFINIDO. 2.2 MANIPULAÇÃO DE EVENTOS ......................... ERRO! INDICADOR NÃO DEFINIDO.
3
2.2.1 Comuns ....................................................................... Erro! Indicador não definido. 2.2.2 Janelas ........................................................................ Erro! Indicador não definido. 2.2.3 Menus .......................................................................... Erro! Indicador não definido.
2.2.3.1 JButton ............................................................ Erro! Indicador não definido. 2.2.3.2 JRadioButton .................................................. Erro! Indicador não definido. 2.2.3.3 JCheckBox ...................................................... Erro! Indicador não definido. 2.2.3.4 JComboBox .................................................... Erro! Indicador não definido. 2.2.3.5 JMenuBar ........................................................ Erro! Indicador não definido. 2.2.3.6 JMenuItem ...................................................... Erro! Indicador não definido. 2.2.3.7 JPopupMenu ................................................... Erro! Indicador não definido.
2.2.4 Textos .......................................................................... Erro! Indicador não definido. 2.2.5 Lista ............................................................................ Erro! Indicador não definido. 2.2.6 Combos ....................................................................... Erro! Indicador não definido. 2.2.7 Tabelas ........................................................................ Erro! Indicador não definido. 2.2.8 Teclas de Atalho .......................................................... Erro! Indicador não definido. 2.2.9 Frames Interno............................................................ Erro! Indicador não definido.
UNIDADE 3 - THREADS ............................................................. ERRO! INDICADOR NÃO DEFINIDO.
3.1 THREADS ...................................................... ERRO! INDICADOR NÃO DEFINIDO. 3.2 CRIAÇÃO DE THREADS .................................. ERRO! INDICADOR NÃO DEFINIDO.
3.3 MANIPULAÇÃO DE THREADS ........................ ERRO! INDICADOR NÃO DEFINIDO.
UNIDADE 4 - EXEMPLOS DO LIVRO ..................................... ERRO! INDICADOR NÃO DEFINIDO.
ANEXO ........................................................................................... ERRO! INDICADOR NÃO DEFINIDO.
GABARITO EXERCÍCIOS ITEM 1.3.1.2 .................. ERRO! INDICADOR NÃO DEFINIDO.
GABARITO EXERCÍCIOS ITEM 1.3.6.1 .................. ERRO! INDICADOR NÃO DEFINIDO. GABARITO EXERCÍCIOS ITEM 1.3.8.1 .................. ERRO! INDICADOR NÃO DEFINIDO.
PLANO DE AULA ......................................................................... ERRO! INDICADOR NÃO DEFINIDO.
1.4 EXERCÍCIOS.................................................. ERRO! INDICADOR NÃO DEFINIDO.
4
INTRODUÇÃO À LINGUAGEM JAVA
Breve História do Java
A Sun criou um time (conhecido como Green Team) para desenvolver inovações tecnológicas
em 1992. Esse time foi liderado por James Gosling, considerado o pai do Java. O time voltou
com a idéia de criar um interpretador (já era uma máquina virtual, veremos o que é isso mais a
frente) para pequenos dispositivos, facilitando a reescrita de software para aparelhos eletrônicos,
como vídeo cassete, televisão e aparelhos de TV a cabo.
A idéia não deu certo. Tentaram fechar diversos contratos com grandes fabricantes de
eletrônicos, como Panasonic e outras, mas não houve êxito devido ao conflito de interesses.
Hoje, sabemos que o Java domina o mercado de aplicações para celulares com mais de 2.5
bilhões de dispositivos compatíveis, porém em 1994 ainda era muito cedo para isso.
Com o advento da web, a Sun percebeu que poderia utilizar a idéia criada em 1992 para rodar
pequenas aplicações dentro do browser. A semelhança era que na internet havia uma grande
quantidade de sistemas operacionais e browsers, e com isso seria grande vantagem poder
programar numa única linguagem, independente da plataforma. Foi aí que o Java 1.0 foi lançado:
focado em transformar o browser de apenas um cliente fino (thin client ou terminal burro) para
uma aplicação que possa também realizar operações, não apenas renderizar html.
Atualmente os applets realmente não são o foco da Sun. É curioso notar que a tecnologia Java
nasceu com um objetivo em mente, foi lançado com outro, mas, no final, decolou mesmo no
desenvolvimento de aplicações do lado do servidor. Sorte?
Você pode ler a história da linguagem Java em: http://java.sun.com/java2/whatis/1996/
storyofjava.html
Em 2009 a Oracle comprou a Sun, fortalecendo a marca. A Oracle sempre foi, junto com a IBM,
uma das empresas que mais investiram e fizeram negócios com tecnologias Java.
No Brasil, diversos grupos de usuários se juntaram para tentar disseminar o conhecimento da
linguagem.
Um deles é o GUJ (http://www.guj.com.br), uma comunidade virtual com artigos, tutoriais e
fórum para tirar dúvidas, o maior em língua portuguesa.
Encorajamos todos os alunos a usar muito os fóruns do mesmo, pois é uma das melhores
maneiras para achar soluções para pequenos problemas que acontecem com grande freqüência.
Vantagens da Linguagem Java
Quando a linguagem Java foi criada, a equipe de desenvolvimento tinha como principal objetivo
fazer do Java uma linguagem melhor do que as ja existentes no mercado.
Baseando-se nas linguagens C/C++, a equipe de Gosling pensou em algo robusto, portável,
seguro, com código limpo e fácil de programar.
5
Quando falamos em facilidade para programar, estamos falando em simplificar certas coisas que
"atrapalham" o dia a dia do programador, fazendo-o de modo seguro, ou seja, simplificar não
significa deixar de usar e sim facilitar algo de modo seguro e concreto.
As vezes quando falamos em facilidades, algumas pessoas enxergam desvantagens. A equipe de
James Gosling viu vantagens na linguagem que haviam criado. Alguns programadores hoje
acham essas vantagens negativas para eles, mas na verdade, nem sempre é.
Algumas vantagens que a linguagem Java possui
Independência de Plataforma
Essa talvez seja o grande trunfo da linguagem Java. Ser independente de plataforma significa
muito nos dias atuais. quando falamos em uma linguagem multiplataforma, queremos dizer que
Java não depende de nenhum Sistema Operacional para rodar, ou seja, tanto faz em qual SO
você irá rodar o seu bytecode (arquivo .class). quando a Sun criou a JVM (Java Virtual
Machine), ela especificou que, para diversos SO's haveriam máquinas virtuais diferentes, ou seja,
para tornar a linguagem multiplataforma, a Sun desenvolveu não só JVM's para sistemas
Operacionais diferentes, como J2SDK's diferentes também, ou seja, para diferentes SO's
(Windows, Linux, Solaris, etc) há a JVM e o JSDK.
Se você desenvolve um programa em windows, por exemplo, compila ele no windows, pode-se
muito bem rodar ele na JVM de um Linux. este exemplo caracteriza a multiplataforma do java.
Java não usa explicitamente ponteiros
Nem todos acham essa uma vantagem, mas só quem trabalhou com linguagens que tem ponteiros
que manipulam endereço de memória diretamente sabem o trabalho que dá. Pensando nisso, os
desenvolvedores da linguagem java, eliminaram a manipulação direta de ponteiros. O que ocorre
é o apontamento para um endereço de memória, ou seja, quando você cria um objeto, você está
apontando em qual endereço de memória esse objeto ficará alocado.
Não implementa herança múltipla
Não é exatamente uma vantagem mas facilita o trabalho do programador. A única forma de fazer
herança multipla, de forma indireta, é quando uma classe herda uma outra classe e implementa
interface (classe que contém apenas declaração dos métodos).
Possui "Coleta de Lixo" automática. Isso significa que ela desaloca automaticamente qualquer
espaço de memória não utilizado sem que o programador se preocupe com isso.
Robustez
Os recursos da linguagem e do ambiente para o tempo de execução garantem que o código não
derrube o sistema de alguém que "tropece" em uma home page contendo uma animação.
Orientação a Objetos
Java é uma linguagem totalmente orientada a objetos, o que permite a herança e a reutilização de
códigos de forma dinâmica e estática.
6
Alto Desempenho
A linguagem Java suporta vários recursos de alto desempenho, como multithreading, compilação
just-in-time e utilização de código nativo. O byte-code do Java possui um desempenho
aproximadamente 20 vezes inferior que o de um código nativo do processador (ou linguagem de
máquina), mas que em comparação com linguagens Script, como o HTML, o JavaScript ou o
VBScript, ou até mesmo o próprio byte-code do VB (Visual Basic), possui uma performance
muitas vezes superior. Esta performance, pela quantidade de esforços aplicados sobre a sua
otimização pelos desenvolvedores de Java, está cada vez mais sendo aumentada, podendo um dia
comparar-se com uma linguagem compilada para o processador em específico (linguagem
nativa). Inclusive já foram criados processadores para suportar diretamente o byte-code da
linguagem Java.
Facilidade
A linguagem é derivada da linguagem C e C++, sendo assim familiar. Além disso, o ambiente
retira do programador a responsabilidade de gerenciar a memória e os ponteiros.
Além dessas vantagens, a linguagem Java está agora incorporando suporte a operações em
Banco de Dados. O JDBC, que é uma biblioteca de classes para acesso a banco de dados,
permite uma conexão remota a servidores SQL que possuam driver OBDC ou compatível.
Transações no estilo de Compras, Vendas, Cadastramentos, Alteração de dados pessoais
controlada por senha via Internet, são exemplos do que o JDBC permite que seja realizado.
Desvantagens da Linguagem
Apesar disso, a linguagem também possui as seguintes desvantagens:
Performance reduzida: por ser uma linguagem não projetada para gerar código nativo
para cada arquitetura, os programas em Java costumam ter um desempenho menor que os
escritos em linguagens como C++. Eles também costumam ocupar mais espaço em
memória. Mas à medida que a linguagem vem sendo refinada, tal desvantagem vem
diminuindo cada vez mais.
Programas em Java geralmente demoram mais tempo para compilar.
Programas que realizam cálculo com números em ponto flutuante tendem a possuir baixo
desempenho.
A Linguagem Java
É uma linguagem de progração que permite o desenvolvimento de aplicações para uma série de
plataformas. É possível ter software Java desde de dispositivos pequenos, como telefones
celulares, até computadores de grande porte, como os mainframes, por exemplo. Devido a essa
característica, a linguagem Java conta com três conhecidos ambientes de desenvolvimento:
JSE ou J2SE (Java Standard Edition);
JEE ou J2EE (Java Enterprise Edition);
JME ou J2ME (Java Micro Edition).
7
JSE
O JSE (Java Standard Edition) é o ambiente de desenvolvimento mais utilizado. Isso porque seu
uso é voltado a PCs e servidores, onde há bem mais necessidade de aplicações. Além disso,
pode-se dizer que essa é a plataforma principal, já que, de uma forma ou de outra, o JEE e o JME
tem sua base aqui. Pode-se dizer também que esses ambientes de desenvolvimento são versões
aprimoradas do JSE para as aplicações a que se propõem.
Por ser a plataforma mais abrangente do Java, o JSE é a mais indicada para quem quer aprender
a linguagem.
JEE
O JEE (Java Enterprise Edition) é a plataforma Java voltada para redes, internet, intranets e
afins. Assim, ela contém bibliotecas especialmente desenvolvidas para o acesso a servidores, a
sistemas de e-mail, a banco de dados, etc. Por essas características, o JEE foi desenvolvido para
suportar uma grande quantidade de usuários simultâneos.
JME
O JME (Java Micro Edition) é o ambiente de desenvolvimento para dispositivos móveis ou
portáteis, como telefones celulares e palmtops. Como a linguagem Java já era conhecida e a
adaptação ao JME não é complicada, logo surgiram diversos tipos de aplicativos para tais
dispositivos, como jogos e agendas eletrônicas. As empresas saíram ganhando com isso porque,
desde que seus dispositivos tenham uma JVM (Java Virtual Machine - Máquina Virtual Java), é
possível, com poucas modificações, implementar os aplicativos em qualquer aparelho, sendo o
único limite a capacidade do hardware.
A plataforma JME contém configurações e bibliotecas trabalhadas especialmente para a atuação
em dispositivos portáteis. Assim, o desenvolvedor tem maior facilidade para lidar com as
limitações de processamento e memória, por exemplo. Um exemplo disso é a configuração
chamada CLDC (Connected Limited Device Configuration), destinada a dispositivos com
recursos de hardware bastante limitados, como processadores de 16 bits e memórias com 512 KB
de capacidade. Essa configuração contém uma JVM e um conjunto básico de bibliotecas que
permite o funcionamento da aplicação Java em dispositivos com tais características.
A imagem a seguir mostra um jogo em Java que roda em dois dispositivos móveis diferentes
(tirada do site http://www.msmobile.com/):
8
Finalizando
A tecnologia Java é bastante abrangente e permite o desenvolvimento de soluções para uma
infinidade de aplicações. São tantos recursos, que até mesmo desenvolvedores experientes
podem se confundir em um determinado momento. Felizmente, a comunidade Java é organizada
e não é difícil encontrar auxílio em sites ou fóruns especializados. Caso queira mais informações
sobre Java, visite o site oficial: java.sun.com.
Programação Orientada a Objetos
A programação orientada a objeto não é somente uma nova forma de programar é uma nova
forma de pensar um problema, de forma abstrata, utilizando conceitos do mundo real e não
conceitos computacionais. Os conceitos de objetos devem acompanhar todo o ciclo de
desenvolvimento de um software.
A programação orientada a objeto também inclui uma nova notação e exige por parte do
analista/programador o conhecimento desta notação (diagramas).
Conceitos fundamentais em POO
Classe
Objeto
Atributos
Métodos
Sobrecarga
Herança Simples
Herança múltipla
Encapsulamento
Polimorfismo
Classe
Para a Programação Orientada a Objetos (POO), uma classe é um conjunto de códigos de
programação, que incluem a definição dos atributos e dos métodos necessários para a criação de
um ou mais objetos.
A classe contém toda a descrição da forma do objeto, é um molde para criação de objetos, é uma
matriz geradora de objetos, é uma fábrica de objetos.
Uma classe é a unidade de encapsulamento dos atributos e dos métodos.
Dentro da classe é que declaramos os atributos, os métodos e seus controles de acesso. Vamos
ver o protótipo para declarar e definir uma classe.
Definição de classes em Java
A forma geral da declaração de uma classe é a seguinte:
9
[modificadores] class [nome classe] extends [nome super]
public class Funcionario extends Pessoa{ String nome;
int idade;
float altura;
Funcionario(){} // Construtor de classe
public static void digita(){} // Metodo para a digitacao
public static void imprime(){} // Metodo para imprimir da tela
}
Modificadores
Os modificadores de uma classe determinam como uma classe será manipulada mais tarde no
decorrer do desenvolvimento do programa.
Public;
Private;
Protected;
Static;
Abstract;
Final.
public
A instrução public indica que a classe, método ou variável assim declarada possa ser acessada
em qualquer lugar e a qualquer momento da execução do programa.
Private
O modificador de acesso "private" quando aplicado a um atributo ou a um método indica que os
mesmos só podem ser acessados de dentro da classe que os criou (encapsulamento). Uma classe
que herde de uma superclasse com atributos declarados como "private" só poderá ter acesso a
eles através dos métodos públicos da própria superclasse, caso contrário, não haverá acesso a
estes atributos.
O modificador de acesso private deixa o atributo visível apenas para a classe em que o mesmo se
encontra.
Protected
Deixa o atributo visível para todas as outras classes e subclasses que pertencem ao mesmo
pacote. Neste caso apenas as classes do mesmo pacote tem acesso ao membro, enquanto nem
mesmo pacotes de suas subclasses tem acesso.
Static
Quando usar o modificador static ?
Não pensem que a palavra-chave static define que uma variável não possa mudar de valor. O uso
da palavra-chave static é confundido por muitos programadores, até por alguns mais experientes.
Quando uma variável ou método é declarado static, estes são carregados na memória pela JVM.
10
Para acessar um método static você só pode fazê-lo de duas maneiras, ou acessa de dentro de
outro método static ou cria uma instância (sem ser static) e a partir daí pode fazer o que quiser e
de dentro de um método não static você pode acessar tanto um método static como um não static
de forma direta.
No java, quando uma classe é usada (seja por instância ou diretamente nos membros estáticos),
suas váriaveis e seus métodos estáticos ganham um lugar na mémoria RAM do computador
enquanto o programa é executado. Mas, este lugar (ou endereço) é usado pela classe, ou seja,
todas as instâncias dessa classe, quando utilizam esta variável, estão na verdade utilizando a
variável da classe, e não do objeto. Assim, todas as instâncias dessa classe terão o mesmo valor
para aquela variável estática. Vejamos isso no código!
Exemplo
public class TestaStatic {
public static int minhaVariavelStatic;
public static void main(String args[]){
TestaStatic.minhaVariavelStatic = 3;
TestaStatic a = new TestaStatic();
TestaStatic b = new TestaStatic();
TestaStatic c = new TestaStatic();
System.out.println("Valor minha variavel: " + minhaVariavelStatic);
a.minhaVariavelStatic = 5;
System.out.println("Valor objeto a: " + a.minhaVariavelStatic);
System.out.println("Valor objeto b: " + b.minhaVariavelStatic);
System.out.println("Valor objeto c: " + c.minhaVariavelStatic);
}
}
Quando executarmos, vemos a saída:
Valor minha variavel: 3
Valor objeto a: 5
Valor objeto b: 5
Valor objeto c: 5
CONSTRUÍDO COM SUCESSO (tempo total: 2 segundos)
Podemos acessar minhaVariavelStatic diretamente pela classe, sem precisar instanciar um novo
objeto para seu uso.
Neste momento a JVM carrega todos os métodos e variáveis estáticos, da classe TestaStatic na
memória. Isto acontece agora, porque é a primeira utilização da classe pelo programa. (A JVM
só utiliza memória, quando realmente é necessário.)
Instânciamos três objetos a partir da classe TestaStatic.
imprimimos o valor da variável a partir do objeto a mudamos o valor da variável para 5 a partir
do objeto a imprimimos o valor da varial a partir do objeto b e c.
11
A saída foi 3 e depois 5 depois 5 Como pode isto a partir de objetos diferentes?
Atribuimos o valor 3 para a variável minhaVariavelStatic diretamente na classe TestaStatic, e
quando imprimos pelo objeto a a invés da saída ser 0(zero), foi 3. E quando mudamos o valor da
variável estática a partir do objeto a para 5, podemos perceber que essa mudança esta presente
também no objeto b e c, porque quando imprimos a saída foi 5, 5 e 5. Isto acontece porque
variáveis estáticas possuem somente um único valor para todas as instâncias de sua classe. A
variável estática pertence a Classe e não a instância(ou objeto). Ao contrário de membros não-
estáticos que só podem ser acessados a partir de uma instância. Pois seus valores são individuais
para cada objeto.
Vantagem no uso desse modificador static
É alguns programadores não tem essa percepção. Mas é muito útil quando se necessita
compartilhar uma informação entre todos os objetos de determinada classe, como alguma
contagem ou totalização, até mesmo o ponteiro de uma conexão com um banco de dados.
Outra utilidade para static é pode utilizar as coisas de forma direta sem precisar criar instâncias.
Uma classe ou método static não tem o seu conteúdo “zerado” toda vez que é criada uma nova
instância.
Por isto que o método executável do java, o método main, é estático:
public static void main(String args[]){}
A JVM não poderia saber por onde comerça a execução do programa sem um método que possa
ser acessado diretamente, sem precisar de uma instância. Já pensou se a JVM tivesse que
instanciar classe a classe até achar o método main, iria ficar muito lento, além do uso da
mémoria. E se eu tiver dois métodos public e static? A JVM entende que o método main (escrito
e minusculas) é o método de inicialização do programa, assim você pode ter outros métodos
estáticos em suas classes, sem nenhum problema. Isto é padrão da JVM.
Existem também os blocos de código static que são executados assim que a classe que o
contenha é usada, antes mesmo do método main, se a classe o tiver.
package Programas;
public class Inicio {
static {
System.out.println("Executou o bloco estático!");
}
public static void main(String[] args) {
System.out.println("Executou o método main");
}
}
A execução dessa classe gerará a saída:
Executou o bloco estático!
Executou o método main
12
Quando a JVM procura logo os atributos, métodos e blocos de códigos estáticos antes mesmo da
main ser executada. Porque já pensou se o método main for usar um membro estático que não
estiver carregado na memória? Seria um erro.
Para que servem esses blocos de código static?
Os blocos de códigos estáticos são como um construtor de uma classe, servem quando se precisa
inicializar, tratar ou pesquisar os valores de variaveis estáticas, as únicas que podem ser
acessadas neste instante, antes mesmo do método main ou o método construtor possa ser
executado. É praticamente um método construtor sem nome, sem argumentos (parâmetros) e
nenhum tipo de retorno. Ele é sem nome porque não há necessidade de se referir a ele. Serve
somente para trabalhar com os membros estáticos da classe antes de seu construtor ou do método
main (caso seja a classe executável).
package Programas;
public class Inicio {
public static String data;
static {
data = "10/08/2008";
}
public static void main(String[] args) {
System.out.println("A data que escrevi este artigo era " + data);
}
}
Deste modo, usando os blocos de código estáticos, podemos tratar as variáveis estáticas antes de
qualquer coisa.
Abstract
Classes abstratas são aquelas que contém ao menos um método incompleto. Desse modo uma
classe abstrata não pode ser instanciada, mas pode ser derivada. Neste caso, a subclasse deve
prover o corpo do método para que possa ser instanciada. Isto é muito útil quando desejamos
definir em uma classe regras gerais para o comportamento de uma parte do programa, para que,
mais tarde, as regras mais específicas sejam introduzidas por subclasses.
Final
Uma classe final pode ser instanciada, mas não pode ser derivada, isto é, não pode ser
superclasse de nenhuma subclasse. Algumas classes predefinidas no ambiente Java têm esta
propriedade.
A palavra reservada final impede que o método seja sobreposto em uma subclasse isso é, ele
pode ser herdado porém não pode ser sobrescrito. O que podemos dizer é que quando criamos
um método uma classe ou até mesmo variáveis do tipo final não podemos sobrescrevê-las. O
método serve para que quando uma subclasse a chame da mesma maneira que foi criada, sem
que haja mudanças em seu comportamento. Já quando isso acontece com uma classe ela não
pode ser herdada, isso quer dizer que eu não posso usá-la como uma subclasse, ele já é a classe
final e está no seu auge do perfeccionismo. Já uma variável ela não pode mudar seu valor quando
recebe seu valor inicial, por exemplo, final int a = 5; até o final do programa ou da execução do
seu bloco a variável a sempre será 5, é importante saber que seu valor não muda.
13
Friendly
Se nenhum modificador de classe for especificado, então a classe será considerada friendly.
Apenas os objetos integrantes do mesmo package podem utilizar uma classe friendly.
Convenção para nomes de objetos
Identificadores são seqüências de caracteres Unicode, que devem obedecer às seguintes regras:
Embora não seja obrigatório, o conhecimento e uso da seguinte convenção padrão para atribuir
nomes em Java pode facilitar bastante a manutenção de um programa:
Nomes de classes são iniciados por letras maiúsculas.
Nomes de métodos, atributos e variáveis são iniciados por letras minúsculas.
Em nomes compostos, cada palavra do nome é iniciada por letra maiúscula -- as palavras
não são separadas por nenhum símbolo.
Um nome pode ser composto por letras, por dígitos e pelos símbolos _ e $.
Um nome não pode ser iniciado por um dígito (0 a 9).
Letras maiúsculas são diferenciadas de letras minúsculas.
Uma palavra-chave da linguagem Java não pode ser um identificador.
Tipo de objeto Formato do nome
Variáveis nomeVariavel
Constantes NOME_CONSTANTE
Nome de classes NomeClasse
Nome de métodos/funções nomeMetodo()
Atributos nomeAtributo
Atributos estáticos nomeAtributo
Nome de classes derivadas Deve lembrar a classe base
Regras para a escolha de nomes de variáveis e constantes em Java
Cada linguagem de programação tem seu conjunto próprio de regras e convenções para os tipos
de nomes que você pode usar, e Java não é diferente. As regras e convenções para nomear
variáveis em Java são as seguintes:
Nomes de variáveis são sensitivos a minúsculas e maiúsculas. Isso quer dizer que
"cliente" é diferente de "Cliente". O nome de uma variável pode ser qualquer
identificador legal: Uma sequencia sem limites de tamanho de letras Unicode e dígitos,
começando com uma letra, "$" ou o caractere de sublinhado "_" (underscore). A
convenção, contudo, é sempre começar um nome de variável com uma letra e não "$" ou
"_". Além disso, por convenção, o caractere $ nunca é usado. Você pode encontrar
situações em que nomes gerados automaticamente podem conter o sinal $, mas evite usá-
lo sempre que possível. O mesmo acontece com "_". Embora permitido, evite começar
nomes de variáveis com "_". Espaços não são permitidos em nomes de variáveis.
Caracteres subsequentes podem ser letras, dígitos, $ ou "_". Convenções (e senso
comum) se aplicam a esta regra também. Quando escolher nomes para suas variáveis, use
nomes completos em vez de abreviações confusas. Isso tornará seu código mais legível.
Nomes tais como "cliente", "nota", "quantidade", etc, são bem mais fáceis de entender e
14
lembrar que "cl", "n", "qt", etc. Tenha também em mente que palavras-chaves e palavras
reservadas da linguagem não podem ser usadas como nomes de variáveis.
Se o nome de variável que você escolher consistir de apenas um palavra, escreva-a toda
em letras minúsculas. Ex.: cliente. Se consistir de mais de uma palavra, escreva a
primeira letra da segunda palavra usando letra maiúscula. Ex.: nomeCliente. Se o nome
for de uma constante, ele deve ser escrito todo em letras maiúsculas. Ex.: MODELO =
102. Se o nome da constante possuir mais de uma palavra, separe-as com o caractere "_".
Ex.: NIVEL_BOLETO = 2.
Lembre-se: as letras maiúsculas e as minúsculas são consideradas diferentes.
Detalhes sobre as convenções de codificação sugeridas pelos projetistas da linguagem Java
podem ser encontrados no documento Code Conventions for the JavaTM
Programming
Language.
Super Classes
Um dos aspectos mais importantes da OOP é a capacidade de usar campos e métodos de uma
classe previamente construída. Por meio da extensão de classes simples podemos construir
classes maiores, acrescentando àquelas mais campos e métodos, obtendo com isto mais
funcionalidades. Neste processo, há uma grande economia no esforço de codificação. Sem esse
recurso, freqüentemente seria necessário recodificar grande parte dos programas para
acrescentar-lhes funcionalidade ou fazer modificações significativas.
Ao derivar uma classe, estamos primeiramente fazendo uma cópia da classe parente. É
exatamente isto que obtemos se deixarmos vazio o corpo da subclasse. Tal classe se comportaria
exatamente como sua superclasse. Entretanto, podemos acrescentar novos campos e métodos à
subclasse, além de sobrepor métodos existentes na superclasse, declarando-os exatamente como
na superclasse, exceto por dar um corpo diferente.
As classes são definidas através do uso da palavra-chave class. Para definir uma classe, utiliza-
se a construção:
[modif] class NomeDaClasse {
// corpo da classe...
}
A primeira linha é um comando que inicia a declaração da classe. Após a palavra-chave class,
segue-se o nome da classe, que deve ser um identificador válido para a linguagem. O
modificador modif é opcional; se presente, pode ser uma combinação de public e abstract ou
final.
Definindo a Classe
A definição da classe propriamente dita está entre as chaves { e }, que delimitam blocos na
linguagem Java. Este corpo da classe usualmente obedece à seguinte seqüência de definição:
1. As variáveis de classe, iniciando pelas public, seguidos pelas protected, pelas com
visibilidade padrão (sem modificador) e finalmente pelas private.
15
2. Os atributos (ou variáveis de instância) dos objetos dessa classe, seguindo a mesma
ordenação definida para as variáveis de classe.
3. Os construtores de objetos dessa classe.
4. Os métodos da classe, geralmente agrupados por funcionalidade.
Toda classe pode também ter um método main associado, que será utilizado pelo interpretador
Java para dar início à execução de uma aplicação.
Java também oferece outra estrutura, denominada interface, com sintaxe similar à de classes
mas contendo apenas a especificação da funcionalidade que uma classe deve conter, sem
determinar como essa funcionalidade deve ser implementada.
Propriedades de uma classe (meta-informação) podem ser obtidas através das funcionalidades
oferecidas na classe java.lang.Class.
Variáveis da classe
Cada objeto definido a partir de uma classe terá sua cópia separada dos atributos definidos para a
classe. No entanto, há situações em que é interessante que todos os objetos compartilhem a
mesma variável, similarmente ao que ocorre com variáveis globais em linguagens de
programação tradicional. O mecanismo para realizar esse compartilhamento é a definição de
variáveis da classe.
Uma variável de classe tem sua declaração precedida pela palavra-chave static.
Várias constantes são definidas em Java como public static final. Por exemplo, a classe Math de
Java define as constantes E (2.71828...) e PI (3.14159...). Para ter acesso a esses valores, basta
precedê-los com o nome da classe e um ponto, como em
double pi2 = Math.PI/2;
Outro exemplo de variável public static final é a variável out da classe System. Essa variável,
System.out, está associada a um objeto que representa a saída padrão (o monitor, tipicamente),
sendo utilizada sempre que se deseja enviar um valor para essa saída.
Construtores
Um construtor é um (pseudo-)método especial, definido para cada classe. O corpo desse método
determina as atividades associadas à inicialização de cada objeto criado. Assim, o construtor é
apenas invocado no momento da criação do objeto através do operador new.
A assinatura de um construtor diferencia-se das assinaturas dos outros métodos por não ter
nenhum tipo de retorno (nem mesmo void). Além disto, o nome do construtor deve ser o próprio
nome da classe.
O construtor pode receber argumentos, como qualquer método. Usando o mecanismo de
sobrecarga, mais de um construtor pode ser definido para uma classe.
Toda classe tem pelo menos um construtor sempre definido. Se nenhum construtor for
explicitamente definido pelo programador da classe, um construtor default, que não recebe
argumentos, é criado pelo compilador Java. No entanto, se o programador da classe criar pelo
menos um método construtor, o construtor default não será criado automaticamente -- se ele o
desejar, deverá criar um construtor sem argumentos explicitamente.
16
No momento em que um construtor é invocado, a seguinte seqüência de ações é executada para a
criação de um objeto:
1. O espaço para o objeto é alocado e seu conteúdo é inicializado (bitwise) com zeros.
2. O construtor da classe base é invocado.
3. Os membros da classe são inicializados para o objeto, seguindo a ordem em que foram
declarados na classe.
4. O restante do corpo do construtor é executado.
Seguir essa seqüência é uma necessidade de forma a garantir que, quando o corpo de um
construtor esteja sendo executado, o objeto já terá à disposição as funcionalidades mínimas
necessárias, quais sejam aquelas definidas por seus ancestrais. O primeiro passo garante que
nenhum campo do objeto terá um valor arbitrário, que possa tornar erros de não inicialização
difíceis de detectar.
Classes em UML
Em UML (Unified Modeling Language), a representação para uma classe no diagrama de classes
é expressa graficamente como:
Os atributos são membros da classe que descrevem suas propriedades. Para cada atributo
especifica-se o nome, tipo (primitivo ou outra classe), uma especificação de visibilidade e,
opcionalmente, um valor inicial. A especificação de visibilidade pode ser, se definida, privativa
(-, nenhuma visibilidade externa), pública (+, visibilidade externa total) ou protegido (#,
visibilidade externa limitada a objetos de classes derivadas).
Os métodos são membros da classe que descrevem suas funcionalidades, ou seja, o que pode ser
feito com um objeto da classe. Para cada método, especifica-se o nome, o tipo de retorno (void
se não houver nenhum), a lista de argumentos (o tipo e opcionalmente um identificador para
cada parâmetro) e visibilidade (como para atributos, define o quão acessível é um método a
partir de objetos de outros classes).
Atributos
A todo objeto podemos relacionar alguns atributos (propriedades). No exemplo de um relógio a
hora, a data. Na programação orientada a objeto, os atributos são definidos na classe e
armazenados de forma individual ou coletiva pelos objetos.
Podemos relacionar alguns atributos (propriedades) a todo objeto. No exemplo do relógio, a hora e a
data. Na programação orientada a objeto, os atributos são definidos na classe e armazenados de
forma individual ou coletiva pelos objetos.
17
A definição de atributos de uma classe Java reflete de forma quase direta a informação que
estaria contida na representação da classe em um diagrama UML. Para tanto, a sintaxe utilizada
para definir um atributo de um objeto é:
[modificador] tipo nome [ = default];
onde
o modificador (opcional) é uma combinação de
o public, protected ou private;
o final; e
o static.
o tipo deve ser um dos tipos primitivos da linguagem Java ou o nome de uma classe ou
interface;
nome deve ser um identificador válido;
default (opcional) é a especificação de um valor inicial para a variável.
Métodos
A todo objeto podemos relacionar determinados comportamentos, ações e reações. As ações ou
comportamento dos objetos são chamados na análise orientada a objeto de métodos (AOO),
assim, um método é uma função, um serviço fornecido pelo objeto.
Os comportamentos dos objetos são definidos na classe através dos métodos e servem para
manipular e alterar os atributos do objeto (alteram o estado do objeto).
Em Java, a definição de um método em uma classe é expressa dentro do corpo da classe como
um bloco na forma:
[modificador] tipo nome(argumentos) {
corpo do método}
onde o nome (um identificador válido) e o tipo dos argumentos constituem a assinatura do
método. O tipo é um indicador do tipo de retorno do método, que pode ser um dos tipos
primitivos da linguagem, um tipo de objeto (nome de classe ou interface), ou void se não houver
nenhum valor de retorno.
O modificador (opcional) é uma combinação de um especificador de visbilidade (public,
protected ou private), de um especificador de redefinição (abstract ou final) e de um
especificador de escopo (static).
Métodos são essencialmente procedimentos que podem manipular atributos de objetos para os
quais o método foi definido. Além dos atributos de objetos, métodos podem definir e manipular
variáveis locais; também podem receber parâmetros por valor através da lista de argumentos.
Uma boa prática de programação é manter a funcionalidade de um método simples,
desempenhando uma única tarefa. O nome do método deve refletir de modo adequado a tarefa
realizada. Se a funcionalidade do método for simples, será fácil encontrar um nome adequado
para o método.
Como ocorre para a definição de atributos, a definição de métodos reflete de forma quase direta a
informação que estaria presente em um diagrama de classes UML, a não ser por uma diferença
vital: o corpo do método.
18
Métodos de mesmo nome podem co-existir em uma mesma classe desde que a lista de
argumentos seja distinta, usando o mecanismo de sobrecarga.
Mensagens
Um objeto tem determinados atributos (propriedades) e métodos (ações), e que o objeto reage ao
meio que o envolve de acordo com as excitações que sofre.
Em um programa orientado a objeto as excitações são representadas por mensagens que são
enviadas a um objeto. Uma mensagem pode ser gerada pelo usuário, por exemplo, ao clicar o
mouse.
Objeto (ou Instância)
A Análise Orientada a Objeto (AOO) tem uma série de conceitos que auxiliam as pessoas a
delinear claramente o problema e a identificar os objetos e seus relacionamentos.
Objetos são coisas do mundo real ou imaginário, que podemos de alguma forma identificar,
como uma pedra, uma caneta, um copo, uma fada. Um objeto tem determinadas propriedades
que o caracterizam, e que são armazenadas no próprio objeto. As propriedades de um objeto são
chamadas ainda de atributos.
O objeto interage com o meio e em função de excitações que sofre, realiza determinadas ações
que alteram o seu estado (seus atributos). Os atributos de um objeto não são estáticos, eles
sofrem alterações com o tempo.
Para a POO, um objeto é uma entidade única que reúne atributos e métodos, ou seja, reúne as
propriedades do objeto e as reações às excitações que sofre.
Uma variável do tipo classe é chamada de objeto.
A instância de uma classe é chamada de objeto.
Tipos Básicos
Observe a tabela a seguir, sobre os tipos de dados. Esses tipos são conhecidos como Tipos de
Dados Primitivos. Como podemos observar a linguagem Java oferece diversos tipos de dados
com os quais podemos trabalhar. Há basicamente duas categorias em que se encaixam os tipos
de dados: tipos primitivos e tipos de referências. Os tipos primitivos correspondem a dados mais
simples ou escalares, enquanto os tipos de referências consistem em arrays, classes e interfaces.
Estes serão vistos nos módulos subseqüentes.
Vamos a uma descrição curta sobre cada um dos tipos:
Tipo Descrição
boolean
Pode ser contido em 1 bit, porém o seu tamanho não é precisamente definido.
Assume os valores true ou false.
char
Caractere em notação Unicode de 16 bits. Serve para armazenar dados
alfanuméricos. Também pode ser usado como um dado inteiro com valores na
faixa entre 0 e 65535.
19
byte
Inteiro de 8 bits em notação de complemento de dois. Pode assumir valores
entre -27=-128 e 27-1=127.
short Inteiro de 16 bits em notação de complemento de dois. Os valores possíveis
cobrem a faixa de -2-15=-32.768 a 215-1=32.767
int
Inteiro de 32 bits em notação de complemento de dois. Pode assumir valores entre
231=2.147.483.648 e 231-1=2.147.483.647.
long
Inteiro de 64 bits em notação de complemento de dois. Pode assumir valores entre
-263 e 263-1.
float
Representa números em notação de ponto flutuante normalizada em precisão
simples de 32 bits em conformidade com a norma IEEE 754-1985.
O menor valor positivo representável por esse tipo é 1.40239846e-46 e o maior é
3.40282347e+38. 4 bytes de tamanho e 23 dígitos binários deprecisão.
double
Representa números em notação de ponto flutuante normalizada em precisão
dupla de 64 bits em conformidade com a norma IEEE 754-1985. O menor valor
positivo representável é 4.94065645841246544e-324 e o maior é
1.7976931348623157e+308. 8 bytes de tamanho e 52 dígitos binários de
precisão.
20
Controle de Fluxo – Estruturas de Seleção e Repetição
Comando de Seleção em Java
Introdução
Um comando de seleção define uma condição em um programa, que permite que grupos de
comandos sejam executados de maneira condicional, de acordo com o resultado da avaliação de
um determinado teste (verdadeiro ou falso). Ou seja, programas utilizam comandos de seleção
para escolher entre cursos alternativos de ações. A sintaxe do comando de seleção em Java é:
A sintaxe do if no Java é a seguinte:
if (condicaoBooleana) {
codigo;
}
Uma condição booleana é qualquer expressão que retorne true ou false. Para isso, você pode
usar os operadores <, >, <=, >= e outros. Um exemplo:
int idade = 15;
if (idade < 18) {
System.out.println("Não pode entrar");
}
Além disso, você pode usar a cláusula else para indicar o comportamento que deve ser executado
no caso da expressão booleana ser falsa:
int idade = 15;
if (idade < 18) {
System.out.println("Não pode entrar");
}
else {
System.out.println("Pode entrar");
}
Você pode concatenar expressões booleanas através dos operadores lógicos “E” e “OU”. O “E”
é representado pelo && e o “OU” é representado pelo ||.
Um exemplo seria verificar se ele tem menos de 18 anos e se ele não é amigo do dono:
int idade = 15;
boolean amigoDoDono = true;
if (idade < 18 && amigoDoDono == false) {
System.out.println("Não pode entrar");
}
else {
System.out.println("Pode entrar");
}
Esse código poderia ficar ainda mais legível, utilizando-se o operador de negação, o !. Esse
operador transforma o resultado de uma expressão booleana de false para true e vice versa.
21
int idade = 15;
boolean amigoDoDono = true;
if (idade < 18 && !amigoDoDono) {
System.out.println("Não pode entrar");
}
else {
System.out.println("Pode entrar");
}
Repare na linha 3 que o trecho amigoDoDono == false virou !amigoDoDono. Eles têm o mesmo
valor.
Para comparar se uma variável tem o mesmo valor que outra variável ou valor, utilizamos o
operador ==.
Repare que utilizar o operador = dentro de um if vai retornar um erro de compilação, já que o
operador = é o de atribuição.
int mes = 1;
if (mes == 1) {
System.out.println("Você deveria estar de férias");
}
Estruturas de Repetição
While
O while é um comando usado para fazer um laço (loop), isto é, repetir um trecho de código
algumas vezes.
A idéia é que esse trecho de código seja repetido enquanto uma determinada condição
permanecer verdadeira.
int idade = 15;
while (idade < 18) {
System.out.println(idade);
idade = idade + 1;
}
O trecho dentro do bloco do while será executado até o momento em que a condição idade < 18
passe a ser falsa. E isso ocorrerá exatamente no momento em que idade == 18, o que não o fará
imprimir 18.
int i = 0;
while (i < 10) {
System.out.println(i);
i = i + 1;
}
Já o while acima imprime de 0 a 9.
22
Do while
O comando do while é uma estrutura de repetição, tal como o próprio while. A principal
diferença entre os dois é que do while irá fazer a comparação apenas no final do bloco de código,
sendo representado da seguinte forma:
do{
código
} while (comparação);
Neste caso, devemos ter as mesmas precauções quanto while, no que diz respeito a looping
infinito. Mas não é necessário inicializar a variável antes do bloco de código como acontece com
while, pois a comparação só será feita após todo o código ter sido executado.
For
Outro comando de loop extremamente utilizado é o for. A idéia é a mesma do while: fazer um
trecho de código ser repetido enquanto uma condição continuar verdadeira. Mas além disso, o
for isola também um espaço para inicialização de variáveis e o modificador dessas variáveis. Isso
faz com que fiquem mais legíveis, as variáveis que são relacionadas ao loop:
for (inicializacao; condicao; incremento) {
codigo;
}
Um exemplo é o a seguir:
for (int i = 0; i < 10; i = i + 1) {
System.out.println("olá!");
}
Repare que esse for poderia ser trocado por:
int i = 0;
while (i < 10) {
System.out.println("olá!");
i = i + 1;
}
Porém, o código do for indica claramente que a variável i serve, em especial, para controlar a
quantidade de laços executados. Quando usar o for? Quando usar o while? Depende do gosto e
da ocasião.
Pós incremento ++
i = i + 1 pode realmente ser substituído por i++ quando isolado, porém, em alguns casos,
temos essa instrução envolvida em, por exemplo, uma atribuição:
int i = 5;
int x = i++;
Qual é o valor de x? O de i, após essa linha, é 6.
O operador ++, quando vem após a variável, retorna o valor antigo, e incrementa (pós
incremento), fazendo x valer 5.
23
Se você tivesse usado o ++ antes da variável (pré incremento), o resultado seria 6:
int i = 5;
int x = ++i; // aqui x valera 6
Entrada de Dados (Scanner)
A leitura de dados de entrada em aplicativos através da janela de comando do sistema
operacional era surpreendentemente complexa até a versão 1.4.2 do J2SE. Isto não era problema
para aplicativos com recursos GUI - Graphical User Interface (Interface Gráfica com o Usuário),
mas tornava-se desconfortável para estudantes interessados em escrever programas simples com
o propósito de aprender Java.
J2SE 5.0 introduz a classe java.util.Scanner para a entrada de dados, inclusive através da entrada
padrão, System.in.
O exemplo a seguir apresenta uma aplicação Java para a entrada de dois números pelo teclado e
a saída da soma na janela de comando do sistema operacional.
É necessário criar uma instância da classe Scanner, passando como argumento o objeto padrão
de entrada, System.in, que irá capturar as entradas de dados via o teclado. O método nextInt(), da
instância da classe Scanner, lê o valor digitado e o armazena em uma variável do tipo int.
package programas;
import java.util.Scanner;
public class Teste {
public static void main(String[] args) {
String nome;
int num1;
float num2;
double num3;
Scanner entrada = new Scanner(System.in);
System.out.print("Entre com um nome .........: ");
nome = entrada.nextLine();
System.out.print("Entre com um inteiro número: ");
num1 = entrada.nextInt();
System.out.print("Entre com o primeiro valor : ");
num2 = entrada.nextFloat();
System.out.print("Entre com o segundo valor : ");
num3 = entrada.nextDouble();
System.out.printf("Nome digitado .: " + nome);
System.out.printf("\nNumero digitado: " + num1);
System.out.printf("\nValor digitado : " + num2);
System.out.printf("\nValor digitado : " + num3);
System.out.printf("\n");
}
}
24
A classe Scanner possui diversos métodos que podem ser utilizados para realizar este serviço.
Os principais métodos que podemos utilizar, neste caso, são:
Método Finalidade
next() Aguarda uma entrada em formato String
nextInt() Aguarda uma entrada em formato Inteiro
nextByte() Aguarda uma entrada em formato Inteiro
nextLong() Aguarda uma entrada em formato Inteiro Longo
nextFloat() Aguarda uma entrada em formato Número Fracionário
nextDouble() Aguarda uma entrada em formato Número Fracionário
Tabela 1: Métodos da Classe Scanner para obter dados
Encapsulamento
Poderiamos dizer que encapsular significa, na orientação à objetos, separar um programa em
partes isolando-as o máximo possível, protegendo o acesso direto aos atributos de uma classe
com o objetivo de deixar o programa mais flexível e facilitar o trabalho no código.
Para isso se faz necessário o uso de modificadores de acesso mais restritivos nos atributos da
classe. Esses atributos são manipulados indiretamente com o uso de métodos específicos. O
padrão usado para a manipulação desses atributos são os métodos set (que define o valor do
atributo) e get (que retorna o valor do atributo).
Encapsulamento vem de encapsular, que em programação orientada a objetos significa separar o
programa em partes, o mais isoladas possível. A idéia é tornar o software mais flexível, fácil de
modificar e de criar novas implementações.
Para exemplificar, podemos pensar em uma dona de casa (usuário) utilizando um liquidificador
(sistema). O usuário não necessita conhecer detalhes do funcionamento interno do sistema para
poder utilizá-lo, precisa apenas conhecer a interface, no caso, os botões que controlam o
liquidificador. Outro exemplo clássico de encapsulamento é o padrão de projeto chamado
Mediator.
Uma grande vantagem do encapsulamento é que toda parte encapsulada pode ser modificada sem
que os usuários da classe em questão sejam afetados. No exemplo do liquidificador, um técnico
poderia substituir o motor do equipamento por um outro totalmente diferente, sem que a dona de
casa seja afetada - afinal, ela continuará somente tendo que pressionar o botão.
O encapsulamento protege o acesso direto (referência) aos atributos de uma instância fora da
classe onde estes foram declarados. Esta proteção consiste em se usar modificadores de acesso
mais restritivos sobre os atributos definidos na classe. Depois devem ser criados métodos para
manipular de forma indireta os atributos da classe.
Encapsular atributos também auxilia a garantir que o estado e o comportamento de um objeto se
mantenha coeso. Por exemplo, no caso da classe Semaforo poderiamos ter um método de acesso
chamado lerCor(), e um modificador chamado proximaCor(). O estado é mantido pois os
usuários da classe não podem alterar as cores de um semáforo ao seu bel prazer e, por exemplo,
fazer a seguinte troca de cores: vermelho-amarelo-vermelho. É comum usar o padrão
get<nomeDoAtributo> para o método que retorna o valor atual do atributo e
25
set<nomeDoAtributo> para o método que modifica o valor de um atributo do objeto, como no
exemplo abaixo: setComProtecao e getComProtecao.
Exemplo sem encapsulamento
class NaoEncapsulado {
int semProtecao; // implicitamente public
}
public class TesteNaoEncapsulado {
public static void main(String[] args) {
NaoEncapsulado ne = new NaoEncapsulado();
ne.semProtecao = 10; // acesso direto ao atributo
System.out.println("Valor sem proteção: " + ne.semProtecao);
}
}
Com encapsulamento
class Encapsulado {
private int comProtecao;
public void setComProtecao(int valor) {
comProtecao = valor;
}
public int getComProtecao() {
return comProtecao;
}
}
public class TesteEncapsulado {
public static void main(String[] args) {
Encapsulado e = new Encapsulado();
e.setComProtecao(10);
System.out.println("Valor com proteção: " + e.getComProtecao());
}
}
Vejamos como ficaria a classe pessoa com encapsulamento.
Pessoa.java
public class Pessoa{
private String nome;
private String sobrenome;
private String dataNasc;
private String rg;
private String[] telefones;
public Pessoa(){
}
26
public String getNome(){
return nome;
}
public void setNome(String n){
nome = n;
}
public String getSobrenome(){
return sobrenome;
}
public void setSobrenome(String s){
sobrenome = s;
}
public String getDataNasc(){
return dataNasc;
}
public void setDataNasc(String d){
dataNasc = d;
}
public String getRg(){
return rg;
}
public void setRg(String r){
r = rg;
}
public String getTelefones(){
return telefones;
}
public void setTelefones(String[] telefones){
telefones[] = telefones;
}
}
Métodos Get e Set
Como visto anteriormente, o encapsulamento "protege" os atributos ou métodos dentro de uma
classe, portanto devemos prover meios para acessar tais membros quando eles são particulares,
ou seja, quando possuem o modificador private.
O que torna isso possível é a criação de métodos.
Em programação orientada a objetos, esses métodos são chamados de métodos acessores ou
getters e setters, pois eles provêm acesso aos atributos da classe, e geralmente, se iniciam com
get ou set, daí a origem de seu nome.
Na verdade, não há nada de diferente entre os métodos comuns e os métodos acessores. A única
importância está no fato da orientação a objeto. Pois, sempre que formos acessar um membro em
Java usaremos get ou set.
Set
Nomeamos um método acessor com set toda vez que este método for modificar algum campo ou
atributo de uma classe, ou seja, se não criarmos um método acessor set para algum atributo, isso
quer dizer que este atributo não deve ser modificado.
27
Portanto, como o valor de um atributo da classe será modificado, não é necessário que este
método retorne nenhum valor, por isso, os métodos setters são void. Porém, obrigatoriamente,
eles tem que receber um argumento que será o novo valor do campo.
Get
Nomeamos um método acessor com get toda vez que este método for verificar algum campo ou
atributo de uma classe.
Como este método irá verificar um valor, ele sempre terá um retorno como String, int, float, etc.
Mas não terá nenhum argumento.
Sobrecarga de Métodos
Neste capítulo vamos apresentar a sobrecarga de métodos, o uso de métodos com o mesmo
nome, mas parâmetros diferentes.
O que é a sobrecarga de métodos?
Sobrecarga de métodos se refere ao uso de métodos com mesmo nome, mas com tipos de
parâmetros ou número de parâmetros diferentes. Isto é, o nome do método é o mesmo, mas os
tipos de parâmetros são diferentes. De um modo geral como os métodos sobrecarregados têm o
mesmo nome, eles realizam basicamente a mesma tarefa, a diferença é o número de parâmetros e
ou o tipo dos parâmetros que são recebidos.
Exemplos de sobrecarga
O exemplo a seguir declara métodos com o mesmo nome, métodos sobrecarregados.
Exemplo:
public void metodoA(int x, int y); // 1-int,int
public void metodoA(float x, float y); // 2-float,float
public void metodoA(int x, float y); // 3-int,float
O compilador reconhece qual método você quer acessar verificando o tipo dos parâmetros e o
número de parâmetros.
Mudar o nome dos parâmetros não é uma sobrecarga, o compilador diferencia o tipo e a
quantidade de parâmetros não o nome e sim pela sua assinatura.
28
Exemplo de Sobrecarga
package programas;
import entity.Numeros;
public class ExemploSobreCarga {
public static void main(String[] args) {
Numeros exemplo = new Numeros();
System.out.print("===== Exemplo de Sobrecarga de Metodo =====");
System.out.print("\n");
System.out.print("Primeiro Metodo: 2 parametro ");
exemplo.imprime(1,2);
System.out.print("\nSegundo Metodo : 3 parametro ");
exemplo.imprime(1,2,3);
System.out.print("\nTerceiro Metodo: 4 parametro ");
exemplo.imprime(1,2,3,4);
}
}
package entity;
public class Numeros {
public int num1;
public int num2;
public int num3;
public int num4;
public Numeros() {}
public void imprime(int a, int b){
num1 = a;
num2 = b;
System.out.print (num1 + " " + num2 );
}
public void imprime(int x, int f, int s){
num1 = x;
num2 = f;
num3 = s;
System.out.print (num1 + " " + num2 + " " + num3 );
}
public void imprime(int m, int n, int o, int p){
num1 = m;
num2 = n;
num3 = o;
num4 = p;
System.out.print (num1 + " " + num2 + " " + num3 + " " + num4 );
}
}
Interfaces
Interface é um recurso da orientação a objeto utilizado em Java que define ações que devem ser
obrigatoriamente executadas, mas que cada classe pode executar de forma diferente.
Interfaces contém valores constantes ou assinaturas de métodos que devem ser implementados
dentro de uma classe.
E por que isso?
Isso se deve ao fato que muitos objetos (classes) podem possuir a mesma ação (método), porém,
podem executá-la de maneira diferente.
29
Usando um exemplo bem drástico, podemos ter uma interface chamada aéreo que possui a
assinatura do método voar(). Ou seja, toda classe que implementar aéreo deve dizer como voar().
Portanto, se eu tenho uma classe chamada pássaro e outra chamada avião, ambas implementando
a interface aéreo, então, nestas duas classes devemos codificar a forma como cada um irá voar().
Uma interface é criada da mesma forma que uma classe, mas utilizando a palavra-
chave interface no lugar declass.
interface nomeDaInterface {
métodoAbstrato (argumentos);
}
Usando uma Interface em uma Classe
Como vimos anteriormente, uma classe pode extender suas funcionalidades obtendo as
características de outra classe num processo que chamamos de herança. Uma interface não
é herdada, mas sim, implementada. Porque todo o código dos métodos da interface deve ser
escrito dentro da classe que o chama. Dessa forma, obtemos as assinaturas dos métodos da
interface em uma classe usando a palavra-chave implements.
A vantagem principal das interfaces é que não há limites de quantas interfaces uma classe pode
implementar. O que ajuda no caso de heranças múltiplas que não é possível ser feito em Java,
pois uma classe apenas pode herdar as características de uma outra classe.
Resumindo
Uma interface em Java é uma espécie de classe, com as seguintes propriedades:
Não pode ser instanciável (não podemos criar objetos com new);
Só pode possuir assinaturas de métodos de instância, públicos e abstratos (sem corpo).
Não pode possuir métodos concretos (com corpo), nem métodos estáticos.
Os prefixos abstract e public podem ser usados, mas são em geral omitidos;
Não pode conter variáveis de instância ou de classe (static);
Pode conter declarações de constantes (com prefixo final e inicializadas para um valor) –
nesse caso essa variável funcionará como uma constante de classe.
O prefixo static possa ser usado, mas é em geral omitido;
Pode ser criada como subinterface de outra interface já existente, usando extends, como
as classes.
Para criar interfaces usamos uma sintaxe parecida com a das classes, substituindo a palavra class
por interface, por exemplo:
Exemplo1:
package entity;
public interface InterfaceQualquer {
public final double PI = 3.1416;
public void calculaArea(double n1);
public void calculaPerimetro(double n2);
}
30
package Exemplos;
import entity.InterfaceQualquer;
import javax.swing.JOptionPane;
public class ExemploInterface implements InterfaceQualquer{
public void calculaArea(double medida) {
JOptionPane.showMessageDialog(null,"Area de um Quadrado: " + medida * medida);
}
public void calculaPerimetro(double medida) {
JOptionPane.showMessageDialog(null,"Perímetro de um Quadrado: " + medida * 4);
}
public static void main(String[] args) {
ExemploInterface ex = new ExemploInterface();
double medida;
medida = (Double.parseDouble(JOptionPane.showInputDialog(null,
"Cálculo com figura geométrica" +
"\nDigite a medida: ")));
ex.calculaArea(medida);
ex.calculaPerimetro(medida);
}
}
Exemplo2:
public interface InterfaceExemplo{
public final String PALAVRA = "UFRJ";
public void metodo1(int x);
public String metodo2 (String s);
}
public interface InterfaceExemplo2 extends InterfaceExemplo {
public void metodo3();
}
Nos exemplos acima, são criadas duas interfaces.
A segunda é uma subinterface da primeira, ou uma extensão dela.
A interface InterfaceExemplo2 contém todos os três métodos, e mais a constante PALAVRA.
Ou seja, ela "herda" as definições da sua superinterface Exemplo (bem como de todas as
superinterfaces acima na hierarquia que existirem).
Ao contrário das classes, não existe uma interface "raiz" de todas as interfaces, como ocorre com
a classe Object.
A interface InterfaceExemplo, vista acima, não herda de nenhuma outra.
Note que a mesma convenção para nome de classe se aplica aos nomes das interfaces: iniciar
com letra maiúscula, seguida de letras minúsculas.
A constante PALAVRA do exemplo acima segue a convenção de nome de constantes em Java,
que é ter todas as letras maiúsculas.
31
O arquivo fonte de uma interface, da mesma forma que no caso de classes, também tem o nome
da interface com a terminação .java.
E o compilador gera da mesma forma um arquivo .class de mesmo nome.
Usando interfaces
Uma Interface funciona de forma análoga a uma classe abstrata.
Ou seja, ela não pode ser instanciada, mas pode ser como que "herdada" por uma classe.
A forma sintática para uma classe herdar de uma interface utiliza a palavra chave implements,
como no exemplo fictício abaixo:
public class ClasseTeste implements InterfaceExemplo {
public void metodo1(int x) {
System.out.println(x);
}
public String metodo2(String s) {
return s + " da " + PALAVRA;
}
// outros métodos e atributos desta classe
}
O sentido de uma classe "herdar" de uma interface é similar ao de herdar métodos abstratos de
uma superclasse abstrata.
A classe fica obrigada a implementar concretamente todos os métodos declarados na interface, e
nas suas super-interfaces, ou a classe não compilará.
Note que a classe pode usar diretamente a constante definida na interface.
Classes podem implementar mais de uma interface
Uma diferença essencial entre classes e interfaces é que uma classe pode implementar diversas
interfaces, embora possa ser subclasse de apenas uma superclasse.
Nesse caso, após a palavra chave implements, escrevemos a lista das interfaces que a classe
implementa, separadas por vírgulas.
Por exemplo, sejam as interfaces InterfaceExemplo1, InterfaceExemplo2,
InterfaceY e uma classe ExemploInterface que implementa as duas últimas interfaces:
package entity;
public interface InterfaceExemplo1{
public final String PALAVRA= "UFRJ";
public void metodo1();
}
32
package entity;
public interface InterfaceExemplo2 extends InterfaceExemplo1 {
public void metodo2();
}
package entity;
public interface InterfaceY {
public void f1();
public void f2();
}
package entity;
import javax.swing.JOptionPane;
public class ExemploInterface implements InterfaceExemplo2, InterfaceY
{
public void metodoDaClasse(){ //Método da classe
JOptionPane.showMessageDialog(null, "Executou o método da classe");
}
public void metodo1(){ //Método da interface1
JOptionPane.showMessageDialog(null, "Executou o método da Interface1");
}
public void metodo2(){ //Método da interface2
JOptionPane.showMessageDialog(null, "Executou o método da Interface2");
}
public void f1(){ //Método1 da InterfaceY
JOptionPane.showMessageDialog(null, "Executou o método1 da InterfaceY");
}
public void f2(){ //Método2 da InterfaceY
JOptionPane.showMessageDialog(null, "Executou o método2 da InterfaceY");
}
}
package programas;
import entity.ExemploInterface;
public class MainInterface {
public static void main(String[] args) {
ExemploInterface exemplo = new ExemploInterface();
exemplo.metodoDaClasse();
exemplo.metodo2();
exemplo.f1();
exemplo.f2();
}
}
try-catch-finally
Tratamento de Exceções e Erros
Umas das utilidades proporcionadas pela orientação a objetos de Java é a facilidade em tratar
possíveis erros de execução chamados de exceções.
Sempre que um método de alguma classe é passível de causar algum erro, então, podemos usar o
método de tentativa - o try.
33
Tudo que estiver dentro do bloco try será executado até que alguma exceção seja lançada, ou
seja, até que algo dê errado.
Quando uma exceção é lançada, ela sempre deve ser capturada. O trabalho de captura da exceção
é executado pelo bloco catch.
Um bloco try pode possuir vários blocos de catch, dependendo do número de exceções que
podem ser lançadas por uma classe ou método.
O bloco catch obtém o erro criando uma instância da exceção. Portanto, a sintaxe do bloco try
catch é:
try {
// código a ser executado
}
catch (ClasseDeExceção instânciaDaExceção) {
// tratamento da exceção
}
Exceções
As exceções são, na verdade, instâncias de classes. E como qualquer classe ou objeto, podemos
facilmente manipular.
Existem métodos comuns entre todas as classes de Exceções, dentre as quais podemos citar:
toString()
O Java usa o método toString() toda vez que for necessário converter um objeto em String, ou
seja, para obter ume representação textual do objeto.
Por exemplo para imprimir um objeto qualquer usando System.out.println ou para mostrar os
itens de um JComboBox.
Esse método toString() é definido na classe Object, portanto é herdado por todos os objetos.
Todos os objetos são capazes de gerar uma representação textual. Mas o método do Object não
conhece as classes derivadas, não sabe como o objeto deve ser representado. Por isso usa um
padrão: o nome da classe seguido por um '@' e pelo hashCode em hexadecimal da instância em
questão.
No Java cada classe deve fornecer um hashCode(), método que recebe os dados armazenados
em uma instância da classe em um único valor hash1.
Retorna uma “representação em texto” do objeto. Converte os dados da exceção em String para
visualização.
1 Um hash é uma sequência de bits geradas por um algoritmo de dispersão, em geral representada em base
hexadecimal, que permite a visualização em letras e números (0 a 9 e A a F). O conceito teórico diz que "hash é a transformação de uma grande quantidade de informações em uma pequena quantidade de informações".
34
printStackTrace()
Imprime na saída de erro padrão (geralmente console) todos os frames de onde foram detectados
erros. Útil para depuração no desenvolvimento, pois mostra todo o histórico do erro, além das
linhas onde foram ocasionados.
getCause()
Retorna a causa da Exceção, ou null se a causa for desconhecida ou não existir.
getMessage()
Retorna uma string com o erro. É uma forma simples e elegante de mostrar a exceção causada,
geralmente, utilizada como forma de apresentação ao usuário.
Finally
Finally é o trecho de código final. A função básica de finally é sempre executar seu bloco de
dados mesmo que uma exceção seja lançada.
É muito útil para liberar recursos do sistema quando utilizamos, por exemplo, conexões de banco
de dados e abertura de buffer para leitura ou escrita de arquivos.
Finally virá após os blocos de catch.
try {
// código a ser executado
}
catch (ClasseDeExceção instânciaDaExceção) {
// tratamento da exceção
}
finally {
// código a ser executado mesmo que uma exceção seja lançada
}
Abaixo está um exemplo de tratamento de erro ou exceção. Tentaremos atribuir uma string de
letras a um objeto inteiro.
Como não é possível atribuir uma string de letras a um objeto inteiro, uma exceção de formato
de número é lançada.
package programas;
public class ExemploTryCatchFinally {
public static void main(String[] args){
String var = "ABC";
try {
Integer i = new Integer(var);
System.out.println("A variável i vale " + i);
}
catch (NumberFormatException e){
System.out.println("Não é possível atribuir numero a string");
System.out.println("fillInStackTrace: " + e.fillInStackTrace());
System.out.println("getCausa: " + e.getCause()); System.out.println("getLocalizedMessage: " + e.getLocalizedMessage());
35
System.out.println("getMessage: " + e.getMessage());
System.out.println("getStackTrace:" + e.getStackTrace());
System.out.println("toString: " + e.toString());
System.out.println("printStackTrace: "); e.printStackTrace();
System.out.println();
}
finally{
System.out.println("Execute com ou sem erro.");
}
}
}
run:
Não é possível atribuir numero a string
java.lang.NumberFormatException: For input string: "ABC"
fillInStackTrace: java.lang.NumberFormatException: For input string: "ABC"
getCausa: null
getLocalizedMessage: For input string: "ABC"
getMessage: For input string: "ABC"
getStackTrace:[Ljava.lang.StackTraceElement;@3e25a5
at programas.ExemploTryCatchFinally.main(ExemploTryCatchFinally.java:12)
toString: java.lang.NumberFormatException: For input string: "ABC"
printStackTrace:
Execute com ou sem erro.
CONSTRUÍDO COM SUCESSO (tempo total: 2 segundos)
Exemplo sem o método toString()
package entity;
public class ToStringExemplo {
private final String nome;
private int idade;
private double peso;
public ToStringExemplo(String nome, int idade, double peso) {
this.nome = nome;
this.idade = idade;
this.peso = peso;
}
public static void main(String[] args) { ToStringExemplo pessoa = new ToStringExemplo("Jose da Silva ", 21, 1.70);
System.out.println(pessoa);
}
}
Resultado:
entity.ToStringExemplo@3e25a5
CONSTRUÍDO COM SUCESSO (tempo total: 0 segundos)
36
Exemplo com o método toString()
package entity;
public class ToStringExemplo {
private final String nome;
private int idade;
private double peso;
public ToStringExemplo(String nome, int idade, double peso) {
this.nome = nome;
this.idade = idade;
this.peso = peso;
}
@Override
public String toString() {
return nome + " " + idade + " " + peso;
}
public static void main(String[] args) { ToStringExemplo pessoa = new ToStringExemplo("Jose da Silva ", 21, 1.70);
System.out.println(pessoa.toString());
}
}
Resultado:
Jose da Silva 21 1.7
CONSTRUÍDO COM SUCESSO (tempo total: 1 segundo)
Erro com toString
package programas;
import javax.swing.JOptionPane;
public class ExemploTryCatchFinally {
public static void main(String[] args){
String var = "ABC";
try{
Integer i = new Integer(var);
JOptionPane.showMessageDialog(null,"A variável i vale " + i);
}
catch (NumberFormatException e){
JOptionPane.showMessageDialog(null,
"Não é possível atribuir a string " +
var +
" a um Objeto Inteiro.\n" +
"A seguinte mensagem foi retornada:\n\n" +
e.getMessage());
JOptionPane.showMessageDialog(null,
"Outra forma de mostrar a mensagem: " +
e.toString());
}
finally{
JOptionPane.showMessageDialog(null,"Execute com ou sem erro");
}
}
}
37
Unidade 1 – Interfaces Gráficas Usando JFC/Swing
1.1 Introdução
Neste capítulo vamos ver como criar aplicações gráficas em Java, mais precisamente usando um
Framework (conjunto de classes) chamado Swing. Veremos três exemplos, começando com um
simples programa que apenas escreve uma mensagem na tela, passando para um programa que já
trabalha com caixas de texto e botões, e por final veremos como trabalhar com listas. Há ainda
uma seção especialmente sobre gerenciamento de layout, os chamados "Layout Managers", item
muito importante quanto se trata de programação GUI- Graphical User Interfaces (Interface
Gráfica com o Usuário).
Conhecendo o Swing
Nas primeiras versões do Java a única forma de fazer programas gráficos era através da AWT-
Abstract Window Toolkit (), uma biblioteca de baixo-nível que dependia de código nativo da
plataforma onde rodava. Ela traz alguns problemas de compatibilidade entre as plataformas,
fazendo que nem sempre o programa tinha aparência desejada em todos os sistemas
operacionais, sendo também mais difícil de ser usada. Para suprir as necessidades cada vez mais
freqüentes de uma API (Application Programming Interface) mais estável e fácil de usar.
O Swing foi criado como uma extensão do Java a partir da versão 1.2. Swing fornece
componentes de mais alto nível, possibilitando assim uma melhor compatibilidade entre os
vários sistemas onde Java roda. Ao contrário da AWT, Swing não contém uma única linha de
código nativo, e permite que as aplicações tenham diferentes tipos de visuais ( skins ), os
chamados "Look and Feel". Já com AWT isso não é possível, tendo todos os programas a
aparência da plataforma onde estão rodando. Apesar da AWT ainda estar disponível no Java, é
altamente recomendável que sejam usado Swing, pelas razões descritas aqui e por várias outras.
Componentes Swing contém um "J" na frente, como em JButton por exemplo. Componentes
AWT não contém inicial alguma ( "Button" no caso ). Além disso tudo, as vantagens do Swing
não param por ai. Há uma enorme gama de controles extras disponíveis, tais como áreas de texto
que nativamente podem mostrar conteúdo RTF (Rich Text Format) ou HTML, botões com
suporte a imagens, sliders, selecionadores de cores etc. É também possível alterar o tipo de borda
para a maior parte dos componentes, todos podem ter imagens associadas e é possível até ter
controle de como são desenhados os mínimos detalhes de apresentação.
Criação de Interfaces Gráficas
Em Java, as classes nas quais nos baseamos para criar os componentes,bem como para fornecer-
lhes funcionalidade, estão agrupadas em dois grandes pacotes: java.awt (pacote do núcleo) e
javax.swing (pacote de extensão). Os dois pacotes definem componentes com peculiaridades
distintas e que serão discutidas logo abaixo.
1.1.2 Componentes Swing
O pacote javax.swing foi criado em 1997 e inclui os componentes GUI que se tornaram padrão
em Java a partir da versão 1.2 da plataforma Java2. A maioria dos componentes Swing (assim
são denominados) são escritos, manipulados e exibidos completamente em Java, sendo
conhecidos como componentes Java puros. Isso oferece a eles um maior nível de portabilidade e
38
flexibilidade. Os nomes de tais componentes recebem um “J”, como, por exemplo: JLabel,
JButton, JFrame, JPanel, etc.
Tal peculiaridade se justifica para diferenciar esses componentes dos que serão mencionados
logo adiante. São considerados peso-leve e fornecem funcionalidade e aparência uniforme em
todas as plataformas, sendo denominada de aparência de metal (metal look-and-feel).
Entretanto, muitos componentes Swing ainda são considerados peso-pesados. Em particular, as
subclasses de java.awt.Window, como JFrame, utilizada para exibir janelas e as de
java.applet.Applet, como JApplet originam componentes que se apoiam no sistema de janelas da
plataforma local para determinar sua funcionalidade, aparência e seu comportamento.
O Swing também fornece flexibilidade para personalizar a aparência e ocomportamento dos
componentes de acordo com o modo particular de cada plataforma, ou mesmo alterá-los
enquanto o programa está sendo executado. As opções são a personalização com o estilo do
Microsoft Windows, do AppleMacintosh ou do Motif (UNIX).
1.1.3 Componentes A.W.T.
Os componentes GUI oriundos do pacote Abstract Windowing Toolkit - AWT (java.awt)
tiveram origem na versão 1.0 da plataforma Java 2, e estão diretamente associados com os
recursos da interface gráfica da plataforma do usuário.
Dessa forma, a aparência dos componentes diferem quando o programa é executado no
Microsoft Windows e no Apple Macintosh. Podemos dizer que estes componentes considerados
peso-pesados “herdam” a aparência definida pela plataforma, pois o A.W.T. foi projetado para
que cada máquina virtual Java implemente seu elemento de interface. Isso pode ser desejável,
uma vez que permite aos usuários do programa utilizar os componentes GUI com que eles já
estão familiarizados, porém o leiaute e o alinhamento dos componentes pode se alterar devido
aos tamanhos diferentes dos mesmos em cada plataforma.
1.1.4 Look and Feel
Look-and-Feel (olhar e perceber) (ou LaF) é o nome que se dá à “cara” da aplicação (suas cores,
formatos e etc).
Por padrão, o Java vem com um look-and-feel próprio, que se comporta exatamente da mesma
forma em todas as plataformas suportadas.
Mas às vezes esse não é o resultado desejado. Quando roda-se a aplicação no Windows, por
exemplo, é bastante gritante a diferença em relação ao visual das aplicações nativas. Por isso é
possível alterar qual o look-and-feel a ser usado na aplicação.
Além do padrão do Java, o JRE-Java Runtime Environment 5 (Ambiente de Tempo de Execução
Java) da Sun ainda traz LaF nativos para Windows e Mac OS, além do Motif e GTK. E, fora
esses, ainda podem ser baixados diversos LaF na Internet ou até desenvolver os próprios.
Abaixo estão alguns screenshots da documentação do Swing mostrando a mesma aplicação
rodando com 4 LaF diferentes:
39
OBSERVAÇÕES:
Para alterar o look-and-feel de um aplicativo é possível usar o método estático setLookAndFeel()
da classe javax.swing.UIManager. Tal método requer um objeto LookAndFeel/ String com o
nome da classe como argumento.
Alguns exemplos de objetos LookAndFeel:
o javax.swing.plaf.metal.MetalLookAndFeel;
o javax.swing.plaf.synth.SynthLookAndFeel;
Consultar o javadoc do Swing pode não ser muito simples. Por isso, a Sun disponibiliza um
ótimo tutorial online sobre Swing em seu Site: http://java.sun.com/docs/books/tutorial/uiswing/
Existem alguns bons editores visuais (Drag-and-Drop) para se trabalhar com Swing, entre
produtos comerciais e livres. Destaque para:
O Matisse, que vem embutido no Netbeans e é considerado, hoje, o melhor editor;
O VEP (Visual Editor Plugin), um plugin que pode ser instalado no Eclipse;
40
Aplicações grandes com Swing podem ganhar uma complexidade enorme e ficar difíceis de
manter. Alguns projetos tentam minimizar esses problemas; há, por exemplo, o famoso projeto
Thinlet, onde você pode utilizar Swing escrevendo suas interfaces gráficas em XML.
1.2 Hierarquia de Classe
Abaixo, a hierarquia de herança das classes que definem atributos e comportamentos que são
comuns a maioria dos componentes Swing. Cada classe é exibida com o seu pacote:
1.2.1 java.lang.Object
O java.lang.Object classe é a superclasse final de todos os objetos Se uma classe não
explicitamente estender uma classe, o compilador assume que se estende java.lang.Object.
Os Métodos de java.lang.Object
A classe java.lang.Object fornece um número de métodos que são comuns a todos os objetos. O
método toString () é o mais comum, tais. Como o padrão toString () método produz apenas o
nome da classe, você deve substituí-lo em todas as classes que você definir.
public Object ();
getClass Classe public final ();
hashCode public int ();
public boolean equals (Object obj);
Object clone protegido () lança CloneNotSupportedException;
public String toString ();
notify public void final ();
notifyAll public void final ();
espera public void final (long timeout) lança InterruptedException;
espera public void final (long timeout, int nanossegundos) lança InterruptedException;
espera public void final () throws InterruptedException;
protected void finalize () throws Throwable.
JLabel JComboBox JList JPanel JSlider JPopuMenu
u
javax.swing.JCompontent
java.awt.Container
java.awt.Component
java.lang.Object
41
1.2.2 java.awt.Component
Componentes A.W.T.
Os componentes GUI oriundos do pacote Abstract Windowing Toolkit (java.awt) tiveram
origem na versão 1.0 da plataforma Java 2, e estão diretamente associados com os recursos da
interface gráfica da plataforma do usuário. Dessa forma, a aparência dos componentes difere
quando o programa é executado no Microsoft Windows e no Apple Macintosh. Podemos dizer
que estes componentes considerados peso-pesados “herdam” a aparência definida pela
plataforma, pois o A.W.T. foi projetado para que cada máquina virtual Java implemente seu
elemento de interface. Isso pode ser desejável, uma vez que permite aos usuários do programa
utilizar os componentes GUI com que eles já estão familiarizados, porém o leiaute e o
alinhamento dos componentes pode se alterar devido aos tamanhos diferentes dos mesmos em
cada plataforma.
Essa coleção de componentes para construção de Interfaces Gráficas está desatualizada e foi
substituida pelo projeto Swing. Em virtude disso, nossa ênfase reside no estudo e uso do pacote
em maior evidência.
Um componente é um objeto tendo uma representação gráfica que pode ser visualizado no
monitor e que pode interagir com o utilizador. Exemplos de componentes são os botões, caixas, e
barras de rolagem de uma interface gráfica.
As operações comuns à maioria dos componentes GUI, tanto Swing como AWT são definidas na
classe Component. Isso inclui os métodos relativos a:
Posicionamento;
Personalização;
Tamanho;
Visibilidade;
Pintura;
registro de tratadores de eventos;
Ajuste e retorno de estado dos componentes.
Em aplicativos com JFrames e em applets, anexamos os elementos ao painel de conteúdo, que
é um objeto da classe Container. Logo, a classe Container dá suporte à adição e posicionamento
dos componentes ao painel de conteúdo de um contêiner.
Alguns componentes do Java AWT:
Marcadores
Este é o mais simples componente de Java Toolkit Abstract Window. Esse componente é
geralmente usado para mostrar o texto ou string em sua aplicação e rotular nunca executar
qualquer tipo de ação.
Sintaxe:
Etiqueta LABEL_NAME = new Etiqueta ("Este é o texto do rótulo.");
código acima representa simplesmente o texto para o rótulo.
42
Etiqueta LABEL_NAME = new Etiqueta ("Este é o texto do rótulo." , Label.CENTER);
Justificação da etiqueta pode ser de esquerda, direita ou centralizado. Acima de declaração
utilizada a justificação centro da etiqueta utilizando o Label.CENTER.
Botões
Este é o componente de Java Abstract Window Toolkit e é usado para disparar ações e outros
eventos necessários para sua aplicação. A sintaxe de definição do botão é a seguinte:
Botão button_name = new botão ("Este é o rótulo do botão.");
Pode-se alterar o rótulo do botão, ou o texto do rótulo usando o botão.setLabel(String) e
botão.getLabel() método. Os botões são adicionados ao contêiner usando o add
(button_name) método.
Caixas de seleção
Este componente do Java AWT permite que se crie caixas de seleção em suas aplicações. A
sintaxe da definição de Caixa é a seguinte:
CheckBox checkbox_name = new Checkbox ("caixa de seleção opcional 1" , false);
O código acima constrói a caixa de seleção desmarcada, passando o argumento boolean valor
falso com o rótulo Checkbox através do Checkbox() construtor. Checkbox definido é
acrescentado à seu contêiner usando add(checkbox_name) método. Pode-se alterar e obter
rótulo da caixa de seleção usando o setLabel(String) e getLabel() método. Pode-se,
também, definir e obter o estado da caixa de seleção usando o setState
(boolean) e GetState() método fornecido pela Caixa classe.
Radio Button
Este é o caso especial do componente Checkbox de pacote Java AWT. Isto é usado como um
grupo de caixas que nome do grupo é o mesmo. Apenas uma caixa de seleção de um grupo de
checkbox pode ser selecionada por vez. Sintaxe para a criação de botões de rádio é a seguinte:
CheckboxGroup chkgp = new CheckboxGroup();
add(novo Checkbox ("One", chkgp, false);
adicionar (novo Checkbox ("Two", chkgp, false);
add(novo Checkbox ("Tree", chkgp, false);
No código acima estamos fazendo três caixas de seleção com o rótulo de "Um", "Dois" e "Três".
Área de texto
Este é o componente recipiente de texto do pacote Java AWT. A área de texto contém texto
simples. TextArea pode ser declarado como segue:
TextArea txtArea_name = new TextArea();
43
Você pode fazer a área de texto editável ou não. Usar o (boolean) setEditable método. Se
você passar o argumento boolean valor falso, em seguida, a área de texto será não-editável caso
contrário, será editável. A área de texto é, por padrão no modo editável. Texto são definidas na
área de texto usando o setText (string) método do TextArea classe.
Campo de texto
Esta é também a componente recipiente de texto de pacote Java AWT. Este componente contém
linha única e informações de texto limitada. Esta é declarada como segue:
TextField txtfield = new TextField(20);
Pode-se corrigir o número de colunas no campo de texto, especificando o número no
construtor. No código acima, temos fixado o número de colunas igual a 20.
1.2.3 java.awt.Container
Containers
Dificilmente uma aplicação gráfica é composta por um único componente, mas sim por vários
componentes inter-relacionados. Para este tipo de aplicação, um componente fundamental é a
área onde os demais componentes da aplicação estarão dispostos. Um componente que pode
conter outros componentes é denominado um container.
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().
Window é uma classe derivada de Container cujos objetos estão associadas a janelas. Cada
objeto Window é uma janela independente em uma aplicação, embora a essa janela não estejam
associadas as funcionalidades usualmente oferecidas por gerenciadores de janela. Raramente um
objeto desse é usado diretamente, mas objetos dessa classe são muito utilizados através de suas
subclasses, tais como Frame.
Outra classe derivada de Container de extensa aplicação é Panel , que define uma área de
composição de componentes contida em alguma janela. A classe Applet é uma extensão
de Panel que permite criar applets.
Embora a classe JComponent, raiz da hierarquia para todos os componentes do
novo framework para interfaces gráficas de Java, seja derivada da classe Container, não se pode
acrescentar diretamente um componente gráfico a qualquer componente Swing. Para as classes
de Swing que correspondem a containers no sentido definido em AWT, ou seja, às quais podem
ser acrescentados outros componentes, deve-se obter uma referência ao objeto Container através
do método getContentPane().
Um Container, em programação orientada a objetos, é um delimitador abstrato, "um objeto que
contém outros objetos". Estes podem ser incluídos ou removidos dinamicamente (durante
o tempo de execução), diferentemente do que ocorre em uma composição onde este
relacionamento é fixado durante o tempo de compilação.
44
java.awt Container Classe
java.lang.Object
java.awt.Component
java.awt.Container
public class Container estende Component
Um genérico Abstract Window Toolkit objeto de recipiente (AWT) é um componente que pode
conter outros componentes AWT.
Componentes adicionados a um recipiente são controlados em uma lista. A ordem da lista vai
definir ordem dos componentes front-to-back de empilhamento dentro do recipiente. Se nenhum
índice é especificado quando a adição de um componente para um recipiente, será adicionada ao
fim da lista (e, consequentemente, para a parte inferior da ordem de empilhamento).
1.2.4 javax.swing.JCompontent
A classe JComponent
Com exceção de nível superior recipientes, todos os componentes Swing cujos nomes começam
com "J" descer do JComponent classe.
Por exemplo, JPanel, JScrollPane, JButton e JTable todos herdam de JComponent . No entanto,
JFrame e JDialog não o fazem porque eles implementam de nível superior recipientes.
O JComponent classe estende a Container classe, que se estende Component .
O Componente classe inclui tudo, desde fornecendo sugestões de layout para pintura apoiar e
eventos. O Container classe tem suporte para adicionar componentes para o container e
colocando-as fora. Esta seção de tabelas de API resume os métodos mais frequentemente
utilizados de Componente e Container , bem como de JComponent .
A classe JComponent, que define os atributos e comportamentos para suas subclasses,
é a superclasse da maioria dos componentes Swing. Com exceção dos conteiners JFrame e
JDialog, todos os demais componentes Swing cujo nome comece com “J” descendem da classe
JComponent.
Os componentes Swing derivados de JComponent tem muitos recursos:
Uma aparência e comportamento plugáveis, adpatados também as diferentes sistemas
operacionais;
Teclas de atalho (menemônicas) para acesso direto aos componentes a partir do teclado;
Capacidades comuns para tratamento de eventos, no caso em que vários componentes
GUI iniciam a mesma ação em um programa;
Descrições de finalidade associada ao componente;
Podem ser extendidas facilmente a programa para deficientes físicos;
Suporte para linguas locais – o programa pode ser usado em diferentes línguas.
45
1.3 Modelos de Desenvolvimento
Em Java, as classes nas quais nos baseamos para criar os componentes, bem como para fornecer-
lhes funcionalidade, estão agrupadas em dois grandes pacotes: java.awt (pacote do núcleo) e
javax.swing (pacote de extensão). Os dois pacotes definem componentes com peculiaridades
distintas e que serão discutidas logo abaixo.
1.3.1 Desenvolvimento do Swing
Estrutura de uma Interface Swing
1.3.1.1 JDialog
JDialog é a versão do Swing de diálogo e descende diretamente dessa classe. Como diálogo, ele
usa BorderLayout por padrão. Como JFrame e JWindow, JDialog contém uma hierarquia
rootPane incluindo um ContentPane, e permite que os painéis de camadas e vidro. Todos os
diálogos são modais, o que significa que o atual thread é bloqueado até que a interação do
usuário com ele tenha sido concluída. JDialog classe destina-se como a base para a criação de
diálogos personalizados, no entanto, alguns dos diálogos mais comuns são fornecidos através de
métodos estáticos na classe JOptionPane.
Usamos a classe JDialog, que é susbclasse de java.awt.Dialog para criarmos caixas de diálogo
elaboradas, embora mais limitados que as originadas por JFrames. Em prol da facilidade, a classe
JOptionPane, que está definida no pacote de extensão javax.swing, oferece caixas de diálogo
pré-definidas que permitem aos programas exibir simples mensagens para os usuários. Cada vez
que usamos uma JOptionPane para implementar um diálogo, na verdade estamos usando uma
JDialog nos bastidores. A razão é que JOptionPane são simplesmente um contêiner que pode
automaticamente criar uma JDialog e anexá-la ao seu painel de conteúdo.
Embora esses diálogos sejam maneiras válidas de receber entrada do usuário e exibir a saída de
um programa, suas capacidades são um tanto limitadas - o diálogo pode obter somente um valor
por vez e só pode exibir uma mensagem. Mais usual é receber várias entradas de uma só vez, de
modo que o usuário possa visualizar todos os campos de dados. A medida que formos avançando
no conteúdo, o leitor será capaz de sanar tais deficiências usando novos componentes.
JFrame
JPanel
JButton
JLabel
46
As caixas de diálogo podem ser configuradas como modais ou não-modais, valendo-se do
método setModal(boolean). As modais não permitem que qualquer outra janela do aplicativo
seja acessada até que seja tratada a solicitação ou intervenção da caixa de diálogo. O
comportamento oposto se observa nas não-modais. Os diálogos exibidos com a classe
JOptionPane, por defaut, são diálogos modais. Além disso, podemos definir se o tamanho de
uma JDialog é redimensionável, com o método setResizable(boolean).
Obviamente, devido a diversidade de funcionalidades e de construtores, para usarmos todas as
potencialidades devemos estudar profundamente as classes em questão. Abaixo mostraremos
alguns métodos estáticos da classe JOptionPane (todos são precedidos por JOptionPane).
showInputDialog(String)
Método usado para solicitar a entrada de algum dado em forma de String. Lembre-se que os
valores recebidos devem ser atribuídos à variáveis do tipo String e convertidos para outros tipos
caso desejarmos realizar operações sobre eles.
showMessageDialog(Component, Object, String, Icon)
O propósito do primeiro argumento (Component) é especifiar a janela-pai para a caixa de
diálogo. Um valor null indica que a caixa de diálogo será exibida no centro da tela. No caso de
nossa aplicação apresentar várias janelas, podemos especificar nesse argumento a janela-pai, de
modo que a caixa de diálogo aparecerá centralizada sobre a janela-pai especificada, que
necessariamente pode não corresponder ao centro da tela do computador.
O segundo argumento (object) normalmente especifica o String a ser mostrado ao usuário. A
caixa de diálogo comporta qualquer tamanho de String, já que a mesma é dimensionada
automaticamente para acomodar o texto. Também é possível exibir longas saídas baseadas em
texto, passando como argumento para o método um objeto da classe JTextArea.
O terceiro argumento (String) denomina a barra de título. É opcional já que, se forem ignorados
o terceiro e o quarto argumento, a caixa de diálogo exibirá uma mensagem do tipo
INFORMATION MESSAGE, com o texto “Message” na barra de título e um ícone de informação à
esquerda da mensagem de texto.
O quarto argumento (Icon) refere-se a o ícone que será exibido e ao tipo de diálogo de
mensagem. Esse ícone é definido pelo usuário. A tabela abaixo apresenta as "constantes" da
linguagem Java para definição dos ícones a serem apresentados na tela.
Ícone Comando
Pergunta
JOptionPane.QUESTION_MESSAGE - Impõe uma
mensagem que pergunta algo ao usuário
Informação
JOptionPane.INFORMATION_MESSAGE - Exibe uma
mensagem com informações que podem ser dispensadas.
Alerta
JOptionPane.WARNING_MESSAGE – Indica
mensagem de advertência sobre algum problema em
potencial.
Erro
JOptionPane.ERROR_MESSAGE - Indica mensagem
de erro ao usuário.
Vazio (somente mensagem) JOptionPane.PLAIN_MESSAGE - Exibe um diálogo
que simplesmente contém uma mensagem sem nenhum ícone
47
No último argumento podemos definir um ícone (classe Icon) que será exibido junto da caixa de
diálogo. Ele deve residir no mesmo diretório da aplicação ou teremos que especificar o caminho.
showOptionDialog(Component, Object, String, int, int, Icon, Object[ ],Object)
Este método apresenta tudo o que foi descrito no método precedente a ainda suporta a criação de
outros botões, para opções personalizadas.
Como você pode observar, os três primeiros argumentos são os mesmos do método precedente.
O quarto refere-se ao conjunto de botões que aparecem abaixo do diálogo.
Escolha um a partir do conjunto de valores padrão:
DEFAULT OPTION, YES NO OPTION;
YES NO CANCEL OPTION, OK CANCEL OPTION.
O quinto argumento aqui é o mesmo que o o quarto descrito no método precedente, ou seja,
determina o tipo de mensagem exibida no diálogo.
O sexto, refere-se ao ícone que será exibido no diálogo.
O argumento sequente determina que os botões de opção apareçam abaixo do diálogo.
Geralmente, especificamos um array de Strings para rotular os botões, sendo que cada elemento
do array define um botão.
Cada vez que selecionamos um botão, um valor inteiro que corresponde ao índice do array é
retornado pela JOptionPane. Você verá no exemplo2 logo adiante que podemos atribuir esse
valor a uma variável e posteriormente pode-se implementar um processo de decisão que
corresponda à escolha feita pelo usuário.
Finalmente, o último argumento define o botão default a ser selecionado.
1.3.1.1.1. JOptionPane
A classe JOptionPane pode ser usada para criar diálogos modais simples, que permitem a
costumização de ícones, títulos, textos e botões.
JOptionPane faz com que seja fácil exibir um diálogo padrão que leia um valor do usuário ou
informe-o de algo. Entretanto, a maioria dos usos desta classe são simplesmente chamadas de
uma única linha para um dos métodos estáticos showXxxDialog. Os tipos de caixas de diálogo
são:
showInputDialog – mostra a caixa de entrada do texto;
showMessageDialog – mostra o texto digitado;
showConfirmDialog – solicita confirmação;
showOptionDialog – oferece opções.
1.3.1.1.2 showInputDialog
JOptionPane.showInputDialog("Titulo"): Mostra uma caixa de diálogo e solicita a digitação de
um dado;
48
1.3.1.1.3 showMessageDialog
JOptionPane.showMessageDialog(null,"Titulo" + variavel): Mostra uma caixa de diálogo com o
dado digitado e o null é o componente pai, utilizado para especificar a posição de criação da
janela.
Exemplo1:
package Exemplos; import entity.Pessoa; import javax.swing.JOptionPane; public class Exemplo1JoptionPane { public static void main(String[] args) { Pessoa p = new Pessoa(); p.setNome(JOptionPane.showInputDialog(null,"Digite o nome: ")); p.setCep(Integer.parseInt(JOptionPane.showInputDialog(null, "Digite o cep: "))); p.setPeso(Float.parseFloat(JOptionPane.showInputDialog(null, "Digite o peso: "))); JOptionPane.showMessageDialog(null, "Nome digitado: " + p.getNome()); JOptionPane.showMessageDialog(null, "Cep digitado: " + p.getCep()); JOptionPane.showMessageDialog(null, "Peso digitado: " + p.getPeso()); } }
1.3.1.1.4 showConfirmDialog
Outra caixa de diálogo simples e objetiva do JOptionPane é a caixa de diálogo de confirmação
ou Confirm Dialog.
A Confirm Dialog (caixa de confirmação) consiste de uma caixa contendo uma mensagem, um
ícone e três botões: sim, não e cancelar.
Apesar deste ser o aspecto padrão, esta caixa, como qualquer outra de JOptionPane, pode ser
facilmente configurada (assunto que será tratado com mais detalhes nas próximas aulas).
No método padrão chamado showConfirmDialog usamos dois argumentos:
49
1. O primeiro é a dependência ou frame pai, ou seja, de qual janela esta confirmação está sendo
gerada. Como nossos exemplos iniciais não possuem nenhuma dependência, então, sempre
usaremos null neste argumento.
2. O segundo argumento é a mensagem que desejamos mostrar ao usuário.
O método showConfirmDialog sempre retorna uma constante que é a resposta clicada pelo
usuário, que são:
Valor Nome da Constante Equivale
0 YES_OPTION ao clicar no botão Yes (sim)
1 NO_OPTION ao clicar no botão No (não)
2 CANCEL_OPTION ao clicar no botão Cancel (cancelar)
Exemplo2:
package Exemplos; import javax.swing.JOptionPane; public class Exemplo2JoptionPane { public static void main(String[] args) { String nome = null; int resposta; nome = JOptionPane.showInputDialog("Qual é o seu nome?"); resposta = JOptionPane.showConfirmDialog(null,"O seu nome é " + nome + "?"); if (resposta == JOptionPane.YES_OPTION){ JOptionPane.showMessageDialog(null, "Meu nome é " + nome); } if (resposta == JOptionPane.NO_OPTION){ JOptionPane.showMessageDialog(null, "Meu não nome é " + nome); } if (resposta == JOptionPane.CANCEL_OPTION){ JOptionPane.showMessageDialog(null, "Opção candelada!");
50
} } }
1.3.1.1.5 showOptionDialog
As caixas de diálogo de opção são geradas a partir do método showOptionDialog() e são bem
complexas. São capazes de combinar todos os recursos já vistos nas outras caixas de diálogo.
Sintaxe:
JOptionPane.showOptionDialog(Component, <mensagem>, <título da mensagem>, <botões
presentes>, <tipo de mensagem>, <ícone>, <array de objetos>, <seleção padrão>).
Exemplo3:
opcao = JOptionPane.showOptionDialog(null,"Escolha a operação","Operação",
JOptionPane.DEFAULT_OPTION,JOptionPane.QUESTION_MESSAGE,null,opcoes,opcoes[0);)
package Exemplos; import javax.swing.JOptionPane; public class Exemplo3JoptionPane { public static void main(String[]args) { String num1; String num2; int opcao; int vlrNum1; int vlrNum2; int resultado; num1 = JOptionPane.showInputDialog("Primeiro numero"); num2 = JOptionPane.showInputDialog("Segundo numero"); vlrNum1 = Integer.parseInt(num1); vlrNum2 = Integer.parseInt(num2);
51
String[] opcoes = {"Somar", "Subtrair", "Multiplicar", "Dividir"}; opcao = JOptionPane.showOptionDialog(null,"Escolha a operação","Operação", JOptionPane.YES_NO_OPTION,JOptionPane.QUESTION_MESSAGE,null,opcoes,opcoes[0]); if (opcoes[opcao].equals("Somar")){ JOptionPane.showMessageDialog(null, "Valor da Soma: " + (vlrNum1 + vlrNum2)); } else if (opcoes[opcao].equals("Subtrair")){ JOptionPane.showMessageDialog(null, "Valor da Subtração: " + (vlrNum1 - vlrNum2)); } else if (opcoes[opcao].equals("Multiplicar")){ JOptionPane.showMessageDialog(null, "Valor da Multiplicação: " + (vlrNum1 * vlrNum2)); } else if (opcoes[opcao].equals("Dividir")){ JOptionPane.showMessageDialog(null, "Valor da Divisão: " + (vlrNum1 / vlrNum2)); } } }
No código acima, temos o seguinte: Primeiro, foi criado um vetor de Strings chamado “opcoes”.
Nele, foi guardado uma série de textos para usar dentro dos botões da minha caixa de opções.
Depois, foi declarado uma variável int chamada “opcao”, onde ficará guardada a escolha que o
usuário fizer.
A esta variável, é atribuído diretamente o valor da operação de JOptionPane.showOptionDialog.
Veja que ele tem vários argumentos.
Na ordem, temos:
o objeto “pai”, a mensagem, o título, o tipo de opção (coloca-se o Default porque este atributo
será ignorado), depois vem o tipo de mensagem (no caso, uma QUESTION_MESSAGE), em
seguida vem um ícone (está Null, mas poderia ter colocar um objeto do tipo Icon aqui), e logo
depois vem o nome do vetor de onde tiramos os botões (no caso, o vetor “opcoes" que eu
acabara de criar), e em seguida, a opção que vem destacada como“default” (no caso, coloquei a
primeira).
Na linha final do programa, eu simplesmente mandei exibir uma
JOptionPane.showMessageDialog comos seguintes argumentos:Componente “pai”:
null.Mensagem:
o texto do vetor “opcoes", no índice que corresponde à opção clicada (ou seja, vai aparecer o texto
do botão clicado). Título: “Opção escolhida” Tipo de mensagem: “WARNING_MESSAGE”
Onde:
Botões presentes:
52
Um tipo de caixa que utiliza as variáveis YES_NO_OPTION, YES_NO_CANCEL_OPTION ou
OK_CANCEL_OPTION. Deve-se utilizar o 0 (zero) caso outros botões sejam utilizados no lugar
destes.
Tipo de mensagem:
Uma das variáveis de pergunta, informação, alerta, ou erro (QUESTION_MESSAGE,
INFORMATION_MESSAGE, WARNING_MESSAGE, ERROR_MESSAGE,
PLAIN_MESSAGE);
Ícone:
Um objeto ImageIcon a ser apresentado no lugar de um dos ícones do argumento anterior (<tipo
de mensagem>). Se nenhum ícone for usado, deve-se colocar a palavra "null" no lugar desse
argumento.
Array de objetos:
É um array de objetos que contém os componentes ou outros objetos que representam as
escolhas da caixa de diálogo, caso YES_NO_OPTION, YES_NO_CANCEL_OPTION ou
OK_CANCEL_OPTION não esteja sendo utilizado.
Seleção Padrão:
O objeto que representa a seleção padrão, caso as opções YES_NO_OPTION,
YES_NO_CANCEL_OPTION ou OK_CANCEL_OPTION não estejam sendo usadas.
Exemplo4:
package Exemplos; import javax.swing.JOptionPane;
public class Exemplo4JoptionPane { public static void main(String[] args) {
int resposta;
String idade;
53
String[] opcao = {"entre 1 e 20 anos","entre 21 e 40 anos", "entre 41 e 50 anos","mais de 50 anos"};
resposta = JOptionPane.showOptionDialog(null, "Qual sua idade?", "Idade", 0, JOptionPane.QUESTION_MESSAGE, null, opcao, opcao[0]);
idade = opcao[resposta];
JOptionPane.showMessageDialog(null, "Foi informado: " + idade, "Informação", JOptionPane.INFORMATION_MESSAGE);
System.exit(0); }
}
54
1.3.1.2 Exercícios
01 – De acordo com o diagrama abaixo, construa uma classe chamada Pessoa (encapsulada) com
os respectivos métodos gets e sets em um programa Java com swing usando os recursos
showInputDialog() (entrada de dados) e showMessageDialog() (saída de dados). A
classe Pessoa ficará em um pacote chamado entity e a classe principal (main) ficará em pacote
chamado programas. Os dados de entrada deverão ser impressos.
Pessoa string nome
string logradouro
int numero
string complemento
string Bairro
string cidade
string estado
int cep
int telefone
int cpf
int identidade
double peso
float altura
public void get()
public void set()
02 – De acordo com o diagrama abaixo, construa uma classe chamada Aluno (encapsulada) e os
respectivos métodos gets e sets em um programa Java com swing.
Aluno String nomeAluno
float nota1
float nota2
float media
public Aluno()
public void calculaMedia()
public void imprimeSituacao()
03 - Considerando a classe EstoqueMercadorias com os atributos nomeMercadoria,
qtdeMercadoria, precoCusto, precoVenda, faça um programa em Java, usando os recursos do
swing, que gere e imprima as seguintes informações:
1 – Valor total do preço de custo;
2 – Valor total do preço de vendas;
3 – Lucro médio apurado.
04 - Considerando a classe FolhaPagamento com os atributos float salario, float gratificação,
float faltas, float impostoRenda, float salBruto e float salLiquido, faça um programa em Java
usando os recursos do Swing para calcular o salário bruto e o salário líquido. Após o input dos
dados o programa deverá pedir confirmação para efetuar o cálculo e imprimir o valor do salário
líquido.
Obs.
55
Salário liquido = salário bruto (soma dos proventos) – soma dos descontos;
O percentual do imposto de renda e de 10%;
Fazer uso dos métodos get e set (encapsulamento).
05 - Fazer um programa em Java que leia o valor máximo em dólares que um turista pode
comprar no exterior e o valor das compras apurado pela receita federal quando de sua chegada ao
Brasil. Fazer uso da classe ControleCompras com os atributos vlrCompra e vlrLimite.
Pede-se:
06 - Se as compras excederem o valor permitido imprimir mensagem: “Compras com limite
excedido”;
2 – O objeto vlrLimite, (1500,00 dólares) deverá ser declarado como constante (final).
07 – Considere a classe Figura com os seguintes atributos: raio e lado, os métodos calculaArea e
calculaPerimetro, O programa deverá calcular a área ou o perímetro. Uma caixa para a escolha
da operação deve ser disponibilizada.
Cálculo da área: Circulo: raio * raio * 3.1416
Quadrado: lado ao quadrado
Calculo do perímetro: Circulo: 2 * 3.1416 * raio
Quadrado: lado * 4
08 – De acordo com a Figura abaixo construa um programa em Java com swing.
56
1.3.2 JFrame
JFrame é a versão do Swing of Frame e descende diretamente dessa classe. Os componentes
adicionados ao quadro são referidos como o seu conteúdo, as quais são geridos pelo
ContentPane.
JFrame é a classe principal para fazer janelas do Swing, veja este primeiro exemplo, que cria a
classe TesteDiverso como filha da classe JFrame, e no método main cria um objeto da classe e
chama o método show() para que a janela seja exibida.
JFrame
Esta classe define objetos que são frequentemente utilizadas para criar aplicativos baseados em
GUI. Eles consistem em uma janela com barra de título e uma borda e fornecem o espaço para a
GUI do aplicativo ser construída.
A classe JFrame é uma subclasse de java.awt.Frame, que por sua vez é subclasse de
java.awt.Window. Pelo mecanismo de herança, nota-se que JFrames são um dos poucos
componentes GUI do Swing que não são considerados de peso-leve, pois não são escritos
completamente em Java. Sendo assim, quando possível, devemos devolver ao sistema os
recursos ocupados pela janela, descartando-a. Frisamos que a janela de um programa Java faz
parte do conjunto de componentes GUI da plataforma local e será semelhante às demais janelas,
pois serve-se da bibilioteca gráfica do sistema em questão.
Para exibir um título na barra de título de uma JFrame, devemos chamar o construtor de
superclasse de JFrame com o argumento String desejado, dessa forma:
super("Título da Barra");
A classe JFrame suporta três operações quando o usuário fecha a janela.
Por default, a janela é removida da tela (ocultada) quando o usuário intervém indicando o seu
fechamento. Isso pode ser controlado com o método setDefaultCloseOperation(int),
que utiliza como argumento as constantes da interface WindowConstants (pacote javax.swing)
implementada por JFrame:
DISPOSE_ON_CLOSE: descarta a janela devolvendo os seus recursos ao sistema;
DO_NOTHING_ON_CLOSE: indica que o programador determinará o que fazer quando o
usuário designar que a janela deve ser fechada;
HIDE_ON_CLOSE: (o default) a janela é ocultada, removida da tela;
EXIT_ON_CLOSE: determinamos que quando fechamos a JFrame, o aplicativo seja
finalizado. Essa constante é definida na classe JFrame e foi introduzida na versão 1.3 da
Plataforma Java.
A janela só será exibida na tela quando o programa invocar o método setVisible(boolean)
com um argumento true, ou o método show(). O tamanho da janela é configurado com uma
chamada ao método setSize(int x, int y), que define nos valores inteiros dos
argumentos a largura e a altura da mesma. Se não chamarmos esse método, somente a barra de
título será exibida.
Também podemos utilizar o método pack(), que utiliza os tamanhos preferidos dos
componentes anexados ao painel de conteúdo para determinar o tamanho da janela. Por tamanho
57
preferido, entende-se uma chamada realizada pelos gerenciadores de leiaute ao método
getPreferredSize() de cada componente GUI. Esse método indica o melhor tamanho para
os componentes.
É herdado da classe java.awt.Component, de modo que todos os objetos que derivem-se dessa
classe podem responder a essa evocação. Ela devolve um objeto da classe Dimension (pacote
java.awt).
Podemos fazer uso dos métodos setMinimumSize(Dimension) e
setMaximumSize(Dimension), que estabelecem os tamanhos extremos dos elementos. O
componente não deveria ser maior que o tamanho máximo e nem menor que o mínimo.
Entretando, esteja consciente de que certos gerenciadores de leiaute ignoram essa sugestão.
Todos os elementos tem um tamanho preferido default, como, por exemplo, um objeto JPanel,
que tem altura e largura de 10 pixels. Se necessitarmos mudar esse tamanho default, devemos
sobreescrever o método getPreferredSize( ), fazendo com que ele retorne um objeto
Dimension que contenha a nova largura e altura do componente, ou usar o método setPreferredSize(new Dimension( int x, int y)).
No que concerce ao posicionamento, por default, o canto superior esquerdo da janela é
posicionado nas coordenadas (0, 0) da tela, ou seja, no canto superior esquerdo. Podemos alterar
essa característica com o método setLocation(int x, int y).
Métodos Principais
Public void setLocationRelativeTo(null): Centraliza o frame na tela;
Public void setExtendedState(JFrame.MAXIMIZED_BOTH): Executa maximizado;
public void setSize(largura,altura): Delimita tamanho da janela (minimizada);
public void setTitle(String title): Coloca um título na barra de título da janela;
public void show(): Faz o frame aparecer na tela;
public void setVisible(boolean v): Faz com que o frame se torne visível (v=true) ou não
(v=false);
public void setDefaultCloseOperation(int op) :
o Faz a janela realizar uma determinada operação quando fecha. Mais comum:
JFrame.EXIT_ON_CLOSE
Exemplo1:
58
package Exemplos; import javax.swing.JFrame; public class Exemplo1Jframe extends JFrame { public Exemplo1Jframe () { // Construtor super("Titulo do Frame: Testando Frame"); } public static void main(String[] args) { Exemplo1Jframe janela = new Exemplo1Jframe(); //janela.setExtendedState(JFrame.MAXIMIZED_BOTH); // Executa maximizado janela.setLocationRelativeTo(null); // centraliza a janela na tela janela.setSize(400, 200); // definindo tamanho da janela // Outra forma de colocar titilo no Frame //janela.setTitle("Janela de Teste FRAME"); // titulo da janela janela.show(); // Mostrando a janela janela.setSize(400, 200); // definindo tamanho da janela // janela.setVisible(true);// Mostrando a janela janela.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); } }
1.3.3 JPainel
São áreas que comportam outros componentes, inclusive outros painéis. Em outras palavras, são
elementos que fazem a intermediação entre um contêiner e os demais GUI anexados. São criados
com a classe JPanel, que é derivada da classe Container. As JPanel possibilitam a criação de
subconjuntos num contêiner de forma a garantir um maior domínio sobre todas as áreas da
interface.
A classe JPanel não tem painel de conteúdo como applets e JFrames, assim, os elementos devem
ser diretamente adicioandos ao objeto painel.
Além de agregar um conjunto de componentes GUI para fins de leiaute, podemos criar áreas
dedicadas de desenho e áreas que recebem eventos do mouse. Para isso, devemos implementar
subclasses de JPanel e fornecer-lhes tais capacidades sobrescrevendo determinados métodos.
Cabe lembrar que JPanel não suportam eventos convencionais suportados por outros
componentes GUI, como botões, campos de texto e janelas. Apesar disso, JPanel são capazes de
reconhecer eventos de nível mais baixo, como eventos de mouse e de teclas.
1.3.4 JLabel
São rótulos inertes que geralmente informam ou descrevem a funcionalidade de outros
componentes GUI, como por exemplo, campos de texto, ícones, etc. As instruções são mostradas
por meio de uma linha de texto somente leitura, uma imagem, ou ambos. Aqui salientamos o uso
do método setToolTipText(String), o qual fornece dicas de ferramenta a todos os
elementos herdados da classe JComponent. Dessa forma, quando o usuário posicionar o cursor
do mouse sobre algum componente, ficará ciente da função do mesmo. Veremos isso nos
exemplos.
59
O contrutor mais elaborado é JLabel(String, Icon, int). Os argumentos representam o
rótulo a ser exibido, um ícone e o alinhamento, respectivamente.
Como vemos, também é possível a exibição de ícones em muito dos componentes Swing. Para
JLabels, basta especificarmos um arquivo com extensão png, gif ou jpg no segundo argumento
do construtor do JLabel, ou utilizarmos o método setIcon(Icon) Lembramos que o arquivo
da imagem algum Nome.xxx deve encontrar-se no mesmo diretório do programa, ou especifica-
se corretamente a estrutura de diretórios até ele.
Principais métodos:
public JLabel(String text): Cria um novo label com o texto dado como
parâmetro definido como texto de face;
public String getText(): Retorna o texto mostrado no label;
public void setText(String text): Muda o texto de face do label.
As constantes SwingConstants, que definem o posicionamento de vários componentes GUI e
aqui são apropriadas ao terceiro argumento, determinam a locação do ícone em relação ao texto.
São elas:
SwingConstants.NORTH;
SwingConstants.SOUTH;
SwingConstants.EAST;
SwingConstants.WEST;
SwingConstants.TOP;
SwingConstants.BOTTOM;
SwingConstants.CENTER;
SwingConstants.HORIZONTAL;
SwingConstants.VERTICAL;
SwingConstants.LEADING;
SwingConstants.TRAILING;
SwingConstants.NORTH EAST;
SwingConstants.NORTH WEST;
SwingConstants.SOUTH WEST;
SwingConstants.SOUTH EAST;
SwingConstants.RIGHT;
SwingConstants.LEFT.
Não iremos detalhar a funcionalidade de cada uma, pois os nomes já são o suficientente auto-
elucidativos.
Exemplo1:
60
package programas; import javax.swing.JFrame; import javax.swing.JLabel; import javax.swing.JPanel; public class Exemplo1JFrame extends JFrame{ private JPanel painel; private JLabel msg; public Exemplo1JFrame(){ super("Exemplo JFrame JLabel"); } public void criarFrame(){ painel = new JPanel(); msg = new JLabel("Iniciando Java Swing!"); painel.add(msg); add(painel); } public static void main(String args[]){ Exemplo1JFrame ex = new Exemplo1JFrame(); ex.criarFrame(); ex.setSize(300,200); ex.setVisible(true); ex.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); } }
1.3.5 Gerenciador de Layout
O posicionamento de componentes pode ser controlado através de gerenciadores de layout. O
AWT possui cinco ou seis gerenciadores de layout:
FlowLayout;
BorderLayout;
GridLayout;
BoxLayout;
CardLayout;
GridBagLayout;
SpringLayout.
Os gerenciadores de layout são utilizados para organizar os componentes GUI em um Container,
para o propósito de apresentação.
1.3.5.1 FlowLayout
FlowLayout é o gerenciador de layout mais básico, os componentes são adicionados da esquerda
para a direita no Container, na ordem em que são adicionados até atingir a borda do Container,
onde continuam na próxima linha.
Esse Layout ainda permite aos componentes GUI podem ter os seguintes alinhamentos:
LEFT: Indica que cada linha de componentes deve ser alinhada a esquerda;
CENTER: Indica que cada linha de componentes deve ser centralizada;
61
RIGHT: Indica que cada linha de componentes deve ser alinhada a direita;
LEADING: Indica que cada linha de componentes deve ser alinhada com o primeiro lado
de seu Container (levando-se em conta a orientação do Container);
TRAILING: Indica que cada linha de componentes deve ser alinhada com o último lado
de seuContainer (levando-se em conta a orientação do Container);
O FlowLayout é o padrão para java.awt.Applet, java.awt.Panel e javax.swing.JPanel. A classe
FlowLayout herda da classe Object e implementa a interface LayoutManager.
Trata o container como um conjunto de linhas. A altura das linhas é determinada pela altura dos
itens nelas contidos.
Os componentes são adicionados ao container da forma similar a um texto em um parágrafo,
permitindo que cada componente mantenha seu tamanho natural. Como padrão, os componentes
são horizontalmente centralizados no container. É possível mudar esse padrão de alinhamento
especificando um valor alternativo como parâmetro para um dos construtores da classe ou para o
método setAlignment(). Esse parâmetro pode assumir um dos valores constantes definidos na
classe, tais como LEFT ou RIGHT.
É possível também modificar a distância em pixels entre os componentes arranjados através
desse tipo de gerenciador com os métodos setHgap() e setVgap(); alternativamente, esses valores
podem também ser especificados através de construtores da classe FlowLayout. Para obter os
valores utilizados, há métodos getHgap() e getVgap().
Exemplo1:
package programas; import java.awt.FlowLayout; import javax.swing.JFrame; import javax.swing.JButton; public class Exemplo1FlowLayout extends JFrame { private FlowLayout layout; public Exemplo1FlowLayout() { super("Testando Botões FlowLayout"); } public void inicializandoBotoes(){ layout = new FlowLayout(); //cria o objeto FlowLayout layout.setAlignment(FlowLayout.LEFT); setLayout(layout); //define o layout do container }
62
public void adicionandoBotoes(int count) { for(int i=1; i <= count; ++i){ add(new JButton("B" + i)); } } public static void main(String[] args) { Exemplo1FlowLayout j = new Exemplo1FlowLayout(); j.inicializandoBotoes(); j.adicionandoBotoes(10); j.setVisible(true); j.setSize(340,200); j.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); } }
1.3.5.2 BorderLayout
BorderLayout é uma implementação de LayoutManager2 adequado para janelas com até cinco
componentes. Ele permite arranjar os componentes de um container em cinco regiões, cujo
posicionamento é representado pelas constantes:
BorderLayout.NORTH;
BorderLayout.SOUTH;
BorderLayout.EAST; BorderLayout.WEST;
BorderLayout.CENTER.
Exemplo1 BorderLayout:
package programas; import java.awt.BorderLayout; import javax.swing.JButton; import javax.swing.JFrame; public class Exemplo1BorderLayout extends JFrame{ private JButton botao1,botao2,botao3,botao4,botao5; public Exemplo1BorderLayout(){ super("Testando Botões BorderLayout");
}
63
public void BorderLayoutTest(){ botao1 = new JButton("Botão Norte"); botao2 = new JButton("Botão Centro"); botao3 = new JButton("Botão Oeste"); botao4 = new JButton("Botão Sul"); botao5 = new JButton("Botão Leste"); add(botao1, BorderLayout.NORTH); add(botao2, BorderLayout.CENTER); add(botao3, BorderLayout.WEST); add(botao4, BorderLayout.SOUTH); add(botao5, BorderLayout.EAST); } public static void main(String args[]){ Exemplo1BorderLayout border = new Exemplo1BorderLayout(); border.BorderLayoutTest(); border.setSize(400, 200); border.setVisible(true); border.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); } }
Exemplo2 BorderLayout:
package programas; import java.awt.BorderLayout; import javax.swing.JFrame; import javax.swing.JLabel; import javax.swing.JPanel; public class Exemplo2BorderLayout extends JFrame{ JPanel painel1,painel2,painel3,painel4,painel5; JLabel msg1,msg2,msg3,msg4,msg5; public Exemplo2BorderLayout(){ super("Exemplo JFrame JLabel"); } public void criaJanela(){ painel1 = new JPanel(); painel2 = new JPanel();
64
painel3 = new JPanel(); painel4 = new JPanel(); painel5 = new JPanel(); msg1 = new JLabel("Testando ao Norte!"); painel1.add(msg1); add(painel1, BorderLayout.NORTH); msg2 = new JLabel("Testando ao Sul"); painel2.add(msg2); add(painel2, BorderLayout.SOUTH); msg3 = new JLabel("Testando ao Leste"); painel3.add(msg3); add(painel3, BorderLayout.EAST); msg4 = new JLabel("Testando ao Leste"); painel4.add(msg4); add(painel4, BorderLayout.WEST); msg5 = new JLabel("Testando ao Centro"); painel5.add(msg5); add(painel5, BorderLayout.CENTER); } public static void main(String args[]){ Exemplo2BorderLayout ex = new Exemplo2BorderLayout(); ex.criaJanela(); ex.setSize(400, 200); ex.setVisible(true); ex.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); } }
1.3.5.3 GridLayout
GridLayout é um gerenciador de layout que divide o container em uma grade com linhas e
colunas, onde os componentes são colocados a partir da parte superior esquerda e assim
sucessivamente, até completar a linha e para linha abaixo.
A classe GridLayout herda de Object e implementa a interfaceLayoutManager.
Um GridLayout atua como uma grade de uma planilha de cálculo, colocando os componentes em
linhas e colunas pré-determinadas e deixando os componentes com o mesmo tamanho. Veja isso
no exemplo abaixo:
GridLayout é um gerenciador de layout que define os componentes de um container em uma
grade retangular. O recipiente é dividido em retângulos de tamanho igual, e um componente é
colocado em cada retângulo.
Exemplo1:
65
package programas; import javax.swing.*; import java.awt.*; public class Exemplo1GridLayout extends JFrame{ private JButton botao1,botao2,botao3,botao4,botao5; public Exemplo1GridLayout(){ super("Testando Botões GridLayout"); } public void GridLayoutTest(){ setLayout(new GridLayout(3, 2)); // 3 linhas, 2 colunas botao1 = new JButton("Botão 1"); botao2 = new JButton("Botão 2"); botao3 = new JButton("Botão 3"); botao4 = new JButton("Botão 4"); botao5 = new JButton("Botão 5"); add(botao1); add(botao2); add(botao3); add(botao4); add(botao5); } public static void main(String args[]){ Exemplo1GridLayout grid = new Exemplo1GridLayout(); grid.GridLayoutTest(); grid.setVisible(true); grid.setSize(300,200); grid.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); } }
1.3.5.4 BoxLayout
Swing oferece um gerenciador de layout simples, com alto grau de flexibilidade, que é
o BoxLayout . Nesse tipo de layout, componentes podem ser dispostos em uma única linha ou
em uma única coluna, porém arranjos de componentes bem complexos podem ser obtidos
através da combinação desses componentes.
Em BoxLayout os componentes mantêm sua dimensão natural, como em FlowLayout. A direção
na qual os componentes serão dispostos da esquerda para a direita ou se de cima para baixo.
Pode ser especificada no construtor da classe, através respectivamente das
constantes X_AXIS ou Y_AXIS.
Tipicamente, esse tipo de layout não é utilizado diretamente, mas sim através de um container do
tipo Box , que adota BoxLayout como padrão único de gerenciamento de layout.
66
ExemploBoxLayout:
package programas;
import javax.swing.BoxLayout;
import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JPanel;
public class ExemploBoxLayout extends JFrame{
public ExemploBoxLayout(){
super("Testando Botões BoxLayout");
}
public void BoxLayoutTest(){
JPanel panel = new JPanel();
panel.setLayout(new BoxLayout(panel, BoxLayout.Y_AXIS));
JButton botao1 = new JButton("Botão 1");
JButton botao2 = new JButton("Botão 2");
JButton botao3 = new JButton("Botão 3");
JButton botao4 = new JButton("Botão 4");
JButton botao5 = new JButton("Botão 5");
panel.add(botao1);
panel.add(botao2);
panel.add(botao3);
panel.add(botao4);
panel.add(botao5);
getContentPane().add(panel);
}
public static void main(String args[]){
ExemploBoxLayout box = new ExemploBoxLayout();
box.BoxLayoutTest();
box.setSize(300, 200);
box.setVisible(true);
box.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
}
}
67
1.3.5.5 CardLayout
Exemplo1:
package programas;
import java.awt.BorderLayout;
import java.awt.CardLayout;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JPanel;
public class Exemplo1CardLayout extends JFrame{
private int currentCard = 1;
private JPanel cardPanel;
private CardLayout cl;
public Exemplo1CardLayout() {
setTitle("Card Layout Example");
cardPanel = new JPanel();
cl = new CardLayout();
cardPanel.setLayout(cl);
JPanel p1 = new JPanel();
JPanel p2 = new JPanel();
JPanel p3 = new JPanel();
JPanel p4 = new JPanel();
JLabel lab1 = new JLabel("Card1");
JLabel lab2 = new JLabel("Card2");
JLabel lab3 = new JLabel("Card3");
JLabel lab4 = new JLabel("Card4");
p1.add(lab1);
p2.add(lab2);
p3.add(lab3);
p4.add(lab4);
cardPanel.add(p1, "1");
cardPanel.add(p2, "2");
cardPanel.add(p3, "3");
cardPanel.add(p4, "4");
JPanel buttonPanel = new JPanel();
JButton b1 = new JButton("Retornar");
JButton b2 = new JButton("Avançar");
buttonPanel.add(b1);
buttonPanel.add(b2);
b1.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent arg0) {
if (currentCard > 1) {
currentCard -= 1;
cl.show(cardPanel, "" + (currentCard));
}
}
} );
b2.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent arg0) {
if (currentCard < 4) {
currentCard += 1;
cl.show(cardPanel, "" + (currentCard));
68
}
}
});
getContentPane().add(cardPanel, BorderLayout.NORTH);
getContentPane().add(buttonPanel, BorderLayout.SOUTH);
}
public static void main(String[] args) {
Exemplo1CardLayout cl = new Exemplo1CardLayout();
cl.setSize(300, 150);
cl.setVisible(true);
cl.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
}
}
Exemplo2:
package programas;
import java.awt.BorderLayout;
import java.awt.CardLayout;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JPanel;
public class Exemplo2CardLayout extends JFrame {
private int currentCard = 1;
private JPanel cardPanel;
private CardLayout cl;
public Exemplo2CardLayout() {
setTitle("Card Layout Example");
setSize(400, 150);
cardPanel = new JPanel();
// getContentPane().add(cardPanel);
cl = new CardLayout();
cardPanel.setLayout(cl);
JPanel jp1 = new JPanel();
JPanel jp2 = new JPanel();
JPanel jp3 = new JPanel();
JPanel jp4 = new JPanel();
JLabel jl1 = new JLabel("Card1");
JLabel jl2 = new JLabel("Card2");
JLabel jl3 = new JLabel("Card3");
JLabel jl4 = new JLabel("Card4");
jp1.add(jl1);
jp2.add(jl2);
jp3.add(jl3);
jp4.add(jl4);
cardPanel.add(jp1, "1");
cardPanel.add(jp2, "2");
cardPanel.add(jp3, "3");
cardPanel.add(jp4, "4");
JPanel buttonPanel = new JPanel();
JButton firstBtn = new JButton("Primeiro");
JButton previousBtn = new JButton("Anterior");
JButton nextBtn = new JButton("Próximo");
JButton lastBtn = new JButton("Ultimo");
buttonPanel.add(firstBtn);
69
buttonPanel.add(nextBtn);
buttonPanel.add(previousBtn);
buttonPanel.add(lastBtn);
firstBtn.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent arg0) {
cl.first(cardPanel);
currentCard = 1;
}
});
lastBtn.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent arg0) {
cl.last(cardPanel);
currentCard = 4;
}
});
nextBtn.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent arg0) {
if (currentCard < 4) {
currentCard += 1;
cl.show(cardPanel, "" + (currentCard));
}
}
});
previousBtn.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent arg0) {
if (currentCard > 1) {
currentCard -= 1;
cl.show(cardPanel, "" + (currentCard));
}
}
});
getContentPane().add(cardPanel, BorderLayout.NORTH);
getContentPane().add(buttonPanel, BorderLayout.SOUTH);
}
public static void main(String[] args) {
Exemplo2CardLayout cl = new Exemplo2CardLayout();
cl.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
cl.setVisible(true);
}
}
Exemplo3:
package programas;
import java.awt.BorderLayout;
import java.awt.Button;
import java.awt.CardLayout;
import java.awt.Choice;
import java.awt.Color;
import java.awt.Frame;
import java.awt.Label;
import java.awt.Panel;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import javax.swing.JFrame;
public class Exemplo3CardLayout extends Frame {
70
private String[]paineis ={"first","second","third"};
int painelAtual = 0;
private Button proximo = new Button("próximo");
private Button anterior = new Button("anterior");
private CardLayout gerenciador = new CardLayout();
private Panel painelCentral = new Panel();
Exemplo3CardLayout() { // chamando o construtor da superclasse Frame
super("exemplo de CardLayout");
painelCentral.setLayout(gerenciador);
}
public void executa() {
Panel painel1 = new Panel();
Label textoDoPainel1 = new Label("PAINEL 1",Label.CENTER);
painel1.setBackground(new Color(0, 200, 148));
painel1.add(textoDoPainel1);
Panel painel2 = new Panel();
Label textoDoPainel2 = new Label("PAINEL 2",Label.CENTER);
painel2.setBackground(Color.blue);
painel2.add(textoDoPainel2);
painel2.add(new Button("outro componente"));
painel2.add(textoDoPainel2);
Panel painel3 =new Panel();
Label textoDoPainel3 = new Label("PAINEL 3",Label.CENTER);
painel3.setBackground(Color.green);
painel3.add(textoDoPainel3);
painel3.add(new Choice());
painelCentral.add(painel1,"first");
painelCentral.add(painel2,"second");
painelCentral.add(painel3,"third");
Panel controles =new Panel();
controles.add(anterior);
controles.add(proximo);
setLayout(new BorderLayout());
add(painelCentral,BorderLayout.CENTER);
add(controles,BorderLayout.SOUTH);
proximo.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent evento) {
mostrarProximoPainel();
}
} );
anterior.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent evento) {
mostrarPainelAnterior();
}
} );
}
public void mostrarProximoPainel() {
if(painelAtual< 2) {
painelAtual++;gerenciador.show(painelCentral,
paineis[painelAtual]);
}
}
71
public void mostrarPainelAnterior() {
if(painelAtual>0) {
painelAtual--;gerenciador.show(painelCentral,
paineis[painelAtual]);
}
}
static public void main(String[]args){
Exemplo3CardLayout x = new Exemplo3CardLayout();
x.executa();
x.setSize(300, 275);
x.setVisible(true);
// x.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
}
}
1.3.5.6 GridBagLayout
GridBagLayout é um gerenciador de layout que define os componentes de um container em uma
grade de células com cada componente ocupar uma ou mais células, chamado de sua área de
exibição. A área de exibição alinha componentes vertical e horizontalmente, sem exigir que os
componentes ser do mesmo tamanho.
1.3.5.7 SpringLayout
1.3.6. JTextField
Compreende a área de uma única linha que suporta a inserção ou exibição de texto. Podemos
definir se o texto pode ser manipulado com o método setEditable(boolean), utilizando no
argumento o valor true.
Quando o usuário digita os dados em uma JTexField e pressiona Enter, ocorre um evento de
ação. Esse evento é processado pelo ouvinte de evento registrado que pode usar os dados que
estão no JTexField no momento em que o evento ocorre. O exemplo2 implementa diversos
campos de texto com um evento associado a cada um deles.
JTextField permite a edição de uma única linha de texto. Novos recursos incluem a capacidade
de justificar o texto à esquerda, direita, centro ou, e para definir a fonte do texto.
Um textfield é como um label, só que pode ser editado e modificado pelo usuário.
Textfields são usados geralmente para entrada de dados pelo usuário.
Métodos interessantes:
o public JTextField(int columns): Cria um novo textfield com uma largura, em
caracteres, dada pelo parâmetro.
o public String getText(): Retorna o texto atualmente armazenado no campo.
o public void setText(String text): Modifica o texto do campo para ser igual à
string dada como parâmetro.
72
Exemplo1:
package Exemplos;
import java.awt.FlowLayout;
import java.awt.GridLayout;
import javax.swing.*;
public class Exemplo1TextField extends JFrame{
private JPanel painel;
private JLabel lblNome;
private JLabel lblEndereco;
private JTextField txtNome;
private JTextField txtEndereco;
private JButton btnCadastro;
private GridLayout gridLayout;
public Exemplo1TextField() {
super.setTitle("Formulário para cadastro de Pessoa");
}
public void init(){
painel = new JPanel();
setLayout(new FlowLayout(FlowLayout.LEFT));
gridLayout = new GridLayout(3, 2, 10, 10);
painel.setLayout(gridLayout);
lblNome = new JLabel("Informe Nome:");
txtNome = new JTextField(15);
painel.add(lblNome);
painel.add(txtNome);
lblEndereco = new JLabel("Informe Endereço:");
txtEndereco = new JTextField(15);
painel.add(lblEndereco);
painel.add(txtEndereco);
btnCadastro = new JButton("Enviar Dados");
painel.add(btnCadastro);
super.add(painel);//Adiciono o painel ao JFrame
}
public static void main(String[] args) {
73
Exemplo1TextField tela = new Exemplo1TextField();
tela.init(); //Inicializa a criação do JFrame
tela.setSize(400, 200); //Define Largura e Altura
tela.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
tela.setVisible(true); //Exibir o JFrame
}
}
74
1.3.6.1 Exercícios
01 – De acordo com exemplo1 do item 1.3.6, alterar o layout do formulário para o modelo
abaixo, usuando os recursos do Java Swing.
Antes:
Depois:
02 – De acordo com a figura abaixo, faça um programa usando recursos do Java Swing para
formatar o formulário abaixo.
75
03 – Alterar o programa anterior (02) e acrescentar o Curso e a Disciplina do aluno.
04 – De acordo com a figura abaixo, faça um programa usando recursos do Java Swing para
formatar o formulário a baixo.
76
05 – De acordo com a figura anterior (exercício 04), faça um programa usando recursos do Java
Swing para modificar e formatar o formulário a baixo.
06 – De acordo com a figura, faça um programa usando recursos do Java Swing para formatar o
formulário a baixo.
77
1.3.7 Listas (JComboBox)
JComboBox é como uma caixa suspensa . Você pode clicar em uma seta drop-down e selecionar
uma opção da lista. Por exemplo, quando o componente tem o foco, pressionando uma tecla que
corresponde ao primeiro caractere no nome de alguma entrada de seleciona essa entrada. A barra
de rolagem vertical é usada para listas mais longas.
Exemplo1:
package Exemplos; import java.awt.FlowLayout; import java.awt.GridLayout; import javax.swing.*; public class Exemplo1JComboBox extends JFrame{ public Exemplo1JComboBox() { super.setTitle("Formulário para cadastro de Pessoa"); } public void init(){ JPanel painel = new JPanel(); //Definir o conteúdo que será adicionado ao JFrame setLayout(new FlowLayout(FlowLayout.LEFT)); GridLayout layout = new GridLayout(5, 2, 10, 10); painel.setLayout(layout); JLabel lblCpf = new JLabel("Informe Cpf:"); JTextField txtCpf = new JTextField(15); painel.add(lblCpf); painel.add(txtCpf); JLabel lblNome = new JLabel("Informe Nome:"); JTextField txtNome = new JTextField(15); painel.add(lblNome); painel.add(txtNome); JLabel lblEndereco = new JLabel("Informe Endereço:");
78
JTextField txtEndereco = new JTextField(15); painel.add(lblEndereco); painel.add(txtEndereco); JLabel lblEstadoCivil = new JLabel("Estado civil:"); painel.add(lblEstadoCivil); //Vetor de String para alimentar o campo ComboBox String[] opcoes = new String[] { "Solteiro", "Casado", "Separado", "Desquitado", "Viuvo"}; JComboBox cmbEstadoCivil = new JComboBox(opcoes); painel.add(cmbEstadoCivil); JButton btnCadastro = new JButton("Enviar Dados"); painel.add(btnCadastro); super.add(painel);//Adiciono o panel ao JFrame } public static void main(String[] args) { Exemplo1JComboBox tela = new Exemplo1JComboBox(); tela.init(); //Inicializa a criação do JFrame tela.setSize(400, 250); //Define Largura e Altura tela.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); tela.setVisible(true); //Exibir o JFrame } }
1.3.8. Eventos de Botões
A interface ActionListener especifica o método actionPerformed() para tratar eventos do tipo
ação. Um objeto de uma classe que implemente essa interface deve ser associado a um
componente através do método addActionListener(), que é definido para componentes do
tipo botão, lista e campo de texto. Neste item veremos o evento associado a um botão.
Quando um evento desse tipo ocorre, o objeto registrado é notificado. O
método actionPerformed() é então invocado, recebendo como argumento o objeto que representa
o evento.
interface ActionListener
método actionPerformed()
botao.addActionListener(new NomeDaClasse());//Adicionado o evento ao botao
private class NomeDaClasse implements ActionListener{
@Override
public void actionPerformed(ActionEvent e) {
instruçoes........
}
}
79
Exemplo1:
package Exemplos; import java.awt.FlowLayout; import java.awt.GridLayout; import java.awt.event.ActionEvent; import java.awt.event.ActionListener; import javax.swing.JButton; import javax.swing.JFrame; import javax.swing.JLabel; import javax.swing.JOptionPane; import javax.swing.JPanel; import javax.swing.JTextField; public class Exemplo1AcaoBotao extends JFrame{ private JPanel painel; private JLabel nome; private JLabel matricula; private JLabel media; private JTextField txtNome; private JTextField txtMatricula; private JTextField txtMedia; private JButton botao; private GridLayout layout; public Exemplo1AcaoBotao(){ super("Testando ActionListener"); } public void executa(){ painel = new JPanel(); setLayout(new FlowLayout()); layout = new GridLayout(5,2,10,10); painel.setLayout(layout); nome = new JLabel("Digite o nome: "); matricula = new JLabel("Digite a matricula: "); media = new JLabel("Digite a media: "); txtNome = new JTextField(10); txtMatricula = new JTextField(10);
80
txtMedia = new JTextField(10); botao = new JButton("Imprimir Dados"); painel.add(nome); painel.add(txtNome); painel.add(matricula); painel.add(txtMatricula); painel.add(media); painel.add(txtMedia); painel.add(botao); add(painel); botao.addActionListener(new ImprimeDados()); } private class ImprimeDados implements ActionListener{ int matricula; float media; public void actionPerformed(ActionEvent event) { matricula = Integer.parseInt(txtMatricula.getText()); media = Float.parseFloat(txtMedia.getText()); JOptionPane.showMessageDialog(null, "Nome: " + txtNome.getText() + "\nMatricula: " + matricula + "\nMedia: " + media); } } public static void main(String[] args) { Exemplo1AcaoBotao teste = new Exemplo1AcaoBotao(); teste.executa(); teste.setVisible(true); teste.setSize(500,300); teste.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); } }
Exemplo2:
package Exemplos; import java.awt.event.ActionEvent; import javax.swing.*; import java.awt.FlowLayout; import java.awt.GridLayout; import java.awt.event.ActionListener; public class Exemplo2AcaoBotao extends JFrame{ private JPanel painel; private JLabel numero1; private JLabel numero2;
81
private JTextField txtNumero1; private JTextField txtNumero2; private JButton botao; private GridLayout layout; public Exemplo2AcaoBotao() { super("Testando ActionListener"); } public void inicializa(){ setLayout(new FlowLayout(FlowLayout.LEFT)); layout = new GridLayout(3, 2, 5, 5); painel = new JPanel(); numero1 = new JLabel("Digite um numero: "); numero2 = new JLabel("Digite um numero: "); botao = new JButton("Soma"); txtNumero1 = new JTextField(10); txtNumero2 = new JTextField(10); painel.add(numero1); painel.add(txtNumero1); painel.add(numero2); painel.add(txtNumero2); painel.add(botao); botao.addActionListener(new calcula()); painel.setLayout(layout); super.add(painel); } private class calcula implements ActionListener{ public void actionPerformed(ActionEvent e) { float n1, n2, soma; n1 = Float.parseFloat(txtNumero1.getText()); n2 = Float.parseFloat(txtNumero2.getText()); soma = n1 + n2; JOptionPane.showMessageDialog(null,"Soma dos numeros: " + soma); } } public static void main(String[] args){ Exemplo2AcaoBotao teste = new Exemplo2AcaoBotao(); teste.inicializa(); teste.setSize(300,200); teste.setVisible(true); } }
82
Exemplo3:
package Exemplos; import java.awt.FlowLayout; import java.awt.GridLayout; import java.awt.event.ActionEvent; import java.awt.event.ActionListener; import javax.swing.*; public class Exemplo3AcaoBotao extends JFrame{ private JTextField txtCpf; private JTextField txtNome; private JTextField txtEndereco; private JComboBox cmbEstadoCivil; public Exemplo3AcaoBotao() { super.setTitle("Formulário para cadastro de Pessoa"); } public void init(){ JPanel painel = new JPanel(); //Definir o conteúdo que será adicionado ao JFrame setLayout(new FlowLayout(FlowLayout.LEFT)); GridLayout layout = new GridLayout(5, 2, 10, 10); painel.setLayout(layout); JLabel lblCpf = new JLabel("Informe Cpf:"); txtCpf = new JTextField(15); painel.add(lblCpf); painel.add(txtCpf); JLabel lblNome = new JLabel("Informe Nome:"); txtNome = new JTextField(15); painel.add(lblNome); painel.add(txtNome); JLabel lblEndereco = new JLabel("Informe Endereço:"); txtEndereco = new JTextField(15); painel.add(lblEndereco); painel.add(txtEndereco); JLabel lblEstadoCivil = new JLabel("Estado civil:"); painel.add(lblEstadoCivil); //Vetor de String para alimentar o campo ComboBox String[] opcoes = new String[] { "Solteiro", "Casado", "Separado", "Desquitado", "Viuvo"}; cmbEstadoCivil = new JComboBox(opcoes); painel.add(cmbEstadoCivil); JButton btnCadastro = new JButton("Imprimir Dados");
83
painel.add(btnCadastro); btnCadastro.addActionListener(new ImprimeDados()); super.add(painel);//Adiciono o panel ao JFrame } public class ImprimeDados implements ActionListener{ @Override public void actionPerformed(ActionEvent e) { JOptionPane.showMessageDialog(null, "Cpf: " + txtCpf.getText() + "\nNome: " + txtNome.getText() + "\nEndereço: " + txtEndereco.getText() + "\nEstado Civil: " + cmbEstadoCivil.getSelectedItem()); } } public static void main(String[] args) { Exemplo3AcaoBotao tela = new Exemplo3AcaoBotao(); tela.init(); //Inicializa a criação do JFrame tela.setSize(400, 250); //Define Largura e Altura tela.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); tela.setVisible(true); //Exibir o JFrame } }
84
1.3.8.1 Exercícios
01 – De acordo com o formulário abaixo, imprimir os dado digitados usando o botão de evento
do Java Swing.
02 – De acordo com a figura abaixo, faça um programa usando recursos do Java Swing para
formatar o formulário e calcular a média das duas notas. Uma caixa de diálogo deverá mostrar a
média calculada.
85
03 – De acordo com a figura abaixo, faça um programa usando recursos do Java Swing para
formatar o formulário a baixo e informar o valor do salário líquido (salario + gratificação –
faltas).
04 – De acordo com a figura anterior (exercício 03), faça um programa usando recursos do Java
Swing para formatar o formulário a baixo. Ao final mostrar o valor do contracheque.
valorContraCheque = salario + gratificação + abono + horaExtra + férias + salarioFamilia –
faltas – atrasos – inss - impostoRenda
86
05 – De acordo com a figura, faça um programa usando recursos do Java Swing para formatar o
formulário a baixo. Ao final informar o valor das compras.
87
06 – De acordo com a figura, faça um programa usando recursos do Java Swing para formatar o
formulário a baixo. Ao final imprimir os dados digitados.
07 – De acordo com a figura, faça um programa usando recursos do Java Swing para formatar o
formulário a baixo. Ao final imprimir os dados digitados.
