UNIVERSIDADE ESTÁCIO DE SÁ SISTEMAS DE INFORMAÇÃO
RESUMO PROGRAMAÇÃO ORIENTADA A OBJETOS - JAVA
Prof. Fernando André da Silva
1º Semestre/2012 Semestre/2012
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 EPETIÇÃO .......................... CONTROLE DE FLUXO – ESTRUTURAS DE SELEÇÃO E R EPETIÇÃO .......................... 20 E NCAPSULAMENTO .......................................... ................................................................ ............................................ ................................. ........... 24 SOBRECARGA DE MÉTODOS........................................... .................................................................. ......................................... .................. 27 I NTERFACES ......................................... ............................................................... ............................................. ............................................. ...................... 28 TRY-CATCH-FINALLY .......................................... ................................................................ ............................................ .............................. ........ 32 UNIDADE 1 – INTERFACES GRÁFICAS USANDO JFC/SWING ..................................................... 37
1.1 I NTRODUÇÃ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................................................................................................... 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................................................................................................... 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................................................................................................... Exercícios.................................... ................................................................... .... 84 1.3.7 Manipulação de Aspectos Visuais ............................... 1.3.8 Variação de Componentes Visuais.............................. 1.3.9 JTextArea ................................................................ .... 1.3.10 JPasswordField......................................................... 1.3.11 JTabbedPane.............................................................
Erro! rro! I ndicad ndicador or não de definido. fi nido. Erro! rro! I ndicad ndicador or não de definido. fi nido. Erro! rro! I ndicad ndicador or não de definido. fi nido. Erro! rro! I ndicad ndicador or não de definido. fi nido. Erro! rro! I ndicad ndicador or não de definido. fi nido.
LISTA 3 DE EXERCICIOS ...................................... ERRO! INDICADOR NÃO DEFINIDO. rro! I ndicad ndicador or não de definido. fi nido. 1.3.11 JInternalFrame ......................................................... Erro!
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. 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 EPETIÇÃO .......................... CONTROLE DE FLUXO – ESTRUTURAS DE SELEÇÃO E R EPETIÇÃO .......................... 20 E NCAPSULAMENTO .......................................... ................................................................ ............................................ ................................. ........... 24 SOBRECARGA DE MÉTODOS........................................... .................................................................. ......................................... .................. 27 I NTERFACES ......................................... ............................................................... ............................................. ............................................. ...................... 28 TRY-CATCH-FINALLY .......................................... ................................................................ ............................................ .............................. ........ 32 UNIDADE 1 – INTERFACES GRÁFICAS USANDO JFC/SWING ..................................................... 37
1.1 I NTRODUÇÃ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................................................................................................... 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................................................................................................... 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................................................................................................... Exercícios.................................... ................................................................... .... 84 1.3.7 Manipulação de Aspectos Visuais ............................... 1.3.8 Variação de Componentes Visuais.............................. 1.3.9 JTextArea ................................................................ .... 1.3.10 JPasswordField......................................................... 1.3.11 JTabbedPane.............................................................
Erro! rro! I ndicad ndicador or não de definido. fi nido. Erro! rro! I ndicad ndicador or não de definido. fi nido. Erro! rro! I ndicad ndicador or não de definido. fi nido. Erro! rro! I ndicad ndicador or não de definido. fi nido. Erro! rro! I ndicad ndicador or não de definido. fi nido.
LISTA 3 DE EXERCICIOS ...................................... ERRO! INDICADOR NÃO DEFINIDO. rro! I ndicad ndicador or não de definido. fi nido. 1.3.11 JInternalFrame ......................................................... Erro!
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. 2
2.2.1 Comuns ....................................................................... Erro! rro! I ndicad ndicador or não de definido. fi nido. rro! I ndicad ndicador or não de definido. fi nido. 2.2.2 Janelas ........................................................................ Erro! 2.2.3 Menus ............................................................ .............. Erro! rro! I ndicad ndicador or não de definido. fi nido.
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 ............................................................ .............. 2.2.5 Lista ............................................................................ 2.2.6 Combos ....................................................................... 2.2.7 Tabelas .......................................................... .............. 2.2.8 Teclas de Atalho .......................................................... 2.2.9 Frames Interno............................................................
Erro! rro! I ndicad ndicador or não de definido. fi nido. Erro! rro! I ndicad ndicador or não de definido. fi nido. Erro! rro! I ndicad ndicador or não de definido. fi nido. Erro! rro! I ndicad ndicador or não de definido. fi nido. Erro! rro! I ndicad ndicador or não de definido. fi nido. Erro! rro! I ndicad ndicador or não de definido. fi nido.
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.
3
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 dispositivos compatíveis, porém em 1994 ainda ainda era muito cedo 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: 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 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 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 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. 4
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. 5
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 ( J ava Micro Edition).
6
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 ( J ava Micro E dition) é 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 ( J ava 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 L imited 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/):
7
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:
8
[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. 9
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. 10
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ãoestá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 é cri ada 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
11
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.
12
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 Variáveis Constantes Nome de classes Nome de métodos/funções Atributos Atributos estáticos Nome de classes derivadas
Formato do nome nomeVariavel NOME_CONSTANTE NomeClasse nomeMetodo() nomeAtributo nomeAtributo 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 13
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 Java TM 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 se a construção:
class.
Para definir uma classe, utiliza-
[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. 14
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. 15
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.
16
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 é: onde
[modificador]
tipo
nome [ = default];
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. 17
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 boolean
Descrição 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. 18
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.
19
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 é representado pelo && e o “OU” é representado pelo ||.
“E”
e “OU”. O “E”
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. 20
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.
21
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. 22
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 .: " System.out.printf("\nNumero digitado: System.out.printf("\nValor digitado : System.out.printf("\nValor digitado : System.out.printf("\n");
+ " " "
"); "); "); ");
nome); + num1); + num2); + num3);
} }
23
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 next() nextInt() nextByte() nextLong() nextFloat() nextDouble()
Finalidade Aguarda uma entrada em formato String Aguarda uma entrada em formato Inteiro Aguarda uma entrada em formato Inteiro Aguarda uma entrada em formato Inteiro Longo Aguarda uma entrada em formato Número Fracionário 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
para o método que retorna o valor atual do atributo e 24
set 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 private private private private private
Pessoa{ String nome; String sobrenome; String dataNasc; String rg; String[] telefones;
public Pessoa(){ }
25
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. 26
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); public void metodoA(float x, float y); public void metodoA(int x, float y);
// 1-int,int // 2-float,float // 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.
27
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 num1 = a; num2 = b; System.out.print } public void imprime(int num1 = x; num2 = f; num3 = s; System.out.print } public void imprime(int num1 = m; num2 = n; num3 = o; num4 = p; System.out.print }
a, int b){ (num1 + " " + num2 ); x, int f, int s){
(num1 + " " + num2 + " " + num3 ); m, int n, int o, int p){
(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. 28
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 palavrachave 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); }
29
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. 30
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(); }
31
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. 32
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 hash 1. 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".
33
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());
34
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)
35
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");
} } }
36
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 fornecerlhes 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 compon entes 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 37
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 plataf orma, 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:
38
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;
39
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: java.lang.Object
java.awt.Component java.awt.Container javax.swing.JCompontent
JLabel
JComboBox
JList
JPanel
JSlider
JPopuMen u
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. 40
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. 41
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();
42
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. 43
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 . 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. A classe JComponent, que define os atributos e comportamentos para
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.
44
1.3 Modelos de Desenvolvimento Em Java, as classes nas quais nos baseamos para criar os componentes, bem como para fornecerlhes 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 JFrame
JPanel
JButton JLabel 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.
45
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
JOptionPane.QUESTION_MESSAGE - Impõe uma Pergunta mensagem que pergunta algo ao usuário JOptionPane.INFORMATION_MESSAGE - Exibe uma mensagem com informações que podem ser dispensadas. Informação JOptionPane.WARNING_MESSAGE – Indica Alerta mensagem de advertência sobre algum problema em potencial. JOptionPane.ERROR_MESSAGE - Indica mensagem Erro de erro ao usuário. Vazio (somente mensagem) JOptionPane.PLAIN_MESSAGE - Exibe um diálogo que simplesmente contém uma mensagem sem nenhum ícone
46
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; 47
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: 48
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 0 1 2
Nome da Constante YES_OPTION NO_OPTION CANCEL_OPTION
Equivale ao clicar no botão Yes (sim) ao clicar no botão No (não) 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!");
49
} } }
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, , , , , <ícone>, , ).
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);
50
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 “pai”: JOptionPane.showMessageDialog comos seguintes argumentos:Componente 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: 51
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 (). 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;
52
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); } }
53
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. 54
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.
55
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 56
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 e setMinimumSize(Dimension) 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:
57
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. 58
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 especificase 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 autoelucidativos.
Exemplo1:
59
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;
60
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 }
61
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"); }
62
public void BorderLayoutTest(){ botao1 botao2 botao3 botao4 botao5
= new JButton("Botão Norte"); = new JButton("Botão Centro"); = new JButton("Botão Oeste"); = new JButton("Botão Sul"); = new JButton("Botão Leste");
add(botao1, add(botao2, add(botao3, add(botao4, add(botao5,
BorderLayout.NORTH ); BorderLayout.CENTER ); BorderLayout.WEST ); BorderLayout.SOUTH ); 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();
63
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:
64
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 constantes X_AXIS ou Y_AXIS.
da
classe,
através
respectivamente
das
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 .
65
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 JButton JButton JButton JButton
botao1 botao2 botao3 botao4 botao5
= = = = =
new new new new new
JButton("Botão JButton("Botão JButton("Botão JButton("Botão JButton("Botão
1"); 2"); 3"); 4"); 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); } }
66
1.3.5.5 CardLayout Exemplo1: package programas; import import import import import import import import
java.awt.BorderLayout; java.awt.CardLayout; java.awt.event.ActionEvent; java.awt.event.ActionListener; javax.swing.JButton; javax.swing.JFrame; javax.swing.JLabel; 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));
67
} } }); 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);
68
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 import import import import import import import import import import
java.awt.BorderLayout; java.awt.Button; java.awt.CardLayout; java.awt.Choice; java.awt.Color; java.awt.Frame; java.awt.Label; java.awt.Panel; java.awt.event.ActionEvent; java.awt.event.ActionListener; javax.swing.JFrame;
public class Exemplo3CardLayout extends Frame {
69
private String[]paineis ={"first","second","third"}; int painelAtual = 0; private private private private
Button proximo = new Button("próximo"); Button anterior = new Button("anterior"); CardLayout gerenciador = new CardLayout(); 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]); } }
70
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.
71
Exemplo1:
package Exemplos; import java.awt.FlowLayout; import java.awt.GridLayout; import javax.swing.*; public class Exemplo1TextField extends JFrame{ private private private private private private private
JPanel painel; JLabel lblNome; JLabel lblEndereco; JTextField txtNome; JTextField txtEndereco; JButton btnCadastro; 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) {
72
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 } }
73
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.
74
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.
75
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.
76
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:");
77
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........ } }
78
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);
79
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;
80
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); } }
81
Exemplo3:
package Exemplos; import import import import import
java.awt.FlowLayout; java.awt.GridLayout; java.awt.event.ActionEvent; java.awt.event.ActionListener; javax.swing.*;
public class Exemplo3AcaoBotao extends JFrame{ private JTextField txtCpf txtCpf; ; private JTextField txtNome 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 JLabel( "Informe Cpf:" ); txtCpf = new JTextField(15); painel.add(lblCpf); painel.add( txtCpf txtCpf); ); JLabel lblNome = new JLabel("Informe JLabel( "Informe Nome:" ); txtNome = new JTextField(15); painel.add(lblNome); painel.add( txtNome txtNome); ); JLabel lblEndereco = new JLabel("Informe JLabel( "Informe Endereço:" ); txtEndereco = new JTextField(15); painel.add(lblEndereco); painel.add( txtEndereco ); JLabel lblEstadoCivil = new JLabel("Estado JLabel( "Estado civil:" ); painel.add(lblEstadoCivil); //Vetor de String para alimentar o campo ComboBox String[] opcoes = new String[] { "Solteiro" , "Casado" , "Separado" , "Desquitado" , "Viuvo"}; "Viuvo" }; cmbEstadoCivil = new JComboBox(opcoes); painel.add( cmbEstadoCivil ); JButton btnCadastro = new JButton("Imprimir JButton( "Imprimir Dados" );
82
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 txtCpf.getText() .getText() + "\nNome: " + txtNome txtNome.getText() .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 } }
83
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.
84
03 – De acordo com a figura abaixo, faça um programa usando recursos do Java Swing para formatar o formulário formulário a baixo e informar o valor do salário 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
85
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.
86
