Você está na página 1de 87

UNIVERSIDADE ESTCIO DE S

SISTEMAS DE INFORMAO

RESUMO PROGRAMAO ORIENTADA A OBJETOS - JAVA

Prof. Fernando Andr da Silva

1 Semestre/2012

INDICE
INTRODUO LINGUAGEM JAVA ................................................................................................... 4

BREVE HISTRIA DO JAVA........................................................................................ 4 VANTAGENS DA LINGUAGEM JAVA .......................................................................... 4 PROGRAMAO ORIENTADA A OBJETOS .................................................................. 8 CLASSE ..................................................................................................................... 8 CONSTRUTORES ...................................................................................................... 15 MTODOS ............................................................................................................... 17 CONTROLE DE FLUXO ESTRUTURAS DE SELEO E REPETIO .......................... 20 ENCAPSULAMENTO ................................................................................................. 24 SOBRECARGA DE MTODOS .................................................................................... 27 INTERFACES ............................................................................................................ 28 TRY-CATCH-FINALLY .............................................................................................. 32
UNIDADE 1 INTERFACES GRFICAS USANDO JFC/SWING ..................................................... 37

1.1 INTRODUO .................................................................................................... 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 Exerccios....................................................................................................... 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 Exerccios....................................................................................................... 74 1.3.7 Listas (JComboBox) ................................................................................................. 77 1.3.8. Eventos de Botes ................................................................................................... 78 Exemplo3: .................................................................................................................. 82 1.3.8.1 Exerccios....................................................................................................... 84 1.3.7 Manipulao de Aspectos Visuais ............................... Erro! Indicador no definido. 1.3.8 Variao de Componentes Visuais.............................. Erro! Indicador no definido. 1.3.9 JTextArea .................................................................... Erro! Indicador no definido. 1.3.10 JPasswordField......................................................... Erro! Indicador no definido. 1.3.11 JTabbedPane............................................................. Erro! Indicador no definido. LISTA 3 DE EXERCICIOS ...................................... ERRO! INDICADOR NO DEFINIDO. 1.3.11 JInternalFrame ......................................................... Erro! Indicador no definido. UNIDADE 2 TRATAMENTO DE EVENTOS......................... ERRO! INDICADOR NO DEFINIDO.

2.1 DELEGAR TRATAMENTO DE EVENTOS .......... ERRO! INDICADOR NO DEFINIDO. 2.2 MANIPULAO DE EVENTOS ......................... ERRO! INDICADOR NO DEFINIDO. 2

2.2.1 Comuns ....................................................................... Erro! Indicador no definido. 2.2.2 Janelas ........................................................................ Erro! Indicador no definido. 2.2.3 Menus .......................................................................... Erro! Indicador no definido. 2.2.3.1 JButton ............................................................ Erro! Indicador no definido. 2.2.3.2 JRadioButton .................................................. Erro! Indicador no definido. 2.2.3.3 JCheckBox ...................................................... Erro! Indicador no definido. 2.2.3.4 JComboBox .................................................... Erro! Indicador no definido. 2.2.3.5 JMenuBar ........................................................ Erro! Indicador no definido. 2.2.3.6 JMenuItem ...................................................... Erro! Indicador no definido. 2.2.3.7 JPopupMenu ................................................... Erro! Indicador no definido. 2.2.4 Textos .......................................................................... Erro! Indicador no definido. 2.2.5 Lista ............................................................................ Erro! Indicador no definido. 2.2.6 Combos ....................................................................... Erro! Indicador no definido. 2.2.7 Tabelas ........................................................................ Erro! Indicador no definido. 2.2.8 Teclas de Atalho .......................................................... Erro! Indicador no definido. 2.2.9 Frames Interno............................................................ Erro! Indicador no definido. UNIDADE 3 - THREADS ............................................................. ERRO! INDICADOR NO DEFINIDO.

3.1 THREADS ...................................................... ERRO! INDICADOR NO DEFINIDO. 3.2 CRIAO DE THREADS .................................. ERRO! INDICADOR NO DEFINIDO. 3.3 MANIPULAO DE THREADS ........................ ERRO! INDICADOR NO DEFINIDO.
UNIDADE 4 - EXEMPLOS DO LIVRO ..................................... ERRO! INDICADOR NO DEFINIDO. ANEXO ........................................................................................... ERRO! INDICADOR NO DEFINIDO.

GABARITO EXERCCIOS ITEM 1.3.1.2 .................. ERRO! INDICADOR NO DEFINIDO. GABARITO EXERCCIOS ITEM 1.3.6.1 .................. ERRO! INDICADOR NO DEFINIDO. GABARITO EXERCCIOS ITEM 1.3.8.1 .................. ERRO! INDICADOR NO DEFINIDO.
PLANO DE AULA ......................................................................... ERRO! INDICADOR NO DEFINIDO.

1.4 EXERCCIOS.................................................. ERRO! INDICADOR NO DEFINIDO.

INTRODUO LINGUAGEM JAVA


Breve Histria do Java
A Sun criou um time (conhecido como Green Team) para desenvolver inovaes tecnolgicas em 1992. Esse time foi liderado por James Gosling, considerado o pai do Java. O time voltou com a idia de criar um interpretador (j era uma mquina virtual, veremos o que isso mais a frente) para pequenos dispositivos, facilitando a reescrita de software para aparelhos eletrnicos, como vdeo cassete, televiso e aparelhos de TV a cabo. A idia no deu certo. Tentaram fechar diversos contratos com grandes fabricantes de eletrnicos, como Panasonic e outras, mas no houve xito devido ao conflito de interesses. Hoje, sabemos que o Java domina o mercado de aplicaes para celulares com mais de 2.5 bilhes de dispositivos compatveis, porm em 1994 ainda era muito cedo para isso. Com o advento da web, a Sun percebeu que poderia utilizar a idia criada em 1992 para rodar pequenas aplicaes dentro do browser. A semelhana 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 lanado: focado em transformar o browser de apenas um cliente fino (thin client ou terminal burro) para uma aplicao que possa tambm realizar operaes, no apenas renderizar html. Atualmente os applets realmente no so o foco da Sun. curioso notar que a tecnologia Java nasceu com um objetivo em mente, foi lanado com outro, mas, no final, decolou mesmo no desenvolvimento de aplicaes do lado do servidor. Sorte? Voc pode ler a histria 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 negcios com tecnologias Java. No Brasil, diversos grupos de usurios se juntaram para tentar disseminar o conhecimento da linguagem. Um deles o GUJ (http://www.guj.com.br), uma comunidade virtual com artigos, tutoriais e frum para tirar dvidas, o maior em lngua portuguesa. Encorajamos todos os alunos a usar muito os fruns do mesmo, pois uma das melhores maneiras para achar solues para pequenos problemas que acontecem com grande freqncia.

Vantagens da Linguagem Java


Quando a linguagem Java foi criada, a equipe de desenvolvimento tinha como principal objetivo fazer do Java uma linguagem melhor do que as ja existentes no mercado. Baseando-se nas linguagens C/C++, a equipe de Gosling pensou em algo robusto, portvel, seguro, com cdigo limpo e fcil 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 no 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 Independncia 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 no 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 mquinas virtuais diferentes, ou seja, para tornar a linguagem multiplataforma, a Sun desenvolveu no s JVM's para sistemas Operacionais diferentes, como J2SDK's diferentes tambm, 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 no usa explicitamente ponteiros Nem todos acham essa uma vantagem, mas s quem trabalhou com linguagens que tem ponteiros que manipulam endereo de memria diretamente sabem o trabalho que d. Pensando nisso, os desenvolvedores da linguagem java, eliminaram a manipulao direta de ponteiros. O que ocorre o apontamento para um endereo de memria, ou seja, quando voc cria um objeto, voc est apontando em qual endereo de memria esse objeto ficar alocado. No implementa herana mltipla No exatamente uma vantagem mas facilita o trabalho do programador. A nica forma de fazer herana multipla, de forma indireta, quando uma classe herda uma outra classe e implementa interface (classe que contm apenas declarao dos mtodos). Possui "Coleta de Lixo" automtica. Isso significa que ela desaloca automaticamente qualquer espao de memria no utilizado sem que o programador se preocupe com isso. Robustez Os recursos da linguagem e do ambiente para o tempo de execuo garantem que o cdigo no derrube o sistema de algum que "tropece" em uma home page contendo uma animao. Orientao a Objetos Java uma linguagem totalmente orientada a objetos, o que permite a herana e a reutilizao de cdigos de forma dinmica e esttica. 5

Alto Desempenho A linguagem Java suporta vrios recursos de alto desempenho, como multithreading, compilao just-in-time e utilizao de cdigo nativo. O byte-code do Java possui um desempenho aproximadamente 20 vezes inferior que o de um cdigo nativo do processador (ou linguagem de mquina), mas que em comparao com linguagens Script, como o HTML, o JavaScript ou o VBScript, ou at mesmo o prprio byte-code do VB (Visual Basic), possui uma performance muitas vezes superior. Esta performance, pela quantidade de esforos aplicados sobre a sua otimizao pelos desenvolvedores de Java, est cada vez mais sendo aumentada, podendo um dia comparar-se com uma linguagem compilada para o processador em especfico (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. Alm disso, o ambiente retira do programador a responsabilidade de gerenciar a memria e os ponteiros. Alm dessas vantagens, a linguagem Java est agora incorporando suporte a operaes em Banco de Dados. O JDBC, que uma biblioteca de classes para acesso a banco de dados, permite uma conexo remota a servidores SQL que possuam driver OBDC ou compatvel. Transaes no estilo de Compras, Vendas, Cadastramentos, Alterao de dados pessoais controlada por senha via Internet, so exemplos do que o JDBC permite que seja realizado. Desvantagens da Linguagem Apesar disso, a linguagem tambm possui as seguintes desvantagens:

Performance reduzida: por ser uma linguagem no projetada para gerar cdigo nativo para cada arquitetura, os programas em Java costumam ter um desempenho menor que os escritos em linguagens como C++. Eles tambm costumam ocupar mais espao em memria. 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 clculo com nmeros em ponto flutuante tendem a possuir baixo desempenho.

A Linguagem Java uma linguagem de prograo que permite o desenvolvimento de aplicaes para uma srie de plataformas. possvel ter software Java desde de dispositivos pequenos, como telefones celulares, at computadores de grande porte, como os mainframes, por exemplo. Devido a essa caracterstica, a linguagem Java conta com trs conhecidos ambientes de desenvolvimento: JSE ou J2SE (Java Standard Edition); JEE ou J2EE (Java Enterprise Edition); JME ou J2ME (Java Micro Edition).

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 aplicaes. Alm 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 tambm que esses ambientes de desenvolvimento so verses aprimoradas do JSE para as aplicaes a que se propem. 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 contm bibliotecas especialmente desenvolvidas para o acesso a servidores, a sistemas de e-mail, a banco de dados, etc. Por essas caractersticas, o JEE foi desenvolvido para suportar uma grande quantidade de usurios simultneos. JME O JME (Java Micro Edition) o ambiente de desenvolvimento para dispositivos mveis ou portteis, como telefones celulares e palmtops. Como a linguagem Java j era conhecida e a adaptao ao JME no complicada, logo surgiram diversos tipos de aplicativos para tais dispositivos, como jogos e agendas eletrnicas. As empresas saram ganhando com isso porque, desde que seus dispositivos tenham uma JVM (Java Virtual Machine - Mquina Virtual Java), possvel, com poucas modificaes, implementar os aplicativos em qualquer aparelho, sendo o nico limite a capacidade do hardware. A plataforma JME contm configuraes e bibliotecas trabalhadas especialmente para a atuao em dispositivos portteis. Assim, o desenvolvedor tem maior facilidade para lidar com as limitaes de processamento e memria, por exemplo. Um exemplo disso a configurao chamada CLDC (Connected Limited Device Configuration), destinada a dispositivos com recursos de hardware bastante limitados, como processadores de 16 bits e memrias com 512 KB de capacidade. Essa configurao contm uma JVM e um conjunto bsico de bibliotecas que permite o funcionamento da aplicao Java em dispositivos com tais caractersticas. A imagem a seguir mostra um jogo em Java que roda em dois dispositivos mveis diferentes (tirada do site http://www.msmobile.com/):

Finalizando A tecnologia Java bastante abrangente e permite o desenvolvimento de solues para uma infinidade de aplicaes. So tantos recursos, que at mesmo desenvolvedores experientes podem se confundir em um determinado momento. Felizmente, a comunidade Java organizada e no difcil encontrar auxlio em sites ou fruns especializados. Caso queira mais informaes sobre Java, visite o site oficial: java.sun.com.

Programao Orientada a Objetos


A programao orientada a objeto no somente uma nova forma de programar uma nova forma de pensar um problema, de forma abstrata, utilizando conceitos do mundo real e no conceitos computacionais. Os conceitos de objetos devem acompanhar todo o ciclo de desenvolvimento de um software. A programao orientada a objeto tambm inclui uma nova notao e exige por parte do analista/programador o conhecimento desta notao (diagramas). Conceitos fundamentais em POO Classe Objeto Atributos Mtodos Sobrecarga Herana Simples Herana mltipla Encapsulamento Polimorfismo

Classe
Para a Programao Orientada a Objetos (POO), uma classe um conjunto de cdigos de programao, que incluem a definio dos atributos e dos mtodos necessrios para a criao de um ou mais objetos. A classe contm toda a descrio da forma do objeto, um molde para criao de objetos, uma matriz geradora de objetos, uma fbrica de objetos. Uma classe a unidade de encapsulamento dos atributos e dos mtodos. Dentro da classe que declaramos os atributos, os mtodos e seus controles de acesso. Vamos ver o prottipo para declarar e definir uma classe. Definio de classes em Java A forma geral da declarao de uma classe a seguinte:

[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 A instruo public indica que a classe, mtodo ou varivel assim declarada possa ser acessada em qualquer lugar e a qualquer momento da execuo do programa. Private O modificador de acesso "private" quando aplicado a um atributo ou a um mtodo 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 atravs dos mtodos pblicos da prpria superclasse, caso contrrio, no haver acesso a estes atributos. O modificador de acesso private deixa o atributo visvel apenas para a classe em que o mesmo se encontra. Protected Deixa o atributo visvel 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 ? No pensem que a palavra-chave static define que uma varivel no possa mudar de valor. O uso da palavra-chave static confundido por muitos programadores, at por alguns mais experientes. Quando uma varivel ou mtodo declarado static, estes so carregados na memria pela JVM. 9 Public; Private; Protected; Static; Abstract; Final.

Para acessar um mtodo static voc s pode faz-lo de duas maneiras, ou acessa de dentro de outro mtodo static ou cria uma instncia (sem ser static) e a partir da pode fazer o que quiser e de dentro de um mtodo no static voc pode acessar tanto um mtodo static como um no static de forma direta. No java, quando uma classe usada (seja por instncia ou diretamente nos membros estticos), suas vriaveis e seus mtodos estticos ganham um lugar na mmoria RAM do computador enquanto o programa executado. Mas, este lugar (ou endereo) usado pela classe, ou seja, todas as instncias dessa classe, quando utilizam esta varivel, esto na verdade utilizando a varivel da classe, e no do objeto. Assim, todas as instncias dessa classe tero o mesmo valor para aquela varivel esttica. Vejamos isso no cdigo! 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 sada:


Valor minha variavel: 3 Valor objeto a: 5 Valor objeto b: 5 Valor objeto c: 5 CONSTRUDO 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 mtodos e variveis estticos, da classe TestaStatic na memria. Isto acontece agora, porque a primeira utilizao da classe pelo programa. (A JVM s utiliza memria, quando realmente necessrio.) Instnciamos trs objetos a partir da classe TestaStatic. imprimimos o valor da varivel a partir do objeto a mudamos o valor da varivel para 5 a partir do objeto a imprimimos o valor da varial a partir do objeto b e c.

10

A sada foi 3 e depois 5 depois 5 Como pode isto a partir de objetos diferentes? Atribuimos o valor 3 para a varivel minhaVariavelStatic diretamente na classe TestaStatic, e quando imprimos pelo objeto a a invs da sada ser 0(zero), foi 3. E quando mudamos o valor da varivel esttica a partir do objeto a para 5, podemos perceber que essa mudana esta presente tambm no objeto b e c, porque quando imprimos a sada foi 5, 5 e 5. Isto acontece porque variveis estticas possuem somente um nico valor para todas as instncias de sua classe. A varivel esttica pertence a Classe e no a instncia(ou objeto). Ao contrrio de membros noestticos que s podem ser acessados a partir de uma instncia. Pois seus valores so individuais para cada objeto. Vantagem no uso desse modificador static alguns programadores no tem essa percepo. Mas muito til quando se necessita compartilhar uma informao entre todos os objetos de determinada classe, como alguma contagem ou totalizao, at mesmo o ponteiro de uma conexo com um banco de dados. Outra utilidade para static pode utilizar as coisas de forma direta sem precisar criar instncias. Uma classe ou mtodo static no tem o seu contedo zerado toda vez que criada uma nova instncia. Por isto que o mtodo executvel do java, o mtodo main, esttico:
public static void main(String args[]){}

A JVM no poderia saber por onde comera a execuo do programa sem um mtodo que possa ser acessado diretamente, sem precisar de uma instncia. J pensou se a JVM tivesse que instanciar classe a classe at achar o mtodo main, iria ficar muito lento, alm do uso da mmoria. E se eu tiver dois mtodos public e static? A JVM entende que o mtodo main (escrito e minusculas) o mtodo de inicializao do programa, assim voc pode ter outros mtodos estticos em suas classes, sem nenhum problema. Isto padro da JVM. Existem tambm os blocos de cdigo static que so executados assim que a classe que o contenha usada, antes mesmo do mtodo main, se a classe o tiver.
package Programas; public class Inicio { static { System.out.println("Executou o bloco esttico!"); } public static void main(String[] args) { System.out.println("Executou o mtodo main"); } }

A execuo dessa classe gerar a sada:


Executou o bloco esttico! Executou o mtodo main

11

Quando a JVM procura logo os atributos, mtodos e blocos de cdigos estticos antes mesmo da main ser executada. Porque j pensou se o mtodo main for usar um membro esttico que no estiver carregado na memria? Seria um erro. Para que servem esses blocos de cdigo static? Os blocos de cdigos estticos so como um construtor de uma classe, servem quando se precisa inicializar, tratar ou pesquisar os valores de variaveis estticas, as nicas que podem ser acessadas neste instante, antes mesmo do mtodo main ou o mtodo construtor possa ser executado. praticamente um mtodo construtor sem nome, sem argumentos (parmetros) e nenhum tipo de retorno. Ele sem nome porque no h necessidade de se referir a ele. Serve somente para trabalhar com os membros estticos da classe antes de seu construtor ou do mtodo main (caso seja a classe executvel).
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 cdigo estticos, podemos tratar as variveis estticas antes de qualquer coisa. Abstract Classes abstratas so aquelas que contm ao menos um mtodo incompleto. Desse modo uma classe abstrata no pode ser instanciada, mas pode ser derivada. Neste caso, a subclasse deve prover o corpo do mtodo 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 especficas sejam introduzidas por subclasses. Final Uma classe final pode ser instanciada, mas no pode ser derivada, isto , no pode ser superclasse de nenhuma subclasse. Algumas classes predefinidas no ambiente Java tm esta propriedade. A palavra reservada final impede que o mtodo seja sobreposto em uma subclasse isso , ele pode ser herdado porm no pode ser sobrescrito. O que podemos dizer que quando criamos um mtodo uma classe ou at mesmo variveis do tipo final no podemos sobrescrev-las. O mtodo serve para que quando uma subclasse a chame da mesma maneira que foi criada, sem que haja mudanas em seu comportamento. J quando isso acontece com uma classe ela no pode ser herdada, isso quer dizer que eu no posso us-la como uma subclasse, ele j a classe final e est no seu auge do perfeccionismo. J uma varivel ela no pode mudar seu valor quando recebe seu valor inicial, por exemplo, final int a = 5; at o final do programa ou da execuo do seu bloco a varivel a sempre ser 5, importante saber que seu valor no muda.

12

Friendly Se nenhum modificador de classe for especificado, ento a classe ser considerada friendly. Apenas os objetos integrantes do mesmo package podem utilizar uma classe friendly. Conveno para nomes de objetos Identificadores so seqncias de caracteres Unicode, que devem obedecer s seguintes regras: Embora no seja obrigatrio, o conhecimento e uso da seguinte conveno padro para atribuir nomes em Java pode facilitar bastante a manuteno de um programa: Nomes de classes so iniciados por letras maisculas. Nomes de mtodos, atributos e variveis so iniciados por letras minsculas. Em nomes compostos, cada palavra do nome iniciada por letra maiscula -- as palavras no so separadas por nenhum smbolo. Um nome pode ser composto por letras, por dgitos e pelos smbolos _ e $. Um nome no pode ser iniciado por um dgito (0 a 9). Letras maisculas so diferenciadas de letras minsculas. Uma palavra-chave da linguagem Java no pode ser um identificador.

Tipo de objeto Variveis Constantes Nome de classes Nome de mtodos/funes Atributos Atributos estticos 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 variveis e constantes em Java Cada linguagem de programao tem seu conjunto prprio de regras e convenes para os tipos de nomes que voc pode usar, e Java no diferente. As regras e convenes para nomear variveis em Java so as seguintes:

Nomes de variveis so sensitivos a minsculas e maisculas. Isso quer dizer que "cliente" diferente de "Cliente". O nome de uma varivel pode ser qualquer identificador legal: Uma sequencia sem limites de tamanho de letras Unicode e dgitos, comeando com uma letra, "$" ou o caractere de sublinhado "_" (underscore). A conveno, contudo, sempre comear um nome de varivel com uma letra e no "$" ou "_". Alm disso, por conveno, o caractere $ nunca usado. Voc pode encontrar situaes em que nomes gerados automaticamente podem conter o sinal $, mas evite uslo sempre que possvel. O mesmo acontece com "_". Embora permitido, evite comear nomes de variveis com "_". Espaos no so permitidos em nomes de variveis. Caracteres subsequentes podem ser letras, dgitos, $ ou "_". Convenes (e senso comum) se aplicam a esta regra tambm. Quando escolher nomes para suas variveis, use nomes completos em vez de abreviaes confusas. Isso tornar seu cdigo mais legvel. Nomes tais como "cliente", "nota", "quantidade", etc, so bem mais fceis de entender e 13

lembrar que "cl", "n", "qt", etc. Tenha tambm em mente que palavras-chaves e palavras reservadas da linguagem no podem ser usadas como nomes de variveis. Se o nome de varivel que voc escolher consistir de apenas um palavra, escreva-a toda em letras minsculas. Ex.: cliente. Se consistir de mais de uma palavra, escreva a primeira letra da segunda palavra usando letra maiscula. Ex.: nomeCliente. Se o nome for de uma constante, ele deve ser escrito todo em letras maisculas. 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 maisculas e as minsculas so consideradas diferentes. Detalhes sobre as convenes de codificao sugeridas pelos projetistas da linguagem Java podem ser encontrados no documento Code Conventions for the JavaTM Programming Language. Super Classes Um dos aspectos mais importantes da OOP a capacidade de usar campos e mtodos de uma classe previamente construda. Por meio da extenso de classes simples podemos construir classes maiores, acrescentando quelas mais campos e mtodos, obtendo com isto mais funcionalidades. Neste processo, h uma grande economia no esforo de codificao. Sem esse recurso, freqentemente seria necessrio recodificar grande parte dos programas para acrescentar-lhes funcionalidade ou fazer modificaes significativas. Ao derivar uma classe, estamos primeiramente fazendo uma cpia 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 mtodos subclasse, alm de sobrepor mtodos existentes na superclasse, declarando-os exatamente como na superclasse, exceto por dar um corpo diferente. As classes so definidas atravs do uso da palavra-chave class. Para definir uma classe, utilizase a construo:
[modif] class NomeDaClasse { // corpo da classe... }

A primeira linha um comando que inicia a declarao da classe. Aps a palavra-chave class, segue-se o nome da classe, que deve ser um identificador vlido para a linguagem. O modificador modif opcional; se presente, pode ser uma combinao de public e abstract ou final. Definindo a Classe A definio da classe propriamente dita est entre as chaves { e }, que delimitam blocos na linguagem Java. Este corpo da classe usualmente obedece seguinte seqncia de definio: 1. As variveis de classe, iniciando pelas public, seguidos pelas protected, pelas com visibilidade padro (sem modificador) e finalmente pelas private. 14

2. Os atributos (ou variveis de instncia) dos objetos dessa classe, seguindo a mesma ordenao definida para as variveis de classe. 3. Os construtores de objetos dessa classe. 4. Os mtodos da classe, geralmente agrupados por funcionalidade. Toda classe pode tambm ter um mtodo main associado, que ser utilizado pelo interpretador Java para dar incio execuo de uma aplicao. Java tambm oferece outra estrutura, denominada interface, com sintaxe similar de classes mas contendo apenas a especificao da funcionalidade que uma classe deve conter, sem determinar como essa funcionalidade deve ser implementada. Propriedades de uma classe (meta-informao) podem ser obtidas atravs das funcionalidades oferecidas na classe java.lang.Class. Variveis da classe Cada objeto definido a partir de uma classe ter sua cpia separada dos atributos definidos para a classe. No entanto, h situaes em que interessante que todos os objetos compartilhem a mesma varivel, similarmente ao que ocorre com variveis globais em linguagens de programao tradicional. O mecanismo para realizar esse compartilhamento a definio de variveis da classe. Uma varivel de classe tem sua declarao precedida pela palavra-chave static. Vrias constantes so 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 varivel public static final a varivel out da classe System. Essa varivel, System.out, est associada a um objeto que representa a sada padro (o monitor, tipicamente), sendo utilizada sempre que se deseja enviar um valor para essa sada.

Construtores
Um construtor um (pseudo-)mtodo especial, definido para cada classe. O corpo desse mtodo determina as atividades associadas inicializao de cada objeto criado. Assim, o construtor apenas invocado no momento da criao do objeto atravs do operador new. A assinatura de um construtor diferencia-se das assinaturas dos outros mtodos por no ter nenhum tipo de retorno (nem mesmo void). Alm disto, o nome do construtor deve ser o prprio nome da classe. O construtor pode receber argumentos, como qualquer mtodo. 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 no recebe argumentos, criado pelo compilador Java. No entanto, se o programador da classe criar pelo menos um mtodo construtor, o construtor default no ser criado automaticamente -- se ele o desejar, dever criar um construtor sem argumentos explicitamente. 15

No momento em que um construtor invocado, a seguinte seqncia de aes executada para a criao de um objeto: 1. O espao para o objeto alocado e seu contedo inicializado (bitwise) com zeros. 2. O construtor da classe base invocado. 3. Os membros da classe so inicializados para o objeto, seguindo a ordem em que foram declarados na classe. 4. O restante do corpo do construtor executado. Seguir essa seqncia uma necessidade de forma a garantir que, quando o corpo de um construtor esteja sendo executado, o objeto j ter disposio as funcionalidades mnimas necessrias, quais sejam aquelas definidas por seus ancestrais. O primeiro passo garante que nenhum campo do objeto ter um valor arbitrrio, que possa tornar erros de no inicializao difceis de detectar. Classes em UML Em UML (Unified Modeling Language), a representao para uma classe no diagrama de classes expressa graficamente como:

Os atributos so membros da classe que descrevem suas propriedades. Para cada atributo especifica-se o nome, tipo (primitivo ou outra classe), uma especificao de visibilidade e, opcionalmente, um valor inicial. A especificao de visibilidade pode ser, se definida, privativa (-, nenhuma visibilidade externa), pblica (+, visibilidade externa total) ou protegido (#, visibilidade externa limitada a objetos de classes derivadas). Os mtodos so membros da classe que descrevem suas funcionalidades, ou seja, o que pode ser feito com um objeto da classe. Para cada mtodo, especifica-se o nome, o tipo de retorno (void se no houver nenhum), a lista de argumentos (o tipo e opcionalmente um identificador para cada parmetro) e visibilidade (como para atributos, define o quo acessvel um mtodo a partir de objetos de outros classes). Atributos A todo objeto podemos relacionar alguns atributos (propriedades). No exemplo de um relgio a hora, a data. Na programao orientada a objeto, os atributos so definidos na classe e armazenados de forma individual ou coletiva pelos objetos.
Podemos relacionar alguns atributos (propriedades) a todo objeto. No exemplo do relgio, a hora e a data. Na programao orientada a objeto, os atributos so definidos na classe e armazenados de forma individual ou coletiva pelos objetos.

16

A definio de atributos de uma classe Java reflete de forma quase direta a informao que estaria contida na representao da classe em um diagrama UML. Para tanto, a sintaxe utilizada para definir um atributo de um objeto :
[modificador] tipo nome [ = default];

onde

o modificador (opcional) uma combinao 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 vlido; default (opcional) a especificao de um valor inicial para a varivel.

Mtodos
A todo objeto podemos relacionar determinados comportamentos, aes e reaes. As aes ou comportamento dos objetos so chamados na anlise orientada a objeto de mtodos (AOO), assim, um mtodo uma funo, um servio fornecido pelo objeto. Os comportamentos dos objetos so definidos na classe atravs dos mtodos e servem para manipular e alterar os atributos do objeto (alteram o estado do objeto). Em Java, a definio de um mtodo em uma classe expressa dentro do corpo da classe como um bloco na forma:
[modificador] tipo nome(argumentos) { corpo do mtodo}

onde o nome (um identificador vlido) e o tipo dos argumentos constituem a assinatura do mtodo. O tipo um indicador do tipo de retorno do mtodo, que pode ser um dos tipos primitivos da linguagem, um tipo de objeto (nome de classe ou interface), ou void se no houver nenhum valor de retorno. O modificador (opcional) uma combinao de um especificador de visbilidade (public, protected ou private), de um especificador de redefinio (abstract ou final) e de um especificador de escopo (static). Mtodos so essencialmente procedimentos que podem manipular atributos de objetos para os quais o mtodo foi definido. Alm dos atributos de objetos, mtodos podem definir e manipular variveis locais; tambm podem receber parmetros por valor atravs da lista de argumentos. Uma boa prtica de programao manter a funcionalidade de um mtodo simples, desempenhando uma nica tarefa. O nome do mtodo deve refletir de modo adequado a tarefa realizada. Se a funcionalidade do mtodo for simples, ser fcil encontrar um nome adequado para o mtodo. Como ocorre para a definio de atributos, a definio de mtodos reflete de forma quase direta a informao que estaria presente em um diagrama de classes UML, a no ser por uma diferena vital: o corpo do mtodo. 17

Mtodos 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 mtodos (aes), e que o objeto reage ao meio que o envolve de acordo com as excitaes que sofre. Em um programa orientado a objeto as excitaes so representadas por mensagens que so enviadas a um objeto. Uma mensagem pode ser gerada pelo usurio, por exemplo, ao clicar o mouse. Objeto (ou Instncia) A Anlise Orientada a Objeto (AOO) tem uma srie de conceitos que auxiliam as pessoas a delinear claramente o problema e a identificar os objetos e seus relacionamentos. Objetos so coisas do mundo real ou imaginrio, 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 so armazenadas no prprio objeto. As propriedades de um objeto so chamadas ainda de atributos. O objeto interage com o meio e em funo de excitaes que sofre, realiza determinadas aes que alteram o seu estado (seus atributos). Os atributos de um objeto no so estticos, eles sofrem alteraes com o tempo. Para a POO, um objeto uma entidade nica que rene atributos e mtodos, ou seja, rene as propriedades do objeto e as reaes s excitaes que sofre. Uma varivel do tipo classe chamada de objeto. A instncia de uma classe chamada de objeto. Tipos Bsicos Observe a tabela a seguir, sobre os tipos de dados. Esses tipos so 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 referncias. Os tipos primitivos correspondem a dados mais simples ou escalares, enquanto os tipos de referncias consistem em arrays, classes e interfaces. Estes sero vistos nos mdulos subseqentes. Vamos a uma descrio curta sobre cada um dos tipos: Tipo boolean Descrio Pode ser contido em 1 bit, porm o seu tamanho no precisamente definido. Assume os valores true ou false. Caractere em notao Unicode de 16 bits. Serve para armazenar dados alfanumricos. Tambm pode ser usado como um dado inteiro com valores na faixa entre 0 e 65535. 18

char

byte

Inteiro de 8 bits em notao de complemento de dois. Pode assumir valores entre -27=-128 e 27-1=127. Inteiro de 16 bits em notao de complemento de dois. Os valores possveis cobrem a faixa de -2-15=-32.768 a 215-1=32.767 Inteiro de 32 bits em notao de complemento de dois. Pode assumir valores entre 231=2.147.483.648 e 231-1=2.147.483.647. Inteiro de 64 bits em notao de complemento de dois. Pode assumir valores entre -263 e 263-1. Representa nmeros em notao de ponto flutuante normalizada em preciso simples de 32 bits em conformidade com a norma IEEE 754-1985. O menor valor positivo representvel por esse tipo 1.40239846e-46 e o maior 3.40282347e+38. 4 bytes de tamanho e 23 dgitos binrios depreciso. Representa nmeros em notao de ponto flutuante normalizada em preciso dupla de 64 bits em conformidade com a norma IEEE 754-1985. O menor valor positivo representvel 4.94065645841246544e-324 e o maior 1.7976931348623157e+308. 8 bytes de tamanho e 52 dgitos binrios de preciso.

short

int

long

float

double

19

Controle de Fluxo Estruturas de Seleo e Repetio


Comando de Seleo em Java Introduo Um comando de seleo define uma condio em um programa, que permite que grupos de comandos sejam executados de maneira condicional, de acordo com o resultado da avaliao de um determinado teste (verdadeiro ou falso). Ou seja, programas utilizam comandos de seleo para escolher entre cursos alternativos de aes. A sintaxe do comando de seleo em Java : A sintaxe do if no Java a seguinte:
if (condicaoBooleana) { codigo; }

Uma condio booleana qualquer expresso 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("No pode entrar"); }

Alm disso, voc pode usar a clusula else para indicar o comportamento que deve ser executado no caso da expresso booleana ser falsa:
int idade = 15; if (idade < 18) { System.out.println("No pode entrar"); } else { System.out.println("Pode entrar"); }

Voc pode concatenar expresses booleanas atravs dos operadores lgicos E e OU. O E representado pelo && e o OU representado pelo ||. Um exemplo seria verificar se ele tem menos de 18 anos e se ele no amigo do dono:
int idade = 15; boolean amigoDoDono = true; if (idade < 18 && amigoDoDono == false) { System.out.println("No pode entrar"); } else { System.out.println("Pode entrar"); }

Esse cdigo poderia ficar ainda mais legvel, utilizando-se o operador de negao, o !. Esse operador transforma o resultado de uma expresso booleana de false para true e vice versa. 20

int idade = 15; boolean amigoDoDono = true; if (idade < 18 && !amigoDoDono) { System.out.println("No pode entrar"); } else { System.out.println("Pode entrar"); }

Repare na linha 3 que o trecho amigoDoDono == false virou !amigoDoDono. Eles tm o mesmo valor. Para comparar se uma varivel tem o mesmo valor que outra varivel ou valor, utilizamos o operador ==. Repare que utilizar o operador = dentro de um if vai retornar um erro de compilao, j que o operador = o de atribuio.
int mes = 1; if (mes == 1) { System.out.println("Voc deveria estar de frias"); }

Estruturas de Repetio While O while um comando usado para fazer um lao (loop), isto , repetir um trecho de cdigo algumas vezes. A idia que esse trecho de cdigo seja repetido enquanto uma determinada condio 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 condio idade < 18 passe a ser falsa. E isso ocorrer exatamente no momento em que idade == 18, o que no 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 repetio, tal como o prprio while. A principal diferena entre os dois que do while ir fazer a comparao apenas no final do bloco de cdigo, sendo representado da seguinte forma:
do{ cdigo } while (comparao);

Neste caso, devemos ter as mesmas precaues quanto while, no que diz respeito a looping infinito. Mas no necessrio inicializar a varivel antes do bloco de cdigo como acontece com while, pois a comparao s ser feita aps todo o cdigo ter sido executado. For Outro comando de loop extremamente utilizado o for. A idia a mesma do while: fazer um trecho de cdigo ser repetido enquanto uma condio continuar verdadeira. Mas alm disso, o for isola tambm um espao para inicializao de variveis e o modificador dessas variveis. Isso faz com que fiquem mais legveis, as variveis que so 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; }

Porm, o cdigo do for indica claramente que a varivel i serve, em especial, para controlar a quantidade de laos executados. Quando usar o for? Quando usar o while? Depende do gosto e da ocasio. Ps incremento ++ i = i + 1 pode realmente ser substitudo por i++ quando isolado, porm, em alguns casos, temos essa instruo envolvida em, por exemplo, uma atribuio:
int i = 5; int x = i++;

Qual o valor de x? O de i, aps essa linha, 6. O operador ++, quando vem aps a varivel, retorna o valor antigo, e incrementa (ps incremento), fazendo x valer 5. 22

Se voc tivesse usado o ++ antes da varivel (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 atravs da janela de comando do sistema operacional era surpreendentemente complexa at a verso 1.4.2 do J2SE. Isto no era problema para aplicativos com recursos GUI - Graphical User Interface (Interface Grfica com o Usurio), mas tornava-se desconfortvel para estudantes interessados em escrever programas simples com o propsito de aprender Java. J2SE 5.0 introduz a classe java.util.Scanner para a entrada de dados, inclusive atravs da entrada padro, System.in. O exemplo a seguir apresenta uma aplicao Java para a entrada de dois nmeros pelo teclado e a sada da soma na janela de comando do sistema operacional. necessrio criar uma instncia da classe Scanner, passando como argumento o objeto padro de entrada, System.in, que ir capturar as entradas de dados via o teclado. O mtodo nextInt(), da instncia da classe Scanner, l o valor digitado e o armazena em uma varivel 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 nmero: 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 mtodos que podem ser utilizados para realizar este servio. Os principais mtodos que podemos utilizar, neste caso, so: Mtodo 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 Nmero Fracionrio Aguarda uma entrada em formato Nmero Fracionrio Tabela 1: Mtodos da Classe Scanner para obter dados

Encapsulamento
Poderiamos dizer que encapsular significa, na orientao objetos, separar um programa em partes isolando-as o mximo possvel, protegendo o acesso direto aos atributos de uma classe com o objetivo de deixar o programa mais flexvel e facilitar o trabalho no cdigo. Para isso se faz necessrio o uso de modificadores de acesso mais restritivos nos atributos da classe. Esses atributos so manipulados indiretamente com o uso de mtodos especficos. O padro usado para a manipulao desses atributos so os mtodos set (que define o valor do atributo) e get (que retorna o valor do atributo). Encapsulamento vem de encapsular, que em programao orientada a objetos significa separar o programa em partes, o mais isoladas possvel. A idia tornar o software mais flexvel, fcil de modificar e de criar novas implementaes. Para exemplificar, podemos pensar em uma dona de casa (usurio) utilizando um liquidificador (sistema). O usurio no necessita conhecer detalhes do funcionamento interno do sistema para poder utiliz-lo, precisa apenas conhecer a interface, no caso, os botes que controlam o liquidificador. Outro exemplo clssico de encapsulamento o padro de projeto chamado Mediator. Uma grande vantagem do encapsulamento que toda parte encapsulada pode ser modificada sem que os usurios da classe em questo sejam afetados. No exemplo do liquidificador, um tcnico 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 boto. O encapsulamento protege o acesso direto (referncia) aos atributos de uma instncia fora da classe onde estes foram declarados. Esta proteo consiste em se usar modificadores de acesso mais restritivos sobre os atributos definidos na classe. Depois devem ser criados mtodos para manipular de forma indireta os atributos da classe. Encapsular atributos tambm 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 mtodo de acesso chamado lerCor(), e um modificador chamado proximaCor(). O estado mantido pois os usurios da classe no podem alterar as cores de um semforo ao seu bel prazer e, por exemplo, fazer a seguinte troca de cores: vermelho-amarelo-vermelho. comum usar o padro get<nomeDoAtributo> para o mtodo que retorna o valor atual do atributo e 24

set<nomeDoAtributo> para o mtodo 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 proteo: " + 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 proteo: " + 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; } }

Mtodos Get e Set Como visto anteriormente, o encapsulamento "protege" os atributos ou mtodos dentro de uma classe, portanto devemos prover meios para acessar tais membros quando eles so particulares, ou seja, quando possuem o modificador private. O que torna isso possvel a criao de mtodos. Em programao orientada a objetos, esses mtodos so chamados de mtodos acessores ou getters e setters, pois eles provm acesso aos atributos da classe, e geralmente, se iniciam com get ou set, da a origem de seu nome. Na verdade, no h nada de diferente entre os mtodos comuns e os mtodos acessores. A nica importncia est no fato da orientao a objeto. Pois, sempre que formos acessar um membro em Java usaremos get ou set. Set Nomeamos um mtodo acessor com set toda vez que este mtodo for modificar algum campo ou atributo de uma classe, ou seja, se no criarmos um mtodo acessor set para algum atributo, isso quer dizer que este atributo no deve ser modificado. 26

Portanto, como o valor de um atributo da classe ser modificado, no necessrio que este mtodo retorne nenhum valor, por isso, os mtodos setters so void. Porm, obrigatoriamente, eles tem que receber um argumento que ser o novo valor do campo. Get Nomeamos um mtodo acessor com get toda vez que este mtodo for verificar algum campo ou atributo de uma classe. Como este mtodo ir verificar um valor, ele sempre ter um retorno como String, int, float, etc. Mas no ter nenhum argumento.

Sobrecarga de Mtodos
Neste captulo vamos apresentar a sobrecarga de mtodos, o uso de mtodos com o mesmo nome, mas parmetros diferentes. O que a sobrecarga de mtodos? Sobrecarga de mtodos se refere ao uso de mtodos com mesmo nome, mas com tipos de parmetros ou nmero de parmetros diferentes. Isto , o nome do mtodo o mesmo, mas os tipos de parmetros so diferentes. De um modo geral como os mtodos sobrecarregados tm o mesmo nome, eles realizam basicamente a mesma tarefa, a diferena o nmero de parmetros e ou o tipo dos parmetros que so recebidos. Exemplos de sobrecarga O exemplo a seguir declara mtodos com o mesmo nome, mtodos 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 mtodo voc quer acessar verificando o tipo dos parmetros e o nmero de parmetros. Mudar o nome dos parmetros no uma sobrecarga, o compilador diferencia o tipo e a quantidade de parmetros no 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 orientao a objeto utilizado em Java que define aes que devem ser obrigatoriamente executadas, mas que cada classe pode executar de forma diferente. Interfaces contm valores constantes ou assinaturas de mtodos 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 ao (mtodo), porm, podem execut-la de maneira diferente. 28

Usando um exemplo bem drstico, podemos ter uma interface chamada areo que possui a assinatura do mtodo voar(). Ou seja, toda classe que implementar areo deve dizer como voar(). Portanto, se eu tenho uma classe chamada pssaro e outra chamada avio, ambas implementando a interface areo, ento, 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 { mtodoAbstrato (argumentos); }

Usando uma Interface em uma Classe Como vimos anteriormente, uma classe pode extender suas funcionalidades obtendo as caractersticas de outra classe num processo que chamamos de herana. Uma interface no herdada, mas sim, implementada. Porque todo o cdigo dos mtodos da interface deve ser escrito dentro da classe que o chama. Dessa forma, obtemos as assinaturas dos mtodos da interface em uma classe usando a palavra-chave implements. A vantagem principal das interfaces que no h limites de quantas interfaces uma classe pode implementar. O que ajuda no caso de heranas mltiplas que no possvel ser feito em Java, pois uma classe apenas pode herdar as caractersticas de uma outra classe. Resumindo Uma interface em Java uma espcie de classe, com as seguintes propriedades: No pode ser instancivel (no podemos criar objetos com new); S pode possuir assinaturas de mtodos de instncia, pblicos e abstratos (sem corpo). No pode possuir mtodos concretos (com corpo), nem mtodos estticos. Os prefixos abstract e public podem ser usados, mas so em geral omitidos; No pode conter variveis de instncia ou de classe (static); Pode conter declaraes de constantes (com prefixo final e inicializadas para um valor) nesse caso essa varivel 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,"Permetro de um Quadrado: " + medida * 4); } public static void main(String[] args) { ExemploInterface ex = new ExemploInterface(); double medida; medida = (Double.parseDouble(JOptionPane.showInputDialog(null, "Clculo com figura geomtrica" + "\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, so criadas duas interfaces. A segunda uma subinterface da primeira, ou uma extenso dela. A interface InterfaceExemplo2 contm todos os trs mtodos, e mais a constante PALAVRA. Ou seja, ela "herda" as definies da sua superinterface Exemplo (bem como de todas as superinterfaces acima na hierarquia que existirem). Ao contrrio das classes, no existe uma interface "raiz" de todas as interfaces, como ocorre com a classe Object. A interface InterfaceExemplo, vista acima, no herda de nenhuma outra. Note que a mesma conveno para nome de classe se aplica aos nomes das interfaces: iniciar com letra maiscula, seguida de letras minsculas. A constante PALAVRA do exemplo acima segue a conveno de nome de constantes em Java, que ter todas as letras maisculas. 30

O arquivo fonte de uma interface, da mesma forma que no caso de classes, tambm tem o nome da interface com a terminao .java. E o compilador gera da mesma forma um arquivo .class de mesmo nome. Usando interfaces Uma Interface funciona de forma anloga a uma classe abstrata. Ou seja, ela no pode ser instanciada, mas pode ser como que "herdada" por uma classe. A forma sinttica para uma classe herdar de uma interface utiliza a palavra chave implements, como no exemplo fictcio 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 mtodos e atributos desta classe }

O sentido de uma classe "herdar" de uma interface similar ao de herdar mtodos abstratos de uma superclasse abstrata. A classe fica obrigada a implementar concretamente todos os mtodos declarados na interface, e nas suas super-interfaces, ou a classe no compilar. Note que a classe pode usar diretamente a constante definida na interface. Classes podem implementar mais de uma interface Uma diferena essencial entre classes e interfaces que uma classe pode implementar diversas interfaces, embora possa ser subclasse de apenas uma superclasse. Nesse caso, aps a palavra chave implements, escrevemos a lista das interfaces que a classe implementa, separadas por vrgulas. 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(){ //Mtodo da classe
JOptionPane.showMessageDialog(null, "Executou o mtodo da classe");

} public void metodo1(){ //Mtodo da interface1


JOptionPane.showMessageDialog(null, "Executou o mtodo da Interface1");

} public void metodo2(){ //Mtodo da interface2


JOptionPane.showMessageDialog(null, "Executou o mtodo da Interface2");

} public void f1(){ //Mtodo1 da InterfaceY


JOptionPane.showMessageDialog(null, "Executou o mtodo1 da InterfaceY");

} public void f2(){ //Mtodo2 da InterfaceY


JOptionPane.showMessageDialog(null, "Executou o mtodo2 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 Excees e Erros Umas das utilidades proporcionadas pela orientao a objetos de Java a facilidade em tratar possveis erros de execuo chamados de excees. Sempre que um mtodo de alguma classe passvel de causar algum erro, ento, podemos usar o mtodo de tentativa - o try. 32

Tudo que estiver dentro do bloco try ser executado at que alguma exceo seja lanada, ou seja, at que algo d errado. Quando uma exceo lanada, ela sempre deve ser capturada. O trabalho de captura da exceo executado pelo bloco catch. Um bloco try pode possuir vrios blocos de catch, dependendo do nmero de excees que podem ser lanadas por uma classe ou mtodo. O bloco catch obtm o erro criando uma instncia da exceo. Portanto, a sintaxe do bloco try catch :
try { // cdigo a ser executado } catch (ClasseDeExceo instnciaDaExceo) { // tratamento da exceo }

Excees As excees so, na verdade, instncias de classes. E como qualquer classe ou objeto, podemos facilmente manipular. Existem mtodos comuns entre todas as classes de Excees, dentre as quais podemos citar: toString() O Java usa o mtodo toString() toda vez que for necessrio converter um objeto em String, ou seja, para obter ume representao textual do objeto. Por exemplo para imprimir um objeto qualquer usando System.out.println ou para mostrar os itens de um JComboBox. Esse mtodo toString() definido na classe Object, portanto herdado por todos os objetos. Todos os objetos so capazes de gerar uma representao textual. Mas o mtodo do Object no conhece as classes derivadas, no sabe como o objeto deve ser representado. Por isso usa um padro: o nome da classe seguido por um '@' e pelo hashCode em hexadecimal da instncia em questo. No Java cada classe deve fornecer um hashCode(), mtodo que recebe os dados armazenados em uma instncia da classe em um nico valor hash1. Retorna uma representao em texto do objeto. Converte os dados da exceo em String para visualizao.

Um hash uma sequncia de bits geradas por um algoritmo de disperso, em geral representada em base hexadecimal, que permite a visualizao em letras e nmeros (0 a 9 e A a F). O conceito terico diz que "hash a transformao de uma grande quantidade de informaes em uma pequena quantidade de informaes".

33

printStackTrace() Imprime na sada de erro padro (geralmente console) todos os frames de onde foram detectados erros. til para depurao no desenvolvimento, pois mostra todo o histrico do erro, alm das linhas onde foram ocasionados. getCause() Retorna a causa da Exceo, ou null se a causa for desconhecida ou no existir. getMessage() Retorna uma string com o erro. uma forma simples e elegante de mostrar a exceo causada, geralmente, utilizada como forma de apresentao ao usurio. Finally Finally o trecho de cdigo final. A funo bsica de finally sempre executar seu bloco de dados mesmo que uma exceo seja lanada. muito til para liberar recursos do sistema quando utilizamos, por exemplo, conexes de banco de dados e abertura de buffer para leitura ou escrita de arquivos. Finally vir aps os blocos de catch.
try { // cdigo a ser executado } catch (ClasseDeExceo instnciaDaExceo) { // tratamento da exceo } finally { // cdigo a ser executado mesmo que uma exceo seja lanada }

Abaixo est um exemplo de tratamento de erro ou exceo. Tentaremos atribuir uma string de letras a um objeto inteiro. Como no possvel atribuir uma string de letras a um objeto inteiro, uma exceo de formato de nmero lanada.
package programas; public class ExemploTryCatchFinally { public static void main(String[] args){ String var = "ABC"; try { Integer i = new Integer(var); System.out.println("A varivel i vale " + i); } catch (NumberFormatException e){
System.out.println("No possvel 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:
No possvel 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. CONSTRUDO COM SUCESSO (tempo total: 2 segundos)

Exemplo sem o mtodo 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
CONSTRUDO COM SUCESSO (tempo total: 0 segundos)

35

Exemplo com o mtodo 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
CONSTRUDO 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 varivel i vale " + i);

} catch (NumberFormatException e){


JOptionPane.showMessageDialog(null, "No possvel 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 Grficas Usando JFC/Swing


1.1 Introduo
Neste captulo vamos ver como criar aplicaes grficas em Java, mais precisamente usando um Framework (conjunto de classes) chamado Swing. Veremos trs exemplos, comeando com um simples programa que apenas escreve uma mensagem na tela, passando para um programa que j trabalha com caixas de texto e botes, e por final veremos como trabalhar com listas. H ainda uma seo especialmente sobre gerenciamento de layout, os chamados "Layout Managers", item muito importante quanto se trata de programao GUI- Graphical User Interfaces (Interface Grfica com o Usurio). Conhecendo o Swing Nas primeiras verses do Java a nica forma de fazer programas grficos era atravs da AWTAbstract Window Toolkit (), uma biblioteca de baixo-nvel que dependia de cdigo nativo da plataforma onde rodava. Ela traz alguns problemas de compatibilidade entre as plataformas, fazendo que nem sempre o programa tinha aparncia desejada em todos os sistemas operacionais, sendo tambm mais difcil de ser usada. Para suprir as necessidades cada vez mais freqentes de uma API (Application Programming Interface) mais estvel e fcil de usar. O Swing foi criado como uma extenso do Java a partir da verso 1.2. Swing fornece componentes de mais alto nvel, possibilitando assim uma melhor compatibilidade entre os vrios sistemas onde Java roda. Ao contrrio da AWT, Swing no contm uma nica linha de cdigo nativo, e permite que as aplicaes tenham diferentes tipos de visuais ( skins ), os chamados "Look and Feel". J com AWT isso no possvel, tendo todos os programas a aparncia da plataforma onde esto rodando. Apesar da AWT ainda estar disponvel no Java, altamente recomendvel que sejam usado Swing, pelas razes descritas aqui e por vrias outras. Componentes Swing contm um "J" na frente, como em JButton por exemplo. Componentes AWT no contm inicial alguma ( "Button" no caso ). Alm disso tudo, as vantagens do Swing no param por ai. H uma enorme gama de controles extras disponveis, tais como reas de texto que nativamente podem mostrar contedo RTF (Rich Text Format) ou HTML, botes com suporte a imagens, sliders, selecionadores de cores etc. tambm possvel alterar o tipo de borda para a maior parte dos componentes, todos podem ter imagens associadas e possvel at ter controle de como so desenhados os mnimos detalhes de apresentao. Criao de Interfaces Grficas Em Java, as classes nas quais nos baseamos para criar os componentes,bem como para fornecerlhes funcionalidade, esto agrupadas em dois grandes pacotes: java.awt (pacote do ncleo) e javax.swing (pacote de extenso). Os dois pacotes denem componentes com peculiaridades distintas e que sero discutidas logo abaixo. 1.1.2 Componentes Swing O pacote javax.swing foi criado em 1997 e inclui os componentes GUI que se tornaram padro em Java a partir da verso 1.2 da plataforma Java2. A maioria dos componentes Swing (assim so denominados) so escritos, manipulados e exibidos completamente em Java, sendo conhecidos como componentes Java puros. Isso oferece a eles um maior nvel de portabilidade e 37

exibilidade. Os nomes de tais componentes recebem um J, como, por exemplo: JLabel, JButton, JFrame, JPanel, etc. Tal peculiaridade se justica para diferenciar esses componentes dos que sero mencionados logo adiante. So considerados peso-leve e fornecem funcionalidade e aparncia uniforme em todas as plataformas, sendo denominada de aparncia de metal (metal look-and-feel). Entretanto, muitos componentes Swing ainda so 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, aparncia e seu comportamento. O Swing tambm fornece exibilidade para personalizar a aparncia e ocomportamento dos componentes de acordo com o modo particular de cada plataforma, ou mesmo alter-los enquanto o programa est sendo executado. As opes so a personalizao 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 verso 1.0 da plataforma Java 2, e esto diretamente associados com os recursos da interface grca da plataforma do usurio. Dessa forma, a aparncia dos componentes diferem quando o programa executado no Microsoft Windows e no Apple Macintosh. Podemos dizer que estes componentes considerados peso-pesados herdam a aparncia denida pela plataforma, pois o A.W.T. foi projetado para que cada mquina virtual Java implemente seu elemento de interface. Isso pode ser desejvel, uma vez que permite aos usurios do programa utilizar os componentes GUI com que eles j esto familiarizados, porm 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 aplicao (suas cores, formatos e etc). Por padro, o Java vem com um look-and-feel prprio, que se comporta exatamente da mesma forma em todas as plataformas suportadas. Mas s vezes esse no o resultado desejado. Quando roda-se a aplicao no Windows, por exemplo, bastante gritante a diferena em relao ao visual das aplicaes nativas. Por isso possvel alterar qual o look-and-feel a ser usado na aplicao. Alm do padro do Java, o JRE-Java Runtime Environment 5 (Ambiente de Tempo de Execuo Java) da Sun ainda traz LaF nativos para Windows e Mac OS, alm do Motif e GTK. E, fora esses, ainda podem ser baixados diversos LaF na Internet ou at desenvolver os prprios. Abaixo esto alguns screenshots da documentao do Swing mostrando a mesma aplicao rodando com 4 LaF diferentes:

38

OBSERVAES: Para alterar o look-and-feel de um aplicativo possvel usar o mtodo esttico setLookAndFeel() da classe javax.swing.UIManager. Tal mtodo 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 no 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

Aplicaes grandes com Swing podem ganhar uma complexidade enorme e ficar difceis de manter. Alguns projetos tentam minimizar esses problemas; h, por exemplo, o famoso projeto Thinlet, onde voc pode utilizar Swing escrevendo suas interfaces grficas em XML.

1.2 Hierarquia de Classe


Abaixo, a hierarquia de herana das classes que denem atributos e comportamentos que so 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

u 1.2.1 java.lang.Object O java.lang.Object classe a superclasse final de todos os objetos Se uma classe no explicitamente estender uma classe, o compilador assume que se estende java.lang.Object. Os Mtodos de java.lang.Object A classe java.lang.Object fornece um nmero de mtodos que so comuns a todos os objetos. O mtodo toString () o mais comum, tais. Como o padro toString () mtodo 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 () lana CloneNotSupportedException; public String toString (); notify public void final (); notifyAll public void final (); espera public void final (long timeout) lana InterruptedException; espera public void final (long timeout, int nanossegundos) lana 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 verso 1.0 da plataforma Java 2, e esto diretamente associados com os recursos da interface grfica da plataforma do usurio. Dessa forma, a aparncia dos componentes difere quando o programa executado no Microsoft Windows e no Apple Macintosh. Podemos dizer que estes componentes considerados peso-pesados herdam a aparncia definida pela plataforma, pois o A.W.T. foi projetado para que cada mquina virtual Java implemente seu elemento de interface. Isso pode ser desejvel, uma vez que permite aos usurios do programa utilizar os componentes GUI com que eles j esto familiarizados, porm o leiaute e o alinhamento dos componentes pode se alterar devido aos tamanhos diferentes dos mesmos em cada plataforma. Essa coleo de componentes para construo de Interfaces Grficas est desatualizada e foi substituida pelo projeto Swing. Em virtude disso, nossa nfase reside no estudo e uso do pacote em maior evidncia. Um componente um objeto tendo uma representao grfica que pode ser visualizado no monitor e que pode interagir com o utilizador. Exemplos de componentes so os botes, caixas, e barras de rolagem de uma interface grfica. As operaes comuns maioria dos componentes GUI, tanto Swing como AWT so denidas na classe Component. Isso inclui os mtodos relativos a: Posicionamento; Personalizao; 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 contedo, que um objeto da classe Container. Logo, a classe Container d suporte adio e posicionamento dos componentes ao painel de contedo de um continer. 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 aplicao e rotular nunca executar qualquer tipo de ao. Sintaxe:
Etiqueta LABEL_NAME = new Etiqueta ("Este o texto do rtulo.");

cdigo acima representa simplesmente o texto para o rtulo. 41

Etiqueta LABEL_NAME = new Etiqueta ("Este o texto do rtulo." , Label.CENTER);

Justificao da etiqueta pode ser de esquerda, direita ou centralizado. Acima de declarao utilizada a justificao centro da etiqueta utilizando o Label.CENTER. Botes Este o componente de Java Abstract Window Toolkit e usado para disparar aes e outros eventos necessrios para sua aplicao. A sintaxe de definio do boto a seguinte:
Boto button_name = new boto ("Este o rtulo do boto.");

Pode-se alterar o rtulo do boto, ou o texto do rtulo usando o boto.setLabel(String) e boto.getLabel() mtodo. Os botes so adicionados ao continer usando o add (button_name) mtodo. Caixas de seleo Este componente do Java AWT permite que se crie caixas de seleo em suas aplicaes. A sintaxe da definio de Caixa a seguinte:
CheckBox checkbox_name = new Checkbox ("caixa de seleo opcional 1" , false);

O cdigo acima constri a caixa de seleo desmarcada, passando o argumento boolean valor falso com o rtulo Checkbox atravs do Checkbox() construtor. Checkbox definido acrescentado seu continer usando add(checkbox_name) mtodo. Pode-se alterar e obter rtulo da caixa de seleo usando o setLabel(String) e getLabel() mtodo. Pode-se, tambm, definir e obter o estado da caixa de seleo usando o setState (boolean) e GetState() mtodo 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 seleo de um grupo de checkbox pode ser selecionada por vez. Sintaxe para a criao de botes de rdio 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 cdigo acima estamos fazendo trs caixas de seleo com o rtulo de "Um", "Dois" e "Trs". rea de texto Este o componente recipiente de texto do pacote Java AWT. A rea de texto contm texto simples. TextArea pode ser declarado como segue:
TextArea txtArea_name = new TextArea();

42

Voc pode fazer a rea de texto editvel ou no. Usar o (boolean) setEditable mtodo. Se voc passar o argumento boolean valor falso, em seguida, a rea de texto ser no-editvel caso contrrio, ser editvel. A rea de texto , por padro no modo editvel. Texto so definidas na rea de texto usando o setText (string) mtodo do TextArea classe. Campo de texto Esta tambm a componente recipiente de texto de pacote Java AWT. Este componente contm linha nica e informaes de texto limitada. Esta declarada como segue:
TextField txtfield = new TextField(20);

Pode-se corrigir o nmero de colunas no campo de texto, especificando o nmero no construtor. No cdigo acima, temos fixado o nmero de colunas igual a 20. 1.2.3 java.awt.Container Containers Dificilmente uma aplicao grfica composta por um nico componente, mas sim por vrios componentes inter-relacionados. Para este tipo de aplicao, um componente fundamental a rea onde os demais componentes da aplicao estaro dispostos. Um componente que pode conter outros componentes denominado um container. Em Java, a classe Container a classe abstrata que define as funcionalidades bsicas associadas a um container, tais como adicionar e remover componentes, o que possvel atravs dos mtodos add() e remove(), respectivamente. possvel tambm estabelecer qual a estratgia de disposio de componentes no container, ou seja, qual o mtodo de gerncia de layout, atravs do mtodo setLayout(). Window uma classe derivada de Container cujos objetos esto associadas a janelas. Cada objeto Window uma janela independente em uma aplicao, embora a essa janela no estejam associadas as funcionalidades usualmente oferecidas por gerenciadores de janela. Raramente um objeto desse usado diretamente, mas objetos dessa classe so muito utilizados atravs de suas subclasses, tais como Frame. Outra classe derivada de Container de extensa aplicao Panel , que define uma rea de composio de componentes contida em alguma janela. A classe Applet uma extenso de Panel que permite criar applets. Embora a classe JComponent, raiz da hierarquia para todos os componentes do novo framework para interfaces grficas de Java, seja derivada da classe Container, no se pode acrescentar diretamente um componente grfico 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 referncia ao objeto Container atravs do mtodo getContentPane(). Um Container, em programao orientada a objetos, um delimitador abstrato, "um objeto que contm outros objetos". Estes podem ser includos ou removidos dinamicamente (durante o tempo de execuo), diferentemente do que ocorre em uma composio onde este relacionamento fixado durante o tempo de compilao. 43

java.awt Container Classe java.lang.Object java.awt.Component java.awt.Container public class Container estende Component Um genrico Abstract Window Toolkit objeto de recipiente (AWT) um componente que pode conter outros componentes AWT. Componentes adicionados a um recipiente so 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 adio 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 exceo de nvel superior recipientes, todos os componentes Swing cujos nomes comeam com "J" descer do JComponent classe. Por exemplo, JPanel, JScrollPane, JButton e JTable todos herdam de JComponent . No entanto, JFrame e JDialog no o fazem porque eles implementam de nvel superior recipientes. O JComponent classe estende a Container classe, que se estende Component . O Componente classe inclui tudo, desde fornecendo sugestes de layout para pintura apoiar e eventos. O Container classe tem suporte para adicionar componentes para o container e colocando-as fora. Esta seo de tabelas de API resume os mtodos mais frequentemente utilizados de Componente e Container , bem como de JComponent . A classe JComponent, que dene os atributos e comportamentos para suas subclasses, a superclasse da maioria dos componentes Swing. Com exceo dos conteiners JFrame e JDialog, todos os demais componentes Swing cujo nome comece com J descendem da classe JComponent. Os componentes Swing derivados de JComponent tem muitos recursos: Uma aparncia e comportamento plugveis, adpatados tambm as diferentes sistemas operacionais; Teclas de atalho (menemnicas) para acesso direto aos componentes a partir do teclado; Capacidades comuns para tratamento de eventos, no caso em que vrios componentes GUI iniciam a mesma ao em um programa; Descries de finalidade associada ao componente; Podem ser extendidas facilmente a programa para deficientes fsicos; Suporte para linguas locais o programa pode ser usado em diferentes lnguas.

44

1.3 Modelos de Desenvolvimento


Em Java, as classes nas quais nos baseamos para criar os componentes, bem como para fornecerlhes funcionalidade, esto agrupadas em dois grandes pacotes: java.awt (pacote do ncleo) e javax.swing (pacote de extenso). Os dois pacotes definem componentes com peculiaridades distintas e que sero 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 verso do Swing de dilogo e descende diretamente dessa classe. Como dilogo, ele usa BorderLayout por padro. Como JFrame e JWindow, JDialog contm uma hierarquia rootPane incluindo um ContentPane, e permite que os painis de camadas e vidro. Todos os dilogos so modais, o que significa que o atual thread bloqueado at que a interao do usurio com ele tenha sido concluda. JDialog classe destina-se como a base para a criao de dilogos personalizados, no entanto, alguns dos dilogos mais comuns so fornecidos atravs de mtodos estticos na classe JOptionPane. Usamos a classe JDialog, que susbclasse de java.awt.Dialog para criarmos caixas de dilogo elaboradas, embora mais limitados que as originadas por JFrames. Em prol da facilidade, a classe JOptionPane, que est definida no pacote de extenso javax.swing, oferece caixas de dilogo pr-definidas que permitem aos programas exibir simples mensagens para os usurios. Cada vez que usamos uma JOptionPane para implementar um dilogo, na verdade estamos usando uma JDialog nos bastidores. A razo que JOptionPane so simplesmente um continer que pode automaticamente criar uma JDialog e anex-la ao seu painel de contedo. Embora esses dilogos sejam maneiras vlidas de receber entrada do usurio e exibir a sada de um programa, suas capacidades so um tanto limitadas - o dilogo pode obter somente um valor por vez e s pode exibir uma mensagem. Mais usual receber vrias entradas de uma s vez, de modo que o usurio possa visualizar todos os campos de dados. A medida que formos avanando no contedo, o leitor ser capaz de sanar tais deficincias usando novos componentes.

45

As caixas de dilogo podem ser configuradas como modais ou no-modais, valendo-se do mtodo setModal(boolean). As modais no permitem que qualquer outra janela do aplicativo seja acessada at que seja tratada a solicitao ou interveno da caixa de dilogo. O comportamento oposto se observa nas no-modais. Os dilogos exibidos com a classe JOptionPane, por defaut, so dilogos modais. Alm disso, podemos definir se o tamanho de uma JDialog redimensionvel, com o mtodo setResizable(boolean). Obviamente, devido a diversidade de funcionalidades e de construtores, para usarmos todas as potencialidades devemos estudar profundamente as classes em questo. Abaixo mostraremos alguns mtodos estticos da classe JOptionPane (todos so precedidos por JOptionPane).
showInputDialog(String)

Mtodo usado para solicitar a entrada de algum dado em forma de String. Lembre-se que os valores recebidos devem ser atribudos variveis do tipo String e convertidos para outros tipos caso desejarmos realizar operaes sobre eles.
showMessageDialog(Component, Object, String, Icon)

O propsito do primeiro argumento (Component) especifiar a janela-pai para a caixa de dilogo. Um valor null indica que a caixa de dilogo ser exibida no centro da tela. No caso de nossa aplicao apresentar vrias janelas, podemos especificar nesse argumento a janela-pai, de modo que a caixa de dilogo aparecer centralizada sobre a janela-pai especificada, que necessariamente pode no corresponder ao centro da tela do computador. O segundo argumento (object) normalmente especifica o String a ser mostrado ao usurio. A caixa de dilogo comporta qualquer tamanho de String, j que a mesma dimensionada automaticamente para acomodar o texto. Tambm possvel exibir longas sadas baseadas em texto, passando como argumento para o mtodo um objeto da classe JTextArea. O terceiro argumento (String) denomina a barra de ttulo. opcional j que, se forem ignorados o terceiro e o quarto argumento, a caixa de dilogo exibir uma mensagem do tipo INFORMATION MESSAGE, com o texto Message na barra de ttulo e um cone de informao esquerda da mensagem de texto. O quarto argumento (Icon) refere-se a o cone que ser exibido e ao tipo de dilogo de mensagem. Esse cone definido pelo usurio. A tabela abaixo apresenta as "constantes" da linguagem Java para definio dos cones a serem apresentados na tela. cone
Pergunta

Comando

JOptionPane.QUESTION_MESSAGE - Impe uma mensagem que pergunta algo ao usurio JOptionPane.INFORMATION_MESSAGE - Exibe uma mensagem com informaes que podem ser dispensadas. Informao JOptionPane.WARNING_MESSAGE Indica Alerta mensagem de advertncia sobre algum problema em potencial. JOptionPane.ERROR_MESSAGE - Indica mensagem Erro de erro ao usurio. Vazio (somente mensagem) JOptionPane.PLAIN_MESSAGE - Exibe um dilogo que simplesmente contm uma mensagem sem nenhum cone

46

No ltimo argumento podemos definir um cone (classe Icon) que ser exibido junto da caixa de dilogo. Ele deve residir no mesmo diretrio da aplicao ou teremos que especificar o caminho.
showOptionDialog(Component, Object, String, int, int, Icon, Object[ ],Object)

Este mtodo apresenta tudo o que foi descrito no mtodo precedente a ainda suporta a criao de outros botes, para opes personalizadas. Como voc pode observar, os trs primeiros argumentos so os mesmos do mtodo precedente. O quarto refere-se ao conjunto de botes que aparecem abaixo do dilogo. Escolha um a partir do conjunto de valores padro:
DEFAULT OPTION, YES NO OPTION; YES NO CANCEL OPTION, OK CANCEL OPTION.

O quinto argumento aqui o mesmo que o o quarto descrito no mtodo precedente, ou seja, determina o tipo de mensagem exibida no dilogo. O sexto, refere-se ao cone que ser exibido no dilogo. O argumento sequente determina que os botes de opo apaream abaixo do dilogo. Geralmente, especificamos um array de Strings para rotular os botes, sendo que cada elemento do array define um boto. Cada vez que selecionamos um boto, 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 varivel e posteriormente pode-se implementar um processo de deciso que corresponda escolha feita pelo usurio. Finalmente, o ltimo argumento define o boto default a ser selecionado. 1.3.1.1.1. JOptionPane A classe JOptionPane pode ser usada para criar dilogos modais simples, que permitem a costumizao de cones, ttulos, textos e botes. JOptionPane faz com que seja fcil exibir um dilogo padro que leia um valor do usurio ou informe-o de algo. Entretanto, a maioria dos usos desta classe so simplesmente chamadas de uma nica linha para um dos mtodos estticos showXxxDialog. Os tipos de caixas de dilogo so: showInputDialog mostra a caixa de entrada do texto; showMessageDialog mostra o texto digitado; showConfirmDialog solicita confirmao; showOptionDialog oferece opes. 1.3.1.1.2 showInputDialog JOptionPane.showInputDialog("Titulo"): Mostra uma caixa de dilogo e solicita a digitao de um dado; 47

1.3.1.1.3 showMessageDialog JOptionPane.showMessageDialog(null,"Titulo" + variavel): Mostra uma caixa de dilogo com o dado digitado e o null o componente pai, utilizado para especificar a posio de criao 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 dilogo simples e objetiva do JOptionPane a caixa de dilogo de confirmao ou Confirm Dialog. A Confirm Dialog (caixa de confirmao) consiste de uma caixa contendo uma mensagem, um cone e trs botes: sim, no e cancelar. Apesar deste ser o aspecto padro, esta caixa, como qualquer outra de JOptionPane, pode ser facilmente configurada (assunto que ser tratado com mais detalhes nas prximas aulas). No mtodo padro chamado showConfirmDialog usamos dois argumentos: 48

1. O primeiro a dependncia ou frame pai, ou seja, de qual janela esta confirmao est sendo gerada. Como nossos exemplos iniciais no possuem nenhuma dependncia, ento, sempre usaremos null neste argumento. 2. O segundo argumento a mensagem que desejamos mostrar ao usurio. O mtodo showConfirmDialog sempre retorna uma constante que a resposta clicada pelo usurio, que so:

Valor 0 1 2

Nome da Constante YES_OPTION NO_OPTION CANCEL_OPTION

Equivale ao clicar no boto Yes (sim) ao clicar no boto No (no) ao clicar no boto 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 no nome " + nome); } if (resposta == JOptionPane.CANCEL_OPTION){ JOptionPane.showMessageDialog(null, "Opo candelada!");

49

} } }

1.3.1.1.5 showOptionDialog As caixas de dilogo de opo so geradas a partir do mtodo showOptionDialog() e so bem complexas. So capazes de combinar todos os recursos j vistos nas outras caixas de dilogo. Sintaxe:
JOptionPane.showOptionDialog(Component, <mensagem>, <ttulo da mensagem>, <botes presentes>, <tipo de mensagem>, <cone>, <array de objetos>, <seleo padro>).

Exemplo3:
opcao = JOptionPane.showOptionDialog(null,"Escolha a operao","Operao", 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 operao","Operao", 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 Subtrao: " + (vlrNum1 - vlrNum2)); } else if (opcoes[opcao].equals("Multiplicar")){ JOptionPane.showMessageDialog(null, "Valor da Multiplicao: " + (vlrNum1 * vlrNum2)); } else if (opcoes[opcao].equals("Dividir")){ JOptionPane.showMessageDialog(null, "Valor da Diviso: " + (vlrNum1 / vlrNum2)); } } }

No cdigo acima, temos o seguinte: Primeiro, foi criado um vetor de Strings chamado opcoes. Nele, foi guardado uma srie de textos para usar dentro dos botes da minha caixa de opes. Depois, foi declarado uma varivel int chamada opcao, onde ficar guardada a escolha que o usurio fizer. A esta varivel, atribudo diretamente o valor da operao de JOptionPane.showOptionDialog. Veja que ele tem vrios argumentos. Na ordem, temos: o objeto pai, a mensagem, o ttulo, o tipo de opo (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 botes (no caso, o vetor opcoes" que eu acabara de criar), e em seguida, a opo que vem destacada comodefault (no caso, coloquei a primeira). Na linha final do programa, eu simplesmente mandei exibir uma JOptionPane.showMessageDialog comos seguintes argumentos:Componente pai: null.Mensagem: o texto do vetor opcoes", no ndice que corresponde opo clicada (ou seja, vai aparecer o texto do boto clicado). Ttulo: Opo escolhida Tipo de mensagem: WARNING_MESSAGE Onde:

Botes presentes: 51

Um tipo de caixa que utiliza as variveis YES_NO_OPTION, YES_NO_CANCEL_OPTION ou OK_CANCEL_OPTION. Deve-se utilizar o 0 (zero) caso outros botes sejam utilizados no lugar destes. Tipo de mensagem: Uma das variveis de pergunta, informao, alerta, ou erro (QUESTION_MESSAGE, INFORMATION_MESSAGE, WARNING_MESSAGE, ERROR_MESSAGE, PLAIN_MESSAGE); cone: Um objeto ImageIcon a ser apresentado no lugar de um dos cones do argumento anterior (<tipo de mensagem>). Se nenhum cone for usado, deve-se colocar a palavra "null" no lugar desse argumento. Array de objetos: um array de objetos que contm os componentes ou outros objetos que representam as escolhas da caixa de dilogo, caso YES_NO_OPTION, YES_NO_CANCEL_OPTION ou OK_CANCEL_OPTION no esteja sendo utilizado. Seleo Padro: O objeto que representa a seleo padro, caso as opes YES_NO_OPTION, YES_NO_CANCEL_OPTION ou OK_CANCEL_OPTION no 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, "Informao", JOptionPane.INFORMATION_MESSAGE); System.exit(0); } }

53

1.3.1.2 Exerccios 01 De acordo com o diagrama abaixo, construa uma classe chamada Pessoa (encapsulada) com os respectivos mtodos gets e sets em um programa Java com swing usando os recursos showInputDialog() (entrada de dados) e showMessageDialog() (sada 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 devero 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 mtodos 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, faa um programa em Java, usando os recursos do swing, que gere e imprima as seguintes informaes: 1 Valor total do preo de custo; 2 Valor total do preo de vendas; 3 Lucro mdio apurado. 04 - Considerando a classe FolhaPagamento com os atributos float salario, float gratificao, float faltas, float impostoRenda, float salBruto e float salLiquido, faa um programa em Java usando os recursos do Swing para calcular o salrio bruto e o salrio lquido. Aps o input dos dados o programa dever pedir confirmao para efetuar o clculo e imprimir o valor do salrio lquido. Obs. 54

Salrio liquido = salrio bruto (soma dos proventos) soma dos descontos; O percentual do imposto de renda e de 10%; Fazer uso dos mtodos get e set (encapsulamento). 05 - Fazer um programa em Java que leia o valor mximo em dlares 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 dlares) dever ser declarado como constante (final). 07 Considere a classe Figura com os seguintes atributos: raio e lado, os mtodos calculaArea e calculaPerimetro, O programa dever calcular a rea ou o permetro. Uma caixa para a escolha da operao deve ser disponibilizada. Clculo da rea: Circulo: raio * raio * 3.1416 Quadrado: lado ao quadrado Calculo do permetro: 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 verso do Swing of Frame e descende diretamente dessa classe. Os componentes adicionados ao quadro so referidos como o seu contedo, as quais so 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 mtodo main cria um objeto da classe e chama o mtodo show() para que a janela seja exibida. JFrame Esta classe define objetos que so frequentemente utilizadas para criar aplicativos baseados em GUI. Eles consistem em uma janela com barra de ttulo e uma borda e fornecem o espao para a GUI do aplicativo ser construda. A classe JFrame uma subclasse de java.awt.Frame, que por sua vez subclasse de java.awt.Window. Pelo mecanismo de herana, nota-se que JFrames so um dos poucos componentes GUI do Swing que no so considerados de peso-leve, pois no so escritos completamente em Java. Sendo assim, quando possvel, 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 grfica do sistema em questo. Para exibir um ttulo na barra de ttulo de uma JFrame, devemos chamar o construtor de superclasse de JFrame com o argumento String desejado, dessa forma:
super("Ttulo da Barra");

A classe JFrame suporta trs operaes quando o usurio fecha a janela. Por default, a janela removida da tela (ocultada) quando o usurio intervm indicando o seu fechamento. Isso pode ser controlado com o mtodo 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 usurio 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 verso 1.3 da Plataforma Java. A janela s ser exibida na tela quando o programa invocar o mtodo setVisible(boolean) com um argumento true, ou o mtodo show(). O tamanho da janela configurado com uma chamada ao mtodo setSize(int x, int y), que define nos valores inteiros dos argumentos a largura e a altura da mesma. Se no chamarmos esse mtodo, somente a barra de ttulo ser exibida. Tambm podemos utilizar o mtodo pack(), que utiliza os tamanhos preferidos dos componentes anexados ao painel de contedo para determinar o tamanho da janela. Por tamanho 56

preferido, entende-se uma chamada realizada pelos gerenciadores de leiaute ao mtodo getPreferredSize() de cada componente GUI. Esse mtodo 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 evocao. Ela devolve um objeto da classe Dimension (pacote java.awt). dos mtodos setMinimumSize(Dimension) e setMaximumSize(Dimension), que estabelecem os tamanhos extremos dos elementos. O componente no deveria ser maior que o tamanho mximo e nem menor que o mnimo. Entretando, esteja consciente de que certos gerenciadores de leiaute ignoram essa sugesto. Podemos fazer uso 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 mtodo getPreferredSize( ), fazendo com que ele retorne um objeto Dimension que contenha a nova largura e altura do componente, ou usar o mtodo
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 caracterstica com o mtodo setLocation(int x, int y). Mtodos 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 ttulo na barra de ttulo da janela; public void show(): Faz o frame aparecer na tela; public void setVisible(boolean v): Faz com que o frame se torne visvel (v=true) ou no (v=false); public void setDefaultCloseOperation(int op) : o Faz a janela realizar uma determinada operao 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 So reas que comportam outros componentes, inclusive outros painis. Em outras palavras, so elementos que fazem a intermediao entre um continer e os demais GUI anexados. So criados com a classe JPanel, que derivada da classe Container. As JPanel possibilitam a criao de subconjuntos num continer de forma a garantir um maior domnio sobre todas as reas da interface. A classe JPanel no tem painel de contedo como applets e JFrames, assim, os elementos devem ser diretamente adicioandos ao objeto painel. Alm 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 mtodos. Cabe lembrar que JPanel no suportam eventos convencionais suportados por outros componentes GUI, como botes, campos de texto e janelas. Apesar disso, JPanel so capazes de reconhecer eventos de nvel mais baixo, como eventos de mouse e de teclas. 1.3.4 JLabel So rtulos inertes que geralmente informam ou descrevem a funcionalidade de outros componentes GUI, como por exemplo, campos de texto, cones, etc. As instrues so mostradas por meio de uma linha de texto somente leitura, uma imagem, ou ambos. Aqui salientamos o uso do mtodo setToolTipText(String), o qual fornece dicas de ferramenta a todos os elementos herdados da classe JComponent. Dessa forma, quando o usurio posicionar o cursor do mouse sobre algum componente, ficar ciente da funo do mesmo. Veremos isso nos exemplos.

58

O contrutor mais elaborado JLabel(String, Icon, int). Os argumentos representam o rtulo a ser exibido, um cone e o alinhamento, respectivamente. Como vemos, tambm possvel a exibio de cones em muito dos componentes Swing. Para JLabels, basta especificarmos um arquivo com extenso png, gif ou jpg no segundo argumento do construtor do JLabel, ou utilizarmos o mtodo setIcon(Icon) Lembramos que o arquivo da imagem algum Nome.xxx deve encontrar-se no mesmo diretrio do programa, ou especificase corretamente a estrutura de diretrios at ele. Principais mtodos: public JLabel(String text): Cria um novo label com o texto dado como parmetro 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 vrios componentes GUI e aqui so apropriadas ao terceiro argumento, determinam a locao do cone em relao ao texto. So 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.

No iremos detalhar a funcionalidade de cada uma, pois os nomes j so 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 atravs de gerenciadores de layout. O AWT possui cinco ou seis gerenciadores de layout: FlowLayout; BorderLayout; GridLayout; BoxLayout; CardLayout; GridBagLayout; SpringLayout.

Os gerenciadores de layout so utilizados para organizar os componentes GUI em um Container, para o propsito de apresentao. 1.3.5.1 FlowLayout FlowLayout o gerenciador de layout mais bsico, os componentes so adicionados da esquerda para a direita no Container, na ordem em que so adicionados at atingir a borda do Container, onde continuam na prxima 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 orientao do Container); TRAILING: Indica que cada linha de componentes deve ser alinhada com o ltimo lado de seuContainer (levando-se em conta a orientao do Container); O FlowLayout o padro 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 so adicionados ao container da forma similar a um texto em um pargrafo, permitindo que cada componente mantenha seu tamanho natural. Como padro, os componentes so horizontalmente centralizados no container. possvel mudar esse padro de alinhamento especificando um valor alternativo como parmetro para um dos construtores da classe ou para o mtodo setAlignment(). Esse parmetro pode assumir um dos valores constantes definidos na classe, tais como LEFT ou RIGHT. possvel tambm modificar a distncia em pixels entre os componentes arranjados atravs desse tipo de gerenciador com os mtodos setHgap() e setVgap(); alternativamente, esses valores podem tambm ser especificados atravs de construtores da classe FlowLayout. Para obter os valores utilizados, h mtodos 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 Botes 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 implementao de LayoutManager2 adequado para janelas com at cinco componentes. Ele permite arranjar os componentes de um container em cinco regies, 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 Botes BorderLayout"); }

62

public void BorderLayoutTest(){ botao1 = new JButton("Boto Norte"); botao2 = new JButton("Boto Centro"); botao3 = new JButton("Boto Oeste"); botao4 = new JButton("Boto Sul"); botao5 = new JButton("Boto Leste"); add(botao1, BorderLayout.NORTH); add(botao2, BorderLayout.CENTER); add(botao3, BorderLayout.WEST); add(botao4, BorderLayout.SOUTH); add(botao5, BorderLayout.EAST); } public static void main(String args[]){ Exemplo1BorderLayout border = new Exemplo1BorderLayout(); border.BorderLayoutTest(); border.setSize(400, 200); border.setVisible(true); border.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); } }

Exemplo2 BorderLayout:

package programas; import java.awt.BorderLayout; import javax.swing.JFrame; import javax.swing.JLabel; import javax.swing.JPanel; public class Exemplo2BorderLayout extends JFrame{ JPanel painel1,painel2,painel3,painel4,painel5; JLabel msg1,msg2,msg3,msg4,msg5; public Exemplo2BorderLayout(){ super("Exemplo JFrame JLabel"); } public void criaJanela(){ painel1 = new JPanel(); painel2 = new JPanel();

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 so 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 clculo, 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 retngulos de tamanho igual, e um componente colocado em cada retngulo. 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 Botes GridLayout"); } public void GridLayoutTest(){ setLayout(new GridLayout(3, 2)); // 3 linhas, 2 colunas botao1 = new JButton("Boto 1"); botao2 = new JButton("Boto 2"); botao3 = new JButton("Boto 3"); botao4 = new JButton("Boto 4"); botao5 = new JButton("Boto 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, porm arranjos de componentes bem complexos podem ser obtidos atravs da combinao desses componentes. Em BoxLayout os componentes mantm sua dimenso natural, como em FlowLayout. A direo na qual os componentes sero 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, atravs respectivamente das

Tipicamente, esse tipo de layout no utilizado diretamente, mas sim atravs de um container do tipo Box , que adota BoxLayout como padro 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 Botes 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("Boto JButton("Boto JButton("Boto JButton("Boto JButton("Boto 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("Avanar"); 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("Prximo"); 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("prximo"); 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 clulas com cada componente ocupar uma ou mais clulas, chamado de sua rea de exibio. A rea de exibio 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 insero ou exibio de texto. Podemos definir se o texto pode ser manipulado com o mtodo setEditable(boolean), utilizando no argumento o valor true. Quando o usurio digita os dados em uma JTexField e pressiona Enter, ocorre um evento de ao. Esse evento processado pelo ouvinte de evento registrado que pode usar os dados que esto 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 edio 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 usurio. Textfields so usados geralmente para entrada de dados pelo usurio. Mtodos interessantes: o public JTextField(int columns): Cria um novo textfield com uma largura, em caracteres, dada pelo parmetro. 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 parmetro.

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("Formulrio 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 Endereo:"); 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 criao 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 Exerccios 01 De acordo com exemplo1 do item 1.3.6, alterar o layout do formulrio para o modelo abaixo, usuando os recursos do Java Swing. Antes:

Depois:

02 De acordo com a figura abaixo, faa um programa usando recursos do Java Swing para formatar o formulrio abaixo.

74

03 Alterar o programa anterior (02) e acrescentar o Curso e a Disciplina do aluno.

04 De acordo com a figura abaixo, faa um programa usando recursos do Java Swing para formatar o formulrio a baixo.

75

05 De acordo com a figura anterior (exerccio 04), faa um programa usando recursos do Java Swing para modificar e formatar o formulrio a baixo.

06 De acordo com a figura, faa um programa usando recursos do Java Swing para formatar o formulrio a baixo.

76

1.3.7 Listas (JComboBox) JComboBox como uma caixa suspensa . Voc pode clicar em uma seta drop-down e selecionar uma opo 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("Formulrio para cadastro de Pessoa"); } public void init(){ JPanel painel = new JPanel(); //Definir o contedo 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 Endereo:");

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 criao 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 Botes A interface ActionListener especifica o mtodo actionPerformed() para tratar eventos do tipo ao. Um objeto de uma classe que implemente essa interface deve ser associado a um componente atravs do mtodo addActionListener(), que definido para componentes do tipo boto, lista e campo de texto. Neste item veremos o evento associado a um boto. Quando um evento desse tipo ocorre, o objeto registrado notificado. O mtodo actionPerformed() ento invocado, recebendo como argumento o objeto que representa o evento. interface ActionListener mtodo actionPerformed()
botao.addActionListener(new NomeDaClasse());//Adicionado o evento ao botao private class NomeDaClasse implements ActionListener{ @Override public void actionPerformed(ActionEvent e) { instruoes........ } }

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; private JTextField txtNome; private JTextField txtEndereco; private JComboBox cmbEstadoCivil; public Exemplo3AcaoBotao() { super.setTitle("Formulrio para cadastro de Pessoa"); } public void init(){ JPanel painel = new JPanel(); //Definir o contedo que ser adicionado ao JFrame setLayout(new FlowLayout(FlowLayout.LEFT)); GridLayout layout = new GridLayout(5, 2, 10, 10); painel.setLayout(layout); JLabel lblCpf = new JLabel("Informe Cpf:"); txtCpf = new JTextField(15); painel.add(lblCpf); painel.add(txtCpf); JLabel lblNome = new JLabel("Informe Nome:"); txtNome = new JTextField(15); painel.add(lblNome); painel.add(txtNome); JLabel lblEndereco = new JLabel("Informe Endereo:"); txtEndereco = new JTextField(15); painel.add(lblEndereco); painel.add(txtEndereco); JLabel lblEstadoCivil = new JLabel("Estado civil:"); painel.add(lblEstadoCivil); //Vetor de String para alimentar o campo ComboBox String[] opcoes = new String[] { "Solteiro", "Casado", "Separado", "Desquitado", "Viuvo"}; cmbEstadoCivil = new JComboBox(opcoes); painel.add(cmbEstadoCivil); JButton btnCadastro = new JButton("Imprimir Dados");

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.getText() + "\nNome: " + txtNome.getText() + "\nEndereo: " + txtEndereco.getText() + "\nEstado Civil: " + cmbEstadoCivil.getSelectedItem()); } } public static void main(String[] args) { Exemplo3AcaoBotao tela = new Exemplo3AcaoBotao(); tela.init(); //Inicializa a criao 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 Exerccios 01 De acordo com o formulrio abaixo, imprimir os dado digitados usando o boto de evento do Java Swing.

02 De acordo com a figura abaixo, faa um programa usando recursos do Java Swing para formatar o formulrio e calcular a mdia das duas notas. Uma caixa de dilogo dever mostrar a mdia calculada.

84

03 De acordo com a figura abaixo, faa um programa usando recursos do Java Swing para formatar o formulrio a baixo e informar o valor do salrio lquido (salario + gratificao faltas).

04 De acordo com a figura anterior (exerccio 03), faa um programa usando recursos do Java Swing para formatar o formulrio a baixo. Ao final mostrar o valor do contracheque. valorContraCheque = salario + gratificao + abono + horaExtra + frias + salarioFamilia faltas atrasos inss - impostoRenda

85

05 De acordo com a figura, faa um programa usando recursos do Java Swing para formatar o formulrio a baixo. Ao final informar o valor das compras.

86

06 De acordo com a figura, faa um programa usando recursos do Java Swing para formatar o formulrio a baixo. Ao final imprimir os dados digitados.

07 De acordo com a figura, faa um programa usando recursos do Java Swing para formatar o formulrio a baixo. Ao final imprimir os dados digitados.

87