Apostilajava PDF

AUTOR (ERA S O QUE FALTAVA)...
Fbio Burch Salvador

O PRIMEIRO E NICO
LOUCADEMIA
DE JAVA
J2SE
OU
ENCICLOPEDIAE JAVALISTICUS UNIVERSALIS
UM GUIA PARA QUEM NO SABE NADA DA LINGUAGEM JAVA, MAS QUER

APRENDER. VOC COMEA A LER APENAS COM CONHECIMENTOS BEM
BSICOS EM LGICA DA PROGRAMAO, E TERMINA A LEITURA
DESENVOLVENDO SISTEMAS EMPRESARIAIS COMPLETOS S QUE VAI
DAR TRABALHO, CLARO!
ENTO, SE VOC ESTIVER AFIM DE VAGABUNDAGEM, V TENTAR UMA
CARREIRA POLTICA OU ALGO ASSIM. OU VIRE HIPPIE.
Loucademia de Java Verso 1.0
Homem de preto, qual a

sua misso?
aprender logo Java e tirar

Certificao!
Homem de preto, o que

que voc faz?
Escrevo um cdigo fonte

que apavora o Satans!
Powered by
Luisius
WWW.FABIOSALVADOR.COM.BR - Pgina 2
Fbio Burch Salvador
Prefcio
Este livro serve para as pessoas aprenderem a programar em Java. Especificamente, J2SE,
programao para desktop. No um livro para ser lido na cama ou no banheiro. No um livro para
ler no nibus. um livro que tem muitos cdigos e portanto preciso baixar uma IDE e testar os
exemplos. S se aprende a programar programando.
O contedo deste volume foi ordenado seguindo o critrio mais correto de todos - o critrio da prtica.
Ele apresenta as aulas de Java ministradas pelo autor, da maneira como ele gostaria de ter feito caso
tivesse tempo e o curso no fosse curto demais. As explicaes usam uma linguagem informal, solta, e
possivelmente possuem erros de concordncia em diversos pontos.
Este livro antes de mais nada um livro escrito s pressas, em horrios livres, de intervalos para o
lanche ou na madrugada antes do incio das aulas. Portanto, mancadas no portugus devem ser
perdoadas. o livro escrito por algum que passa o tempo todo na mais absoluta pressa. , na
verdade, o ltimo trabalho feito por mim sob estas condies. As prximas obras sero mais
calmamente escritas.
Espero que sirva para os iniciantes e at para quem j conhece alguma coisa de Java.
PreDifcil
Voc pode achar Java uma linguagem complicada. No . Voc pode achar que Orientao a Objetos
um bicho de sete cabeas. No . Tudo isso muito simples. Eu vou tentar fazer parecer ainda mais
simples. Trata-se de lgica natural.
Mas eu aviso: preciso abstrair algumas noes para compreender o que se vai ler aqui. No se pode
pensar em classes como salas ou como caixas. Em objetos como variveis, como valores ou sei l o
que. preciso compreender que estamos lidando com coisas abstratas, que a princpio representam
coisas reais, mas no SO reais. Portanto, comportam-se como aquilo que so: idias. Uma classe
uma idia de um tipo de coisa. Um objeto a idia de um objeto. E uma instncia de sua classe. Um
mtodo, o qu? Uma funo? Mais ou menos. Mas tambm uma o em potencial do objeto. Ou da
classe, se for esttico.
Pode parecer difcil mas no . Poderia ser pior. Os comandos, todos palavras em ingls, poderiam ser
escritos em alemo. A sim a cobra iria fumar!
And we should consider every day lost on

which we have not danced at least once. And
we should call every truth false which was not
accompanied by at least one laugh.
(Devemos considerar perdido um dia em que no danamos
pelo menos uma vez. E mentirosa toda a verdade que
no vier acompanhada de pelo menos uma risada)
Friedrich Nietzsche Em ingls
The book is on the table.

(Penso, logo existo.)
Scrates Em portunhol
Pgina 3 - WWW.FABIOSALVADOR.COM.BR
O autor quem esse cara?
Fbio Burch Salvador nasceu em 1981, em Porto Alegre. viciado em
informtica desde guri, mais precisamente desde o dia em que colocou
as mos em um XT na firma onde o pai trabalhava. Programador desde
os 13 anos (o pai tinha um 286) comeou no Basic desenvolvendo
Games cabulosos tirando sarro de amigos e conhecidos. Mais tarde,
evoluiu, desenvolvendo ento outras coisas medonhas em outras
linguagens. Mas tambm desenvolveu muita coisa boa, sistemas
empresariais principalmente - e apostilas!
Programa Basic, VB, JavaScript, Pascal, PHP, Java. Monta sites
escrevendo HTML e CSS no Bloco de Notas. Aprendeu Flash sozinho. E
tambm Photoshop, Corel Draw, SQL, e tudo mais. Incrivelmente, tem apenas um curso - de AutoCAD (?) - ele que
rodou na stima srie exatamente por no saber nada de geometria e nem a Frmula de Bskhara (que ele alis no
domina at hoje).
formado em Jornalismo desde 2005 pela PUC de Porto Alegre. Por qu logo Jornalismo? Ningum sabe. Nem ele.
Apaixonado pelas cmeras, teve at uma curta carreira como cineasta, dirigindo 4 curtas-metragens, todos dignos de um
Cine Trash .
Defensor implacvel do DOS nos anos 90, acabou rendendo-se. Prdigo em criar bordes, Fbio criou frases de efeito
que ficaram na Histria de todos os lugares pode onde passou. Iniciou sua vida profissional "pegando" uma srie de
empregos variados, mais ou menos no estilo Seu Madruga. Foi, entre outras coisas, digitador de cadastro nas Lojas
Renner, tcnico de fiscalizao da Anatel, estagirio na Prefeitura de Porto Alegre, monitor de laboratrio na PUC, e s
no foi astronauta porque o Brasil no tinha programa espacial.
Em 2004, fundou um pasquim em Viamo/RS chamado "A Cidade". O jornal sagrou-se como o mais polmico no
municpio, tinha o desenho mais estiloso e foi o primeiro a ter um site. Bagunou a vida dos polticos locais e estampou
manchetes gritantes em capas surrealistas at seu fechamento no incio de 2006. Fbio ento passou a colaborar no "de-
vez-em-quandrio" Correio Viamonense, outro pasquim ainda mais meftico do que o primeiro. Virou sub-celebridade
local e passou a ser sistematicamente convidado pelos partidos polticos em tudo que eleio.
Ainda buscando uma carreira de comunicador, tentou a sorte na redao do site Terra, como redador temporrio. Em
seguida, cansou-se de nunca ter grana para nada e resolveu abandonar o jornalismo. Voltou a dedicar-se informtica.
Deu o arriscado passo da troca de carreira e acertou na mosca.
Como desenvolvedor de softwares, sua falta de instruo formal na rea foi facilmente esquecida por todos os que o
empregaram porque, afinal de contas, seus programas funcionam.
Agraciado com o Prmio McGyver da Programao, Fbio foi professor no Senac em So Leopoldo, ensinando sua arte
softwarstica e tornando seus alunos to pirados quanto ele. Acabou tambm ensinando design, liderana, oratria,
administrao e outras coisas mais. Saiu do Senac por vontade prpria em 2008 para dedicar-se a programar em turno
integral. No que no goste de dar aulas. Teve seu$ motivo$ pe$$oai$.
Desde o comeo e sempre, teve principalmente a ajuda indispensvel de seus pais, que sempre o incentivaram a ir em
frente e at a levantar nas inmeras vezes em que caiu. Mais tarde, iria somar-se neste esforo de apoio sua namorada
que virou esposa. Apesar de serem todos pessoas bem mais "normais" e discretas do que o autor deste livro, sempre
tentaram compreend-lo. Ele que por vezes incompreensvel. E que incompreensivelmente conseguiu achar seu
caminho na vida.
Fbio casado, tem uma filha, um gacho urbano criado na Capital e nunca andou a cavalo. No sabe tocar gaita. E
no usa pilcha. Mas sabe assar churrasco, provando mais uma vez que a convenincia a me da sabedoria.
Continua programando, atuando na rea do ensino e dedica-se tambm a escrever. E ainda por cima mantm seu "lado
jornalista" vivo no site que mantm na Internet e cujo jab j foi feito neste livro. Projeta carros espalhafatosos em
AutoCAD 3D (e publica os projetos na Internet). s vezes, filosofa. Tambm mete-se na poltica. E at escreve sobre
teologia.
Ainda no plantou uma rvore. Mas j teve um filho. E agora acaba de escrever um livro.
Fbio Burch Salvador
Agradecimentos
Este livro no teria sido escrito sem a ajuda de algumas pessoas. Em primeiro lugar, quero agradecer minha esposa Fabiana
por me aturar nos tempos em que passei concentrado escrevendo, minha filha Camila por me trazer bolachinhas e beijos
enquanto eu escrevo, aos meus pais que sempre me apoiaram e no final so os verdadeiros responsveis por eu estar aqui
hoje escrevendo. Ao meu cunhado Ismael por consertar meu PC nas vezes em que ele apresentou problemas. minha sogra
por me aturar. Ao meu sobrinho Raphael por me alegrar, e minha irm ngela por ter crescido ao meu lado e ter participado
de quase todos os momentos mais importantes da minha vida. Novamente minha me por sempre me dar fora e ao meu pai
por me incentivar a aprender Basic.
Tambm quero homenagear meus alunos do Senac, tanto a galera do Java e do PHP, sempre formando turmas de pessoas
divertidas, o que me estimulava a aprender mais para ensinar mais. E tambm gurizada da Aprendizagem Comercial: Manu,
Luan, Douglas, Alemo, Frajola, Tainara, Francine, Alisson, Elvis, Pri, e todo o resto da gurizada medonha. Ah, e claro, a Deize
que veio da capital tecnolgica do mundo Ocidental, Crissiumal. Essa gurizada, com seu jeito barulhento e impulsivo, acabou
tornando a mim mesmo mentalmente mais jovem (o papel de professor estava a envelhecer-me aos poucos) e me fez ver que
eu no poderia acomodar-me to cedo, que deveria ser mais confiante e construir meu futuro com ambies maiores e, no fim,
causaram eles mesmos a perda de seu professor de todas as tardes.
Tambm homenageio aos colegas do Senac, a Raquel, o Alexandre, o Antonio, o Alisson, a Pati, a Su, e todos os outros
malucos que dividiram comigo um ano absolutamente divertido e edificante. E, claro, ao Nelson e Carla, que na direo da
escola souberam lidar com pessoas como, por exemplo, eu o que sei ser uma misso casca-grossa.
Mando tambm um al especial para a galera do Espiral, da WaySys, da Memo e de todos os lugares onde eu pude
desenvolver sistemas, aprimorando-me no decorrer do caminho.
Tambm quero agradecer a Steve Wozniak, que inventou o computador pessoal. Ao Bill Gates, por ter criado um sistema
operacional simplesmente maravilhoso. E ao Linus Torvalds pelo mesmo motivo.
Quero agradecer a Jesus Cristo, sem o qual ns hoje seramos Zoroastristas ou mais provavelmente Mitrastas se no
fssemos uns tribais animistas danando seminus em vota de uma pedra e sacrificando virgens ao deus Dagon quando se
sabe que virgens tm outra utilidade bem melhor.
No posso tambm deixar de agradecer a mim mesmo, pessoa sem a qual este texto no se auto-escreveria sozinho.
E quero agradecer a vocs, que j leram umas quantas pginas e ainda no viram nada de Java. Mas vero, e no se
arrependero. Ento, vamos ao Java!
Luis, Michel, Bruno,

Mauricio, Sergio e
Diego (faltou o
lendrio Daniel)
turma de
Java de 2008
Dejair, Clauber,
Pozzebon e eu -
turma de
Java em 2007
Import java.livro.JIndice
class Livro_do_Java {
static JIndice ind;
public static void main (String[]args) {
ind = new JIndice();
ind.listar();
ndice
Prefcio....................................................................................................................................................3
PreDifcil...................................................................................................................................................3
O autor quem esse cara?..................................................................................................................4
Agradecimentos......................................................................................................................................5
ndice........................................................................................................................................................6
Nomenclaturas e badulaques.................................................................................................................8
Java a JavaScript.....................................................................................................................................................8
O que uma API......................................................................................................................................................8
J2SE, J2EE e J2ME.................................................................................................................................................8
Java Virtual Machine (JVM).....................................................................................................................................9
Java Developer Kit (JDK).........................................................................................................................................9
O que uma IDE......................................................................................................................................................9
Palavras Reservadas...............................................................................................................................................9
Coleta automtica de lixo.......................................................................................................................................10
Classes e objetos..................................................................................................................................11
Explicao Wikipdica............................................................................................................................................11
Explicao no popular..........................................................................................................................................12
Padres bsicos de programao Java..............................................................................................15
Principais tipos de dados.......................................................................................................................................15
Usando chaves.......................................................................................................................................................15
Fazendo clculos....................................................................................................................................................15
Comparaes.........................................................................................................................................................16
Concatenando condies.......................................................................................................................................16
Montando um programa simples.........................................................................................................17
Sintaxes principais................................................................................................................................18
Laos de repetio.................................................................................................................................................18
Estruturas condicionais..........................................................................................................................................19
Aplicando Orientao a Objetos..........................................................................................................21
Instanciando uma classe........................................................................................................................................21
Herana..................................................................................................................................................................23
Polimorfismo...........................................................................................................................................................25
Modificadores .......................................................................................................................................26
Static.......................................................................................................................................................................26
Public......................................................................................................................................................................26
Private.....................................................................................................................................................................26
Final........................................................................................................................................................................26
Protected................................................................................................................................................................27
Pacotes...................................................................................................................................................28
Tratamento de erros e excees..........................................................................................................29
Throw informado os erros classe que instanciou o objeto...............................................................................30
Tipos de Excesso.................................................................................................................................................31
Escrevendo dados em arquivos textos e lendo eles de volta............................................................32
Tokenizer (caracteres separadores)......................................................................................................................34
Mtodos da classe StringTokenizer:......................................................................................................................35
Tocando sons em Java.........................................................................................................................36
A classe Console...................................................................................................................................38
Sobrepondo mtodos uma tcnica essencial.....................................................................................................40
Interface grfica em Java......................................................................................................................41
Bibliotecas AWT e SWING.....................................................................................................................................41
Nossa primeira tela.................................................................................................................................................41
Fbio Burch Salvador
JLabel.....................................................................................................................................................................43
JButton....................................................................................................................................................................44
JTextField...............................................................................................................................................................45
JFormattedTextField...............................................................................................................................................46
JToggleButton........................................................................................................................................................47
Icon.........................................................................................................................................................................48
JOptionPane...........................................................................................................................................................49
Tipos de mensagem:..............................................................................................................................................50
showConfirmDialog................................................................................................................................................51
showOptionDialog..................................................................................................................................................52
showInputDialog.....................................................................................................................................................53
JMenuBar, JMenu e JMenuItem............................................................................................................................54
JCheckBox.............................................................................................................................................................55
JRadioButton..........................................................................................................................................................57
JComboBox............................................................................................................................................................59
JTabbedPane.........................................................................................................................................................60
JScrollPane............................................................................................................................................................61
JTables...................................................................................................................................................................62
JFileChooser..........................................................................................................................................................65
JInternalFrame.......................................................................................................................................................67
Tree........................................................................................................................................................................69
Eventos (Listeners)...............................................................................................................................70
ActionListener.........................................................................................................................................................70
FocusListener.........................................................................................................................................................71
KeyEvent................................................................................................................................................................72
MouseListener........................................................................................................................................................73
Uma coleo de pequenos comandos soltos.....................................................................................75
Leitura de dimenses de componentes grficos e da prpria tela........................................................................75
Converso de dados..............................................................................................................................................75
Fazendo uma JFrame sumir, morrer e derrubar o programa................................................................................76
Relaes com o setDefaultCloseOperation...........................................................................................................76
Ordenando a uma JFrame que abra em modo maximizado.................................................................................76
Redimensionando imagens para caberem dentro da JLabel................................................................................77
Colocando uma imagem de plano de fundo dentro do JDesktopPane.................................................................78
Conexo Java + Banco de Dados........................................................................................................81
Criando a aplicao integrada................................................................................................................................84
Consultando o Banco de Dados.............................................................................................................................86
Gravando no BD (Insert e Update).........................................................................................................................87
Java + MySQL........................................................................................................................................................88
A aplicao Java com MySQL integrado...............................................................................................................89
Nota sobre componentes de conexo baixados da Web......................................................................................90
Criando formulrios de impresso com IReport.................................................................................91
Colocando dados no Report...................................................................................................................................94
Montando grupos....................................................................................................................................................97
Testando o Report..................................................................................................................................................99
Botes do IReport...................................................................................................................................................99
Trabalhando com variveis..................................................................................................................................100
Como integrar o JasperReport ao programa Java............................................................................102
Compilando o projeto depois de pronto............................................................................................105
Extras...................................................................................................................................................108
Como chamar um outro programa EXE...............................................................................................................108
Usando impressoras matriciais diretamente........................................................................................................109
Gerando um relatrio com Cdigos de Barra......................................................................................................111
Como ler um cdigo de barras.............................................................................................................................112
Nomenclaturas e badulaques
Vamos ver agora um pequeno glossrio de coisas que precisamos saber antes de comear.
Java a JavaScript
A primeira confuso que existe no mundo Java entre a linguagem Java e o JavaScript. Vamos ver isso
de forma bem clara e objetiva:
JAVA uma linguagem completa, enorme e complexa utilizada para montar aplicaes completas com
acesso a Bancos de Dados constante e fins mais completos. Programar Java exige alguma prtica, e
exatamente para ensinar Java que eu escrevi este livro.
O cdigo JAVA deve ser desenvolvido, testado e depois convertido em Byte-Code, em uma operao
de compilao. O cdigo torna-se ento ilegvel e o usurio no tem acesso s fontes que deram
origem s funcionalidaes.
JAVASCRIPT uma pequena linguagem de scripts usados dentro do cdigo HTML de um site e que
executam pequenas tarefas a serem executadas do lado do cliente na conexo via Internet. O cdigo
aberto e as funcionalidades raramente passam de pequenas validaes de campos em formulrios
HTML ou efeitos de animao limitados.
A nica coisa legal sobre o JavaScript, do ponto de vista do programador Java, que as sintaxes dos
comandos so iguais. Laos de repetio, funes e outros badulaques tm a mesma forma de
escrever que os da linguagem Java.
O que uma API

Uma API uma coleo de componentes de software que j vm prontos e o programa s precisa usar.
Muita gente fala das APIs do Windows, pois possvel chamar estas APIs nos programas. Ns vamos
usar uma API do sistema operacional, l no final do livro.
Vamos criar um arquivo PDF, e da vamos rodar uma API que identificar qual o programa que o
Windows do usurio est utilizando para abrir este tipo de arquivo.
A API do Java uma coleo imensa, absurdamente imensa, de classes reutilizveis com as mais
bizarramente variadas utilidades. Temos, por exemplo, as classes da bibliotecas JAVA.AWT e
JAVA.SWING, que servem para criarmos telas grficas de apresentao para o nosso usurio. Temos a
JAVA.IO, com suas classe usadas para manipular entrada e sada de dados, por exemplo, para
arquivos-texto. Enfim.
As APIs nos economizam tempo, porque no precisamos criar as coisas do zero, fazendo um
movimento semelhante a reinventar a roda. No. Ns vamos usar tudo o que j vier pronto e
desenvolver nossos softwares sem, por exemplo, ter que reinventar o boto clicvel.
J2SE, J2EE e J2ME

So denominaes que damos a trs caminhos para o desenvolvimento de aplicaes na linguagem
Java.
J2SE (Standard Edition) consiste em criar classes, montando um programa executvel, construindo a
interface grfica do programa nessas classes. No final, compila-se o cdigo e temos um arquivo JAR,
que funciona como um executvel em qualquer computador devidamente preparado. Usa-se para fazer
softwares desktop, que operam na tela do computador normalmente.
J2EE (Enterprise Edition) consiste em criar alguns cdigos em arquivos JSP e construir umas classes.
Parece muito com a programao J2SE. Porm a interface grfica feita com o uso de pginas HTML.
Estas pginas tm FORMS cujo boto de ativao aciona as funcionalidades feitas em Java. usado
para desenvolver para a Web.
J2ME (Micro Edition) parecido com o desenvolvimento J2SE, mas no se pode usar uma srie de
Fbio Burch Salvador
funcionalidades, especialmente no que se refere rea de interface grfica. Serve para desenvolver
aplicaes para telefones celulares, palmtops e outros dispositivos mveis.
Java Virtual Machine (JVM)

A Mquina Virtual do Java um software que deve ser baixado e instalado no computador do usurio
para que os programas em Java rodem.
Parece um problema, a princpio, mas aqui que mora a verdadeira vantagem da linguagem Java sobre
as linguagens mais tradicionais.
Uma linguagem tradicional cria um arquivo EXE, executvel, que roda em contato direto com o Sistema
Operacional do computador do usurio. Assim, se o EXE foi compilado para ser usado no Windows, ele
no roda no Linux. Por isso os programas precisam ter vrias verses, uma para Linux, uma para
Windows, uma para Solaris, uma para o Unix, e assim por diante.
J no Java, o programa roda em contato direto com a JVM, e a JVM quem fala diretamente com o
Sistema Operacional. Assim, se eu tiver 3 clientes, um com Linux, um com Windows e um com Solaris,
e os trs forem internet baixar a JVM (que gratuita), meu programa poder ser compilado uma nica
vez, pois funciona em qualquer sistema operacional. Isso maravilhoso. O lema da linguagem java
Write Once, Run Everywhere, ou seja, escreva (o cdigo) uma vez, e rode em todos os lugares.
Java Developer Kit (JDK)

Ah, isso aqui uma mo na roda! O kit de desenvolvimento Java consiste de uma JVM completa e mais
as fontes das classes que formam a API do Java. Assim, temos todo o necessrio para montar, n
computador, um ambiente propcio ao desenvolvimento de aplicaes Java, porque essas classes
prontas da API j vo ficar disponveis para o nosso programa usar.
O que uma IDE

Integrates Development Environments, as IDEs, so, traduzindo, Ambientes de Desenvolvimento
Integrado. Mas o que diabos isso?
So programas muito bons, que nos ajudam a fazer programas. A gente pode escrever cdigo no Bloco
de Notas e depois compilar, mas isso j loucura. Nem eu sou maluco o suficiente para fazer isso.
Existem IDEs muito simples, como o BlueJ, que apenas tem um interpretador capaz de rodar nosso
programa com ele ainda no fechado no arquivo JAR. Assim, podemos testar tudo antes de acabar o
projeto.
Existem IDEs bem mais complexas, como o NetBeans e o Eclipse. No Eclipse, por exemplo, quando a
gente escreve o nome de uma classe qualquer ou de um objeto pertencente a uma classe, aparecem na
tela os mtodos daquela classe em uma lista bem bonitinha, para a gente clicar. Isso nos poupa de ter
que decorar, de cabea, todos os mtodos. Essas IDEs tambm corrigem nossos erros, marcando
eles com sublinhados vermelhos, e possuem assistentes de compilao que nos ajudam a montar o
arquivo JAR sem que ns tenhamos que escrever um arquivo de parmetros na mo.
IDEs so, a grosso modo, editores que ajudam a gente a fazer cdigo sem errar tanto.
Palavras Reservadas
Existem algumas palavras em Java que no poderemos usar para designar classes, variveis ou
qualquer outro tipo de coisa. Essas palavras so comandos nativos da linguagem:
abstract continue for new assert default goto package boolean do if private break double implements
protected byte else import public case enum instanceof return catch extends int short char final
interface static class finally long strictfp const float native super true false null
Coleta automtica de lixo
Java uma linguagem para l de inteligente. Surgiu em 1995, e veio com essa histria de lixo. O que
isso?
Simples! Nas linguagens de antigamente, ns crivamos a varivel X e precisvamos, quando no mais
a quisssemos usar, destru-la para desocupar memria. No Java, isso no acontece. Quando X deve
cair fora, ela cai.
E mais: se antes a varivel X ficava com lixo das atribuies de valor anteriores, hoje ao colocar um
valor novo nela, ela automaticamente limpa.
No fim, ficou muito mais fcil gerenciar memria.
No precisa se preocupar
com suas variveis
fantasmas. Eu guardo elas
para voc!
Fbio Burch Salvador
Classes e objetos
O que vem a ser uma classe? Uma classe aquilo que ser instanciado para a criao de objetos. No
entendeu nada? Vamos ento explicao acadmica para essa coisa toda:
Explicao Wikipdica
Em orientao a objeto, uma classe abstrai um conjunto de objetos com caractersticas similares. Uma
classe define o comportamento de seus objetos atravs de mtodos e os estados possveis destes
objetos atravs de atributos. Em outros termos, uma classe descreve os servios providos por seus
objetos e quais informaes eles podem armazenar.
Classes no so diretamente suportadas em todas as linguagens, e so necessrias para que uma
linguagem seja orientada a objetos. Classes so os elementos primordiais de um diagrama de classes.
Estrutura da classe
Uma classe define estado e comportamento de um Objeto geralmente implementando mtodos e
atributos (nomes utilizados na maioria das linguagens modernas). Os atributos, tambm chamados de
campos (do ingls fields), indicam as possveis informaes armazenadas por um objeto de uma classe,
representando o estado de cada objeto. Os mtodos so procedimentos que formam os
comportamentos e servios oferecidos por objetos de uma classe.
Outros possveis membros de uma classe so:
* Construtores - definem o comportamento no momento da criao de um objeto de uma classe.
* Destrutor - define o comportamento no momento da destruio do objeto de uma classe.
Normalmente, como em C++, utilizado para liberar recursos do sistema (como memria).
* Propriedades - define o acesso a um estado do objeto.
* Eventos - define um ponto em que o objeto pode chamar outros procedimentos de acordo com seu
comportamento e estado interno.
Encapsulamento
Em linguagens orientadas a objetos, possvel encapsular o estado de um objeto. Em termos prticos,
isso se realiza limitando o acesso a atributos de uma classe exclusivamente atravs de seus mtodos.
Para isso, as linguagens orientadas a objeto oferecem limitadores de acesso para cada membro de uma
classe.
Tipicamente os limitadores de acesso so:
* pblico (public) - o membro pode ser acessado por qualquer classe. Os membros pblicos de uma
classe definem sua interface.
* protegido (protected) - o membro pode ser acessado apenas pela prpria classe e suas sub-classes.
* privado (private) - o membro pode ser acessado apenas pela prpria classe.
Cada linguagem de programao pode possuir limitadores de acesso prprios. Por exemplo, em Java, o
nvel de acesso padro de um membro permite que qualquer classe de seu pacote (package) possa ser
acessado. Em C#, o limitador de acesso interno (internal) permite que o membro seja acessado por
qualquer classe do Assembly (isto , da biblioteca ou executvel).
No exemplo abaixo, implementado em Java, a classe Pessoa permite o acesso ao atributo nome
somente atravs dos mtodos setNome e getNome.
public class Pessoa {
public String getNome() {
return nome;
}
public void setNome(String nome) {
this.nome = nome;
}
private String nome;
}
Herana
A herana um relacionamento pelo qual uma classe, chamada de sub-classe, herda todos
comportamentos e estados possveis de outra classe, chamada de super-classe ou classe base.
permitido que a sub-classe estenda os comportamentos e estados possveis da super-classe (por isso
este relacionamento tambm chamado de extenso). Essa extenso ocorre adicionando novos
membros a sub-classe, como novos mtodos e atributos. tambm possvel que a sub-classe altere os
comportamentos e estados possveis da super-classe. Neste caso, a sub-classe sobrescreve membros
da super-classe, tipicamente mtodos.
Quando uma classe herda de mais de uma super-classe, ocorre uma herana mltipla. Esta tcnica
possvel em C++ e em Python, mas no possvel em Java e C#, no entanto estas linguagens
permitem mltipla tipagem atravs do uso de interfaces.
Explicao no popular
Uma classe um pedao de cdigo que vai definir um molde para a gente construir objetos.
Uma classe tem, basicamente, mtodos e atributos. Atributos so como variveis. Mtodos so como
funes. Se voc no sabe o que so Variveis e Funes, volte a ler o material sobre Lgica da
Programao.
Um exemplo prtico:
Vamos construir a classe PESSOA.
ATRIBUTOS ==> NOME (texto), IDADE (nmero inteiro) e SEXO (texto)
MTODOS ==>
Mtodo ANIVERSARIO A idade da pessoa igual idade +1 (se era 20, passa a ser 21).
Mtodo CIRGURGIA_NO_MARROCOS O sexo muda para Transexual
timo, Agora, temos, uma classe com 3 atributos e 2 mtodos. Ento, eu vou escrever o cdigo
principal do programa, aquele que ser executado linearmente (como acontecia nas linguagens Pascal,
Clipper, Cobol, Basic, e todas as antigas).
No cdigo principal, eu vou colocar uma instruo:
A Varivel P armazenar um objeto do tipo PESSOA.
P = Nova PESSOA;
P.NOME = Joozinho;
P.IDADE = 30;
P.SEXO = Homem;
Fbio Burch Salvador
Bom. Temos ento a varivel P, armazenando nossa PESSOA, o Joozinho, com 30 anos, Homem.
Agora, vamos fazer o programa executar um mtodo do objeto P:
P.ANIVERSARIO();
Ao executar este mtodo, o P vai auto-aumentar sua idade em 1 ano, ficando com 31 anos.
Acontece que P um OBJETO do tipo PESSOA. Ele no est armazenado dentro da CLASSE
PESSOA, ele foi gerado a partir dela, mas existe de forma independente.
Depois disso, vou criar outro objeto, o P2, que tambm uma PESSOA:
P2 = Nova PESSOA;
P2.NOME = Claudinei;
P2.IDADE = 20;
P2.SEXO = Homem;
Temos ento agora:

Joozinho Homem 31 anos
Claudinei Homem 20 anos
Se eu mandar que o objeto P2 execute um mtodo:

P2.ANIVERSARIO();
Ento agora, P2 aumentou sua idade em 1 ano. Ele tem 21 anos. Mas a idade de P continua em 31.
E se eu ordenar que:
P2.CIRURGIA_NO_MARROCOS();
Ento P2 mudar seu sexo para Transexual, embora P no sofra conseqncia alguma.
Para entender:
P e P2 so independentes. Eles podem fazer aniversrio em pocas diferentes, um deles pde trocar
de sexo, e as funes executadas por um no vo afetar o outro. Eles so, contudo, semelhantes
porque ambos tm os mesmos 3 atributos e 2 mtodos, embora cada um armazene atributos com
valores diferentes e execute seus mtodos de forma completamente independente.
Por qu interessante trabalhar com Orientao a Objetos?

Porque eu posso criar a mesma classe PESSOA que eu criei no exemplo anterior, e criar um VETOR
(se voc no lembra o que isso, volte a consultar o material de Lgica da Programao).
Vetor V[100] de PESSOA (vai armazenar at 100 objetos do tipo PESSOA).

V[0].NOME = Fredegundeson;
V[1].NOME = Godofredilson;
V[2].NOME = Juvenal Antena;
V[3].NOME = Mendigo Pop;
E assim por diante...
Alis, este o mecanismo usado pelos carrinhos de compras dos sites de e-commerce: existe uma
classe PRODUTO que determina que todo produto vai ter certos atributos (preo, tipo, descrio, etc.),
e ter alguns mtodos (somar_frete, adicionar_ao_carrinho, e assim por diante). E da o programa
alimenta um Vetor de PRODUTOs e vai guardando na memria, sem envolver gravao de Banco de
Dados.
No final, quando o usurio resolve efetivar a compra, h a gravao de um dado efetivamente, sendo
ento os dados armazenados no vetor de objetos dentro da base de dados.
Em Java, tudo classe e objeto

Em Java, at o prprio programa principal, aquele que roda e faz o resto das classe se mexer, uma
classe ele prprio, e o cdigo central do software um mtodo. Veremos depois como fazer um
programa funcional.
Voc vai ter que criar classes para tudo e usar objetos de um monte de classes. A interface grfica, por
exemplo, usa uma classe chamada JFrame. A JFrame uma classe que vem com a JDK e que monta
janelinhas no estilo Windows. Esta classe tem atributos (cor de fundo, tamanho, etc.). Ento, eu crio um
objeto a partir dela e manipulo estes atributos para obter a aparncia que eu quiser para o meu
programa.
Se voc ainda no entendeu nada

No fique preocupado. Quem no tem facilidade para a teoria muitas vezes tem para a prtica. Vamos
ento comear a trabalhar.
Fbio Burch Salvador
Padres bsicos de programao Java
Primeiro, preciso saber que Java uma linguagem case sensitive, ou seja, faz diferena digitar
alguma coisa em letras maisculas ou minsculas. Ento, se quisermos usar uma JFrame e
escrevermos ali JFRAME, nada vai dar certo.
Principais tipos de dados

Java trabalha com alguns tipos de variveis e dados. Se voc no sabe o que uma varivel volte a
estudar o material de Lgica da Programao.
int Nmero inteiro.
double Nmero com casas decimais.
boolean Apenas pode valer Verdadeiro ou
Falso.
char Um caracter, que pode ser letra ou
nmero ou sinal grfico.
String Uma srie de chars, formando
uma frase ou texto.
Usando chaves
Segundo, preciso saber como delimitamos blocos. Blocos so coisas, como por exemplo, o conteo
de uma expresso condicional.
Linguagens como o Pascal e o Basic utilizam palavras-chave para abrir e fechar blocos. Assim, um IF
em Basic fica:
IF X = 1 THEN
// ALGUMA COISA ACONTECE
END IF
No java, porm, usamos chaves. Exatamente, chaves, aquelas que ns aprendemos a usar na quarta
srie para delimitar clculos.
If (x == 1) {
// ALGUMA COISA ACONTECE
}
Fazendo clculos
Depois, precisamos saber como fazer clculos. Os sinais matemticos so os seguintes:
+ Soma
- Subtrao
/ Diviso
* Multiplicao
S que para fazer clculos envolvendo uma certa hierarquia, no usamos parnteses, colchetes e
chaves. Usamos apenas parnteses, uns dentro dos outros.
Comparaes
Em Java, faremos algumas comparaes de valores entre variveis. Ento, devemos conhecer os
sinais usados:
X == Y X igual a Y
X != Y X diferente de Y
X<Y X menor que Y
X>Y X maior que Y
X <= Y X menor ou igual a Y
X >=Y X igual ou maior do que Y
Concatenando condies
Eu posso exigir que, para alguma coisa ser executada, duas ou mais condies sejam verdadeiras.
Para isso, uso a concatenao das condies utilizando principalmente trs sinais:
&& If ((Condio1) && (Condio2)) { Ser verdadeiro se a primeira condio for verdadeira e a
segunda tambm for. Caso alguma delas falhe, toda a expresso
ser FALSE.
Exemplo:
SE ((TIVER SOL) && (EU ESTIVER COM GRANA)) {
VOU PRAIA
}
Ou seja, se fizer sol mas eu estiver duro, no vou praia. Se eu

tiver dinheiro e chover, eu tambm no vou. S vou se estiver
com dinheiro e fizer sol.
|| If ((Condio1) || (Condio2)) { Ser verdadeiro se qualquer das condies for verdadeira, mesmo
que a outra no seja.
Exemplo: SE ((HOUVER UM NIBUS) || (ARRUMAR CARONA)) {

EU VOU
}
Ou seja, se eu arrumar um jeito de viajar, seja ele qual for, eu vou

viajar.
XOR If ((Condio1) && (Condio2)) { Ser verdadeiro se uma, e apenas uma, das condies for
verdadeira.
Exemplo: SE ((ELE GAY) XOR (ELE MULHER)) {

ELE GOSTA DE HOMEM
}
Ou seja, para gostar de homem, OU o sujeito gay, OU mulher.

Se for mulher E gay, nada feito lsbica e no gosta de
homem.
Se no for mulher nem gay, ento homem heterossexual e no
gosta de homem.
Fbio Burch Salvador
Montando um programa simples

Antes de mais nada, vamos ver um pequeno diagrama que mostra como funciona o esquema que eu
tentei explicar nos textos que lemos at agora:
Agora, vamos montar um programa finalmente. Abra a sua IDE e vamos comear a escrever.
Desde os anos 80, h uma tradio que diz que o primeiro software desenvolvido por qualquer pessoa
o famoso Ol Mundo. Ns vamos fazer um pouco diferente. Nosso primeiro programa exibir na tela
uma frase que no seja essa tradicional, pois j est muito manjada.
Ento, vamos l:
public class prog {
System.out.println("Minha vingana ser maligna!");
}
}
O programa acima simplssimo. Na primeira linha, eu crio a classe PROG. Na segunda, inicio o
mtodo MAIN, que ser o principal do nosso programa. No se preocupe em entender as palavras
PUBLIC, STATIC e VOID pois h um farto material sobre isso mais adiante neste mesmo livro (ver
Modificadores). O mtodo chamado MAIN sempre rodado como principal, por um padro existente na
linguagem Java.
Depois, eu tenho uma chamada classe SYSTEM.OUT, que lida com sadas de dados para o sistema.
Eu rodo o mtodo PRINTLN, que significa mande essa frase para o prompt e quebre a linha, sendo
que eu passei uma frase para ele exibir. Pronto! Temos um programa funcional!
Sintaxes principais
Laos de repetio
Os principais laos de repetio usados em Java so o FOR e o WHILE. Se voc no faz a mnima
idia do que seja um Lao de Repetio, por favor reveja a matria de Lgica da Programao.
FOR
O FOR roda um determinado cdigo por um nmero limitado de vezes. A sintaxe de sua declarao
um pouco confusa para quem nunca programou em Java, C ou PHP, mas bem simples. Ela
composta de 3 elementos separados por ponto-e-vrgula.
O primeiro elemento a criao e atribuio de valor iniciar a uma varivel que servir de contador.
O segundo elemento a condio que precisa ser verdadeira para o lao continuar rodando.
O terceiro elemento o comando de incremento da varivel.
public class prog {
for (int x = 0; x<10; x++) {
System.out.println("Estou rodando pela " + x + " vez!");
}
}
}
O resultado ser:
Estou rodando pela 0 vez!
WHILE
A instruo WHILE simplesmente a imposio de uma condio para que o lao continue a repetir-se
por um nmero infinito de vezes at que aquela condio no seja mais cumprida. Trata-se de algo bem
mais simples do que o FOR.
Vamos pegar como exemplo o seguinte: eu vou ficar perguntando ao usurio, pedindo que ele digite um
nmero. Ele vai ficar digitando nmeros at o momento em que ele digitar um 9, que o nmero de
SAIR DO SISTEMA, porque eu vou definir isso no WHILE.
public class prog {
int x = 0;
while (x != 9) {
// Aqui dentro vai ter uma rotina para o usurio digitar um nmero
}
}
}
Eu no coloquei o cdigo responsvel pela interao do usurio porque ele contm muitos comandos
que ns no vimos ainda e isso iria embaralhar a cabea dos leitores.
Fbio Burch Salvador
Estruturas condicionais
IF
O uso da instruo IF nos permite fazer algumas escolhas, o que bem interessante. Estruturas
condicionais equivalem instruo SE do Portugus Estruturado que voc deve ter visto em Lgica da
Programao.
Um IF funciona de forma simples. Eu coloco dentro de parnteses a condio que deve ser verdadeira
para que eu execute o cdigo que est dentro do bloco IF.
Um exemplo de cdigo que, executando, no satisfar condio do IF e portanto no far nada:
public class prog {
int x = 5;
if (x == 4) {
System.out.println("Se esta linha aparecer, algo muito errado foi digitado!");
}
}
}
ELSE
O Else significa seno, e usado em um IF para dar comandos que acontecero caso a condio do
IF no seja atendida.
No programa de exemplo, eu coloquei o valor FALSE em uma varivel boolean que determina se um
sujeito viado ou no. Se ele for, uma mensagem exibida. SENO, outra dizendo Muy Macho
aparecer.
public class prog {
public static void main (String[]args) { TRUE ou
boolean viado = false;
if (viado == true) { FALSE, eis a
System.out.println("Ah, viado!");
} questo!
else {
System.out.println("HUm, muy macho!");
}
}
}
ELSE IF
O Else If usado para colocarmos uma alternativa dirigida dentro de uma estrutura condicional. o
caso, por exemplo, do seguinte sistema:
Eu vou cadastrar ali, em uma String, que tipo de poltico um determinado deputado . Vou ter vrias
opes listadas com ELSEIF, e finalmente, no finalzinho, um ELSE para servir caso a opo marcada
seja Nenhuma das Anteriores.
public class prog {
String falcatrua = "Dossi";
if (falcatrua == "Mensalo") {
System.out.println("Esse do Mensalo!");
}
else if (falcatrua == "Dossi") {
System.out.println("Esse da turma do Dossi!");
}
else if (falcatrua == "Bolsa-Esmola") {
System.out.println("Esse Populisto!");
}
else {
System.out.println ("Ainda no descobriram o que o cara faz");
}
}
}
SWITCH
O SWITCH um comando usado para descobrir dentre vrias opes o que deve acontecer. Um
exemplo:
// Antes, o programa pergunta ao usurio qual opo, entre 1 e 3, ele quer ver.
Int x = // A escolha do usurio
Switch (x) {
case 1:
System.out.println(Voc escolheu 1);
break;
case 2:
break;
case 3:
break;
default:
System.out.println(Nenhuma das anteriores);
}
Onde os Breaks fazem a execuo parar e o programa passa a executar o que vem imediatamente
aps o Switch. J o Default o que acontece se nenhuma das opes vlidas for escolhida.
Fbio Burch Salvador
Aplicando Orientao a Objetos
Instanciando uma classe

Eu j disse que uma classe um molde para criarmos objetos. Certo. Agora, vamos criar uma classe
bem simples para fazermos uma experincia prtica.
public class pessoa {
String nome;
int idade;
pessoa (String n, int i) {
this.nome = n;
this.idade = i;
}
void aniversario () {
this.idade ++;
}
String dados() {
return this.nome + " tem " + this.idade + " anos.";
}
}
Bom. Eu criei uma classe Pessoa, que possui como ATRIBUTOS um Nome e uma Idade.
Da, parti para a criao de mtodos. O primeiro mtodo tem o mesmo nome da classe, o que pode
parecer bizarro, mas perfeitamente plausvel. Quando um mtodo tem o mesmo nome da classe, ele
passa a ser executado no prprio ato de criao de um objeto daquela classe. Assim, chamamos este
mtodo de construtor. Veja que o construtor de Pessoa recebe uma String (um texto) e um int (um
nmero), que ele atribui a THIS.NOME e THIS.IDADE. Mas afinal, o que THIS? This, em ingls,
significa este, e quando eu digo THIS.NOME, estou dizendo (alis, o OBJETO est dizendo) meu
nome ser - e a vem o valor da varivel n, que contm o nome da Pessoa.
Depois, eu tenho o mtodo aniversario, que apenas adiciona um ano idade da pessoa. A palavra
VOID antes do nome do mtodo significa que este mtodo no retorna nada de dados ele apenas
executa a funo de adicionar um ano a mais na idade da pessoa, no d retorno algum. Void em ingls
significa vazio.
O ltimo mtodo, dados, retorna um dado do tipo String. Ele s concatena numa String os dados da
Pessoa, e devolve para o local de onde o mtodo foi chamado.
Note que os mtodo tm parnteses aps seus nomes. Os parnteses esto ali para a gente especificar
parmetros vindos em forma de variveis (alis, ns fazemos isso no mtodo construtor, o que j serve
de demonstrao). algo muito parecido com o que fazamos com as FUNES l nas aulas de
Lgica da Programao. Se voc no se lembra, d uma estudada.
Bom. Agora, chegou a hora de criar a classe principal, que vai ter um programa rodando e instanciando
a classe Pessoa.
public class principal {
public static void main(String[]args) {
pessoa x;
x = new pessoa("Joo", 25);
String texto;
texto = x.dados();
System.out.println(texto);
x.aniversario();
texto = x.dados();
}
}
Veja que eu criei uma classe principal que tem o mtodo MAIN este que ser rodado como mtodo
principal do programa.
O que que eu fao primeiro? Eu crio uma varivel X que vai receber um objeto do tipo PESSOA.
Depois, eu atribuo varivel X um objeto PESSOA. Bom. Mas como eu disse que, ao criar um objeto, o
programa rodar tambm seu mtodo construtor, eu j passei no prprio ato de criao do objeto os
parmetros que vo preencher as variveis N e I do mtodo construtor de PESSOA passando o nome
e a idade do sujeito.
Depois disso, eu criei uma varivel texto que String, e fiz ela receber o RETORNO de dados
fornecido pelo mtodo DADOS() do objeto X, que uma Pessoa. O retorno foi aquela frase Joo tem
25 anos. Em seguida, mandei mostrar a varivel TEXTO na tela com o comando System.out.println.
Ento, a frase apareceu na tela.
S que em seguida, eu mandei o X fazer aniversrio. Ento, Joo agora tem 26 anos e no mais 25.
Depois disso, mandei exibir os dados novamente.
O resultado ser o seguinte:
Este meu cdigo ficou meio longo. Eu poderia encurt-lo, fazendo o seguinte:
pessoa x;
x = new pessoa("Joo", 25);
As duas linhas acima podem ser resumidas em:

pessoa x = new pessoa (Joo, 25);
Esta frase s faz sentido se notarmos que ela resulta da justaposio de trs instrues.
PESSOA X Cria a varivel X, para guardar objeto do tipo PESSOA.
X = NEW PESSOA Cria um objeto PESSOA dentro da varivel X.
PESSOA (Joo, 25) Roda o mtodo PESSOA, de dentro da classe PESSOA, especificando dados.
H ainda outra instruo que poderia ser resumida:

String texto;
texto = x.dados();
Eu poderia nem usar a String TEXTO, colocando diretamente o retorno do mtodo DADOS para ser
exibido na tela.
System.out.println(x.dados());
Ao fazer redues, o cdigo da classe principal ficaria assim:

pessoa x = new pessoa("Joo", 25);
x.aniversario();
}
}
Fbio Burch Salvador
Herana
Herana uma coisa que ocorre em linguagens orientadas a objeto como o Java. Ns podemos criar
uma classe que como um filhote de outra, e que herda todos os seus atributos e mtodos, podendo
ento ter seus prprios mtodos e atributos que apenas servem para somar aos que foram herdados.
Vamos ver um exemplo. Eu vou criar uma classe chamada Veiculo, que ter duas sub-classes:
Tanque e Carro.
public class veiculo {
String modelo;
int ano_fabricacao;
String estado_funcionamento;
veiculo (String m, int a) {
this.modelo = m;
this.ano_fabricacao = a;
this.estado_funcionamento = "Perfeito";
}
void levar_tiro() {
this.estado_funcionamento = "Estragado";
}
}
Na classe Veculo, eu coloquei 3 atributos:

modelo para guardar o nome do modelo de veculo;
ano_fabricacao Para guardar o ano em que o veculo foi fabricado;
estado_funcionamento para guardar em que estado de funcionamento o veculo encontra-se.
Ento, criei um mtodo construtor que recebe por parmetros um texto com o modelo e o ano do
veculo, e que colocam estes valores ou palavras dentro dos atributos do objeto.
Depois, criei um mtodo que ser rodado sempre que o veculo levar um tiro, mudando seu estado de
conservao de Perfeito para Estragado, pois vamos assumir que um veculo qualquer, ao ser
baleado, fica com grandes danos.
Bom. At aqui, nenhuma novidade. Vou agora ento criar uma classe que ser sub-classe de Veculo.
Esta classe ser Carro porque Carro um tipo de veculo especfico, pois haveria tambm a Moto, o
Trem, o Trator e por a em diante.
public class Carro extends veiculo {
String categoria;
Carro (String m, int a, String cat){
super(m, a);
this.categoria = cat;
}
}
Agora, d uma olhada nesta classe Carro. Ela EXTENDS a classe Veculo. Isso quer dizer que ela
herda tudo atributos e mtodos da sua superclasse (veculos). Um Carro um tipo de veculo
especfico.
Aps herdar as caractersticas de veculo, a Carro ainda adiciona um atributo a mais, o categoria,
usado para dizer se de luxo, se popular, etc. Ento, um Carro tem tudo o que um Veculo tem: ano,
modelo, estado de funcionamento, e... CATEGORIA!
D tambm uma olhada no mtodo construtor desta classe. Ela tem um comando SUPER este
comando faz com que o objeto, pertencente subclasse, rode o mtodo construtor da superclasse ou
seja, que rode o mtodo construtor de Veculo. Depois de o mtodo da superclasse atribuir nome, ano
de fabricao e estado de funcionamento ao Carro, o mtodo da prpria subclasse atribui a ele uma
Categoria. E da temos um carro completo!
Isso acontece porque quando criamos um Carro, estamos criando um Veculo ao mesmo tempo. Mas
no em dois objetos diferentes, e sim em um s. Se Carro uma subclasse de Veculo, e se X um
Carro, ento ao mesmo tempo X um Veculo.
como dizer que temos uma superclasse Pessoas e uma subclasse Programador. Se eu digo que Joo
um Programador, por extenso ele uma Pessoa.
Depois, para continuar nosso exemplo, eu vou criar uma outra subclasse de veculo, e esta ser
chamada de Tanque, para produzir tanques de guerra.
public class Tanque extends veiculo{
int calibre_canhao;
Tanque (String m, int a, int cal){
super(m, a);
this.calibre_canhao = cal;
}
void levar_tiro() {
this.estado_funcionamento = "Meio avariado";
System.out.println (Haha! Otrio! Nem doeu!);
}
}
Aqui, eu fiz quase o mesmo que tinha feito na classe Carro. A classe Tanque extends Veculo, e por
isso tem um Modelo, um Ano_fabricacao e um Estado_funcionamento. Eu adicionei mais um atributo,
que o Calibre_canhao, usado para guardar a informao sobre a arma de ataque que o tanque de
guerra possui.
Note que a outra subclasse de Veculo, a classe Carro, no possui um calibre de canho. E que a
prpria superclasse Veculo no possui um calibre tambm. Isso um dado especfico, que s os
tanques de guerra possuem.
Eu fiz um mtodo construtor, assim como havia feito na classe Carro.
S que depois disso eu fiz algo novo. Eu criei um mtodo chamado levar_tiro, mudando sua funo
ele agora no deixa o carro totalmente estragado. Apenas muda o estado de funcionamento do Tanque
de Perfeito para Meio avariado, e ainda exibe uma mensagem tirando sarro da cara do inimigo.
Bom. Agora, eu tenho o dilema: todo Veculo, ao ser atingido, fica Estragado. Mas o Tanque diz que
ele s fica Meio Avariado.
Isso o que chamamos de sobreposio de mtodos, uma das caractersticas principais da Herana.
Eu tenho uma superclasse Veculo que determina que todo veculo atingido por uma bala fica
estragado. Mas, na subclasse Tanque, eu especifico outra coisa. O mtodo da subclasse sobrepe o da
superclasse.
Ento, se eu criar agora as subclasses Moto, Trator e Barco, todas elas herdando diretamente de
Veculo, ento ns teremos Carros, Motos, Tratores e Barcos que, ao serem atingidos por um tiro,
ficaro Estragados. Mas teremos Tanques que, atingidos, ficam apenas Meio avariados.
como dizer que no Brasil h uma superclasse Pessoa, e que ela possui um mtodo aposentar-se.
Todas as subclasses da classe Pessoa herdam este mtodo sem sobrep-lo. A no ser a subclasse
Poltico, que sobrepe este mtodo e tem um clculo completamente diferente de aposentadoria do
resto das pessoas.
Fbio Burch Salvador
Polimorfismo
O fenmeno conhecido como Polimorfismo assim: quando eu crio uma classe e depois crio diversas
sub-classes para ela, eu estou na verdade criando tipos especficos da coisa que representada pela
superclasse.
Ento, por exemplo, eu crio a classe Pessoa, e depois as sub-classes Milico e Poltico, que so tipos
especficos de pessoas.
O caso que, depois, eu posso criar uma varivel X que declarada como sendo do tipo genrico
Pessoa, e X capaz de receber um milico ou um poltico (tanto faz), da a palavra Polimorfismo (Poli =
Muitos e Morfos = Forma).
Isso parece bastante intil primeira vista. Mas torna-se til no momento em que eu crio um vetor
declarado como sendo de Pessoas e ento preencho as posies dele com milicos, polticos ou
quaisquer objetos de qualquer sub-classe de Pessoa.
abstract class pessoa {
int idade;
String nome;
pessoa (int i, String n) {
this.idade = i;
this.nome = n;
}
abstract void mostrar();
}
class milico extends pessoa {
String patente;
milico (int i, String n, String p) {
super(i,n);
this.patente = p;
}
void mostrar () {
System.out.println(nome + " um " + patente + " cuja idade " + idade + " anos.");
}
}
class politico extends pessoa {
String partido;
politico (int i, String n, String p) {
super(i,n);
this.partido = p;
}
void mostrar () {
System.out.println(nome + " um poltico de " + idade + " anos de idade, filiado ao " + partido);
}
}
class prog {
pessoa[]m = new pessoa[3];
m[0] = new milico (23, "Juca", "Cabo");
m[1] = new politico (31, "Joao", "PMDB");
m[2] = new milico (56, "Fernandinho", "PTB");
m[0].mostrar();
m[1].mostrar();
m[2].mostrar();
}
}
Modificadores
Modificadores so argumentos que so colocados antes do nome no ato de criao de mtodos ou
variveis, dando a estes mtodos ou variveis caractersticas especiais, mudando seu escopo de
atuao ou impedindo-os de fazer algum tipo de coisa que ns precisamos ter certeza de que no
acontecer.
Vejamos ento os principais modificadores que existem na linguagem Java.
Static
Quando criamos uma classe, e queremos ativar seus mtodos ou pegar o valor de um atributo a partir
de outra classe, precisamos instanciar a primeira classe. Porque a classe em si no tem mtodos
funcionais e nem valor nos atributos. O objeto criado a partir desta classe que os tem.
Mas se o atributo ou o mtodo recebe o modificador static, ento este atributo ou mtodo passa a ser
ligado diretamente classe, no aos seus objetos.
Com isso, eu posso muito bem executar um mtodo static sem criar objeto algum da classe onde ele foi
escrito, bastando para isso colocar a forma nomedaclasse.nomedometodo().
Uma outra coisa que ocorre que, se eu crio a classe carro, com o atributo static cor, e eu mudo a
cor de um carro, o mesmo valor no mesmo atributo ocorre em todos os outros carros. Assim, se eu
deixar o carro que est na varivel X com a cor azul, todos os outros carros, Y, Z, ou qualquer outro,
ficaro azuis.
Public
Um atributo ou mtodo PUBLIC pode ser acessado e visto a partir de qualquer classe, de qualquer
ponto do programa, abertamente, atravs da frmula NomeDoObjeto.NomeDoAtributo ou ento
NomeDoObjeto.NomeDoMtodo(argumentos).
Private
Um mtodo que PRIVATE no poder ser acessado atravs de nenhuma outra classe a no ser os
objetos daquela classe na qual foi criado. Assim, se eu crio o mtodo PRIVATE ACELERAR, dentro da
classe Carro, eu no posso simplesmente criar o objeto Carro X e querer usar X.ACELERAR(). Eu
precisarei de outro mtodo, dentro de Carro, que ative ACELERAR por dentro.
Existem tambm atributos PRIVATE, e variveis tambm. Estes, s podem ser acessados por dentro da
classe ou mtodo onde foram criados, e servem para guardar valores de uso exclusivo naquele escopo.
Os mtodos ou atributos PRIVATE no so vistos por ningum de fora da classe de origem, nem
mesmo pelas sub-classes.
Final
O modificador Final, utilizado em alguns objetos, mtodos e variveis, faz com que estes no possam
ser reutilizados ou sobrescritos por subclasses no futuro (ou seja, mais adiante no cdigo). Algumas
funcionalidades, como as do ActionListener, s podem ser associadas a um componente qualquer (no
caso do ActionListener, botes e menus), quando existe a certeza absoluta de que estes componentes
no iro mudar ou evaporar-se por ao do programador em algum momento do cdigo. Por isso,
exige-se o uso do modificador final nestes componentes.
Fbio Burch Salvador
Protected
O Protected funciona como uma espcie de PRIVATE, mas sem ser to radical. Os atributos ou
mtodos daquilo que PROTECTED s sero enxergados por classes que estejam no mesmo pacote
(package). Um pequeno exemplo:
package pai; A classe classepai, que pertence ao pacote pai, tem um

public class classepai { atributo que PROTECTED. Bom, at aqui, nada de mais.
protected int variavel = 5;
}
A classe classefilho pertence ao pacote

package filho; filho. Esse programa no compila. Se eu
public class classefilho extends classepai{ trocasse o pacote para pai, aqui, o programa
public static void main() { compilaria e rodaria sem nenhum problema.
classepai p = new classepai();
System.out.println(p.variavel); // ERRO: teste has protected access in pai.Pai
}
}
Pacotes
O uso de PACKAGES (pacotes) tem como funo organizar as classes criadas em Java de forma muito
semelhante ao que fazemos com os Mdulos no Modula. Mas para quem s conhece Java, aqui vo as
utilizaes deste mecanismo:
1 Criar um JAR
Pode-se criar um JAR com apenas as classes que esto no mesmo pacote, e isso especialmente fcil
de fazer no Eclipse. Com isso, podemos disponibilizar nossos programas em pacotes para o usurio
baixar apenas alguns. Ou ento, disponibilizar nossas classes prontas como um pacote.
Esta ltima utilidade a mais legal de todas. Porque se eu criar um package chamado utilidades, e
dentro dele colocar classes com funes variadas, outro programador poder apenas anexar meu
pacote JAR ao seu projeto e utilizar a frmula IMPORT para puxar uma de minhas classes.
Como que ele anexa meu JAR ao seu programa? Usando o comando Build Path, do Eclipse, que
veremos mais adiante e no vem ao caso agora.
Digamos que ele queira importar a classe apetrechos, ele executar:
import utilidades.apetrechos;
E se ele quiser importar tudo de uma vez s, usar:
import utilidades.*;
2 - Organizar o programa em pedaos

No Eclipse, os Packages organizam nossas classes dentro do Package Explorer, o que nos permite
organizar as classes em grupo segundo sua utilidade ou por critrios que podemos escolher livremente.
Fbio Burch Salvador
Tratamento de erros e excees

Tratar erros no Java muito simples. Utilizamos a expresso TRY e rodamos, dentro do bloco de Try
(palavra que significa tentar em ingls). Somos obrigados a envolver rotinas que podem dar erros ou
que provavelmente daro erro em algum momento.
Bons exemplos de rotinas nas quais o uso de TRY obrigatrio so, por exemplo, o acesso a banco de
dados em um servidor remoto (uma situao na qual, mesmo que o cdigo esteja perfeito, o programa
pode dar problemas por causa de uma queda da rede, por exemplo), ou o acesso a arquivos de
qualquer tipo (porque, novamente, mesmo com o programa estando perfeito ainda podem ocorrer
problemas como o extravio do arquivo por ao de algum usurio desavisado).
Depois do TRY, usamos os CATCH (palavra que significa algo prximo de agarrar), porque
precisamos saber quais tipos de erro so esperados. O Catch pega um certo tipo de erro ocorrido e
ento coloca este erro dentro de uma varivel, que deve ser declarada na prpria chamada do CATCH.
Depois, no fim, temos o FINALLY indicando uma rotina que ser rodada sempre, com ou sem erro.
Normalmente utilizada para colocar o programa de volta dentro dos eixos aps a execuo de uma
rotina onde haja perigo de erros.
class errada {
int[]x = new int[4];
for (int c = 0; c<10; c++) {
try {
x[c] = c;
}
catch(ArrayIndexOutOfBoundsException e) {
System.out.println (e);
}
finally {
System.out.println ("Terminou um ciclo.");
}
}
}
}
Throw informado os erros classe que instanciou o objeto
A palavra Throw em ingls significa jogar, atirar alguma coisa. E Throws, o verbo arremessar atribudo
como se fosse na frase Ele joga a pedra longe. Utiliza-se isso para jogar o erro para cima, fazendo-
o atingir a rotina que chamou o procedimento errado, no a prpria rotina onde ocorre o erro.
Para que tudo fique mais claro, imagine a seguinte situao: Eu acabo de criar um programa que tem
uma classe centralizando todo o trabalho lgico e os menus. E criei uma pequena classe que no faz
nada, a no ser abrir um banco de dados.
Eu vou reutilizar a classe que abre banco de dados em todos os meus programas, para manter o
padro. Mas as mensagens de erro devem ser emitidas pela classe principal do programa, para que
cada programa possa ter suas prprias mensagens.
Eu, ento, fao como? Simples: a classe que abre banco de dados no vai tratar os erros que
ocorrerem. Ela vai simplesmente arremessar esses erros para cima, deixando nas mos da classe
principal o tratamento do erro. E ela que trate-o como quiser.
A declarao do THROWS vai na classe onde o erro pode ocorrer, obrigando a classe que est acima
a tratar o erro com um TRY e um CATCH.
class errada2 {
void rodar() throws ArrayIndexOutOfBoundsException {
int[]x = new int[4];
for (int c = 0; c<10; c++) {
x[c] = c;
}
}
}
class progerrado {
errada2 x = new errada2();
try {
x.rodar();
}
catch (ArrayIndexOutOfBoundsException e) {
System.out.println("Deu um erro");
}
}
}
Fbio Burch Salvador
Tipos de Excesso
Nos nossos exemplos acima, temos apenas um tipo de erro, o ArrayIndexOutOfBoundsException, que
bastante comum e familiar (e fcil de entender o vetor est recebendo dados que esto alm do seu
tamanho). Mas temos inmeros outros tipos de erro possveis, o IOException, o SQLException, e por a
vai.
Se ns realmente no sabemos que tipo de erro uma determinada rotina poder apresentar, podemos
ter duas grandes certezas:
1) Estamos em apuros;
2) Precisamos tratar o erro mesmo assim.
Pensando no ponto nmero 2 da lista, usamos o tipo de erro Exception, que a superclasse de todas
as que falam sobre erros possveis, provveis ou imaginveis em Java.
Assim: catch (Exception e) {
Escrevendo dados em arquivos textos e lendo eles

de volta
Agora, vamos viajar um pouquinho no tempo. H muitos, muitos, muitos anos atrs, todo mundo
utilizava arquivos-texto para manipular dados. Era simples. Bastava criar um arquivo-texto no qual cada
linha tivesse um dado especfico, ou no qual uma linha comportasse toda a ficha de um funcionrio,
bem patrimonial ou o que seja. Depois, era preciso ler este arquivo-texto, em ordem, e obter os dados.
Agora, vou dar-lhe uma m notcia: este sistema de organizao de dados ainda existe no governo
brasileiro (este texto de 2008). Diversos rgos (como a Receita) recebem dados em formato texto,
fornecendo aos desenvolvedores os padres de escrita destes dados para que estes possam criar seus
programas geradores de declaraes e outras coisas.
Ento, ns vamos, sim, ver este tipo de coisa. E chega a ser divertido, porque poderemos depois criar
nosso prprio Bloco de Notas paraguaio.
no pacote Java.io que encontramos quase tudo o que precisaremos para fazer a criao e a leitura de
arquivos binrios ou de caracteres (texto).
Temos dois tipos de classes para usar. Um trabalha em nvel de byte (binrio), e o dos Streams. O
outro trabalha com caracteres, e so os Reader/Writer. Quase todas geram, possivelmente, erros do
tipo IOException, obrigando-nos a tratar este tipo de erro.
A quantidade de classes tratando deste tipo de tarefa muito grande. Mas ns usaremos apenas as
mais utilizadas de todas as que existem hoje em dia. No chegam a ser muito complicadas, e com elas
possvel montar perfeitamente uma emulao de banco de dados em arquivos-texto.
import java.io.*;
class escritor {
try {
FileWriter gravador = new FileWriter("arquivo.txt");
A primeira coisa que fazemos instanciar a classe FileWriter, e declarar um nome de arquivo para o
objeto dela (no caso, o gravador, com o arquivo arquivo.txt). Com isso, o programa cria um novo
arquivo com o nome especificado. Eu poderia ter especificado um local (o nome de arquivo como uma
URL), mas no o fiz, portanto, o arquivo surgir na prpria pasta onde roda o programa.
BufferedWriter saida = new BufferedWriter(gravador);
A segunda coisa crier o BufferedWriter. Esta pequena maravilha, evoluo de quase tudo o que havia
anteriormente sobre leitura e gravao, nos permite gravar textos inteiros no arquivo aberto pelo
FileWriter. Antigamente, usava-se escrever caracter por caracter, mas no com o Buffered.
saida.write("Ol mundo \n");

saida.write("Viva o jogo dos Canibais! ");
saida.flush();
Os trs comandos acima fazem o trabalho de graver um texto no arquivo aberto. Os sada.write
escrevem texto em uma espcie de fila de gravao, daquilo que ir para o arquivo assim que eu
executar o comando FLUSH, alis, mostrado na ltima das trs linhas.
Alguns podero perguntar: por qu ele usou o a expresso \n no final da primeira linha? Este sinal,
chamado de caracter de escape (o que meio bizarro, pois na verdade so dois caracteres) equivale
ao sinal de nova linha. isso o que fica no arquivo quando algum usa o ENTER em um programa
Fbio Burch Salvador
como, por exemplo, o EDIT do DOS ou os editores de texto mais simples para Windows.
}
catch(IOException e) {
System.out.println("No deu para escrever o arquivo");
}
}
}
E agora faremos um leitor para o arquivo que acabei de escrever:
import java.io.*;
class leitor {
try {
FileReader gravador = new FileReader("arquivo.txt");
O File Reader a classe que faz a leitura de arquivo, uma espcie de irm da FileWriter, que vimos h
pouco.
BufferedReader entrada = new BufferedReader(gravador);
A classe irm de BufferedWriter faz a leitura de um arquivo-texto.
String linha;
while ((linha = entrada.readLine())!=null) {
Aqui, vemos um momento de maior complexidade no programa (mas no muita). Vamos observar a
condio contida neste WHILE: eu tenho uma operao, que o linha = entrada.readLine(), no qual eu
digo que a varivel linha recebe uma linha do texto do arquivo que est aberto em entrada a cada
vez que esta rotina for rodada, o programa vai ler uma nova linha. Como eu usei um WHILE, ele vai
percorrer o arquivo da primeira ltima linha.
Depois, eu peo que o clico se repita enquanto o resultado desta operao no for NULL a operao
em si retorna um valor que sempre positivo, mas quando no d mais para ler o arquivo (porque ele
chegou ao fim), retorna NULL, encerrando o clico do WHILE.
System.out.println(linha);
}
}
catch(IOException e) {
System.out.println("No deu para ler o arquivo");
}
}
}
Tokenizer (caracteres separadores)
Para podermos criar uma espcie de banco de dados no arquivo-texto, precisamos de separadores
para distinguir os dados entre si. Para isso, usamos a classe StringTokenizer, com a qual determinamos
um token (que pode ser uma vrgula, um ponto, dois caracteres, o que eu quiser) e este token vai
separar os campos de dados.
No caso, imaginemos que eu criei um arquivo-texto (no Bloco de Notas) contendo apenas o seguinte
texto:
Vodka; Russia; Forte
Canha; Brasil; Forte
Vinho; Egito; Medio
Cerveja; Sumeria; Fraca
O nome do arquivo arquivo.txt. Agora, vou fazer um programinha que l estes dados e os exibe na
tela:
import java.io.*;
import java.util.*;
class leitor {
try {
FileReader gravador = new FileReader("arquivo.txt");
BufferedReader entrada = new BufferedReader(gravador);
String linha;
while ((linha = entrada.readLine())!=null) {
At aqui, eu operei apenas com o que j vimos anteriormente: um Reader e nada mais.
StringTokenizer tok = new StringTokenizer(linha, ";");
Agora, eu estou pegando a linha de texto que havia sido capturada na varivel linha e estou
quebrando ela em pedaos, usando o ponto-e-vrgula como sinal de quebra. Logo abaixo, eu vou usar o
mtodo nextToken() para fazer o meu sistema percorrer todos os tokens que existem nesta linha de
texto.
System.out.println("Bebida: " + tok.nextToken());

System.out.println("Origem: " + tok.nextToken());
System.out.println("Grau de alcool: " + tok.nextToken());
System.out.println("-----------------------");
}
}
catch(Exception e) {
System.out.println("No deu para escrever o arquivo");
}
}
}
Fbio Burch Salvador
Mtodos da classe StringTokenizer:
boolean hasMoreTokens() // retorna true se existe mais tokens
String nextToken() // retorna prximo token; lana um NoSuchElementException se no houver mais
tokens.
String nextToken(String delim) // o novo grupo de delimitador usado
int countTokens() // retorna o nmero de tokens
Tocando sons em Java

Para tocarmos sons em um programa em Java, precisamos fazer um processo um pouco longo. Mas o
resultado vale a pena, e pode-se fazer o computador executar o som enquanto executa outras coisas,
tornando a msica ambiente.
A idia : primeiro, abrimos um arquivo como se fssemos ler dele alguma informao (e vamos).
Depois, existe uma classe chamada AudioStream, que pega este arquivo aberto e l ele como arquivo
de som, decodificando-o. Ento, podemos fazer o som tocar normalmente.
import sun.audio.*; Primeira coisa, importar as classes que

import java.io.*; comandam esta questo de som: a sun.audio
e a velha java.io, para a leitura do arquivo
public class Tocador{ pois o som um arquivo.
public static void main(String[] args){

A prxima coisa que fazemos abrir o arquivo de som, e
este processo igual ao da abertura do arquivo de texto
que fazamos em uma aula anterior.
try {
InputStream arq = new FileInputStream("aha.wav");
Depois, vem a novidade: abrir um
AudioStream som = new AudioStream(arq); objeto da classe AudioStream
usando o arquivo.
Da, temos o comando

AudioPlayer.player.start(som); AudioPlayer.player.start(som), usado para
fazer o som comear a tocar.
}
System.out.println(Deu pau);
}
}
}
Podemos, depois, usar um comando para fazer o som parar de tocar:

AudioPlayer.player.stop(som);
Uma outra grande jogada deste sistema que possvel tocar dois sons ao mesmo tempo. Basta criar
dois objetos do tipo InputStream e dois AudioStream. Com isso, podemos colocar uma msica e uma
batida de fundo para tocarem juntas.
Ou ainda, criar:
Fbio Burch Salvador
Um conjunto de InputStream e AudioStream com uma msica ambiente.
Um conjunto de InputStream e AudioStream com o barulho de espadas se batendo.
Um conjunto de InputStream e AudioStream com o grito de um monstro.
Um conjunto de InputStream e AudioStream com o som de uma flecha voando.
E no final, criar um jogo de RPG com msica de fundo, espadas e flechas que fazem barulho, e
monstros que rosnam.
...Quand il me prend dans ses bras

ll me parle tout bas
Pronto! Je vois la vie en rose

ll me dit des mots d'amour...
Agora voc j pode aterrorizar os seus clientes, amigos e at familiares dando a

eles um sistema que no apenas organiza seus dados de qualquer natureza, mas
tambm os faz pensar na possibilidade do suicdio ao escutar uma verso
modorrena de La Vie em Rose, um experimento psicolgico

ainda no concluso, conduzido nas aulas de Java pelo lendrio Bruno, no Senac!
Ou ainda...
Pode animar o trabalho da Contabilidade, que muito montono, fazendo o primeiro sistema contbil
com trilha sonora tocada pelo Sha Na Na!
Ou melhor ainda...
Faa uma juno de msicas e coloque uma banda impensvel para tocar: por qu escolher? Bote
juntos Edith Piaf COM os caras do Sha Na Na!
A classe Console
Bom. Pessoal, eu sei que est ficando difcil de programar em Java, no modo texto, sem ter como
digitar nada na tela.
Ento, eu tenho aqui uma classe que ns sempre usamos dentro dos projetos e que se chama Console.
Ela tem uns mtodos estticos que lidam com possibilidades de erro e tudo mais, permitindo uma
integrao bem legal do teclado com um programa.
/**
An easy interface to read numbers and strings from
standard input
@version 1.10 10 Mar 1997
@author Cay Horstmann
*/
public class Console

{
public static void printPrompt(String prompt)

{ System.out.print(prompt + "Digita a: ");
System.out.flush();
}
public static String readLine()

{ int ch;
String r = "";
boolean done = false;
while (!done)
{ try
{ ch = System.in.read();
if (ch < 0 || (char)ch == ' ')
done = true;
else if ((char)ch != ' ') // weird--it used to do translation
r = r + (char) ch;
}
catch(java.io.IOException e)
{ done = true;
}
}
return r;
}
/**
read a string from the console. The string is
terminated by a newline
@param prompt the prompt string to display

@return the input string (without the newline)
*/
public static String readLine(String prompt)

{ printPrompt(prompt);
return readLine();
}
Fbio Burch Salvador
public static int readInt(String prompt)
{ while(true)
try
{ return Integer.valueOf
(readLine().trim()).intValue();
} catch(NumberFormatException e)
{ System.out.println
("Not an integer. Please try again!");
}
}
}
public static double readDouble(String prompt)

{ while(true)
try
{ return Double.parseDouble(readLine().trim());
} catch(NumberFormatException e)
{ System.out.println
("Not a floating point number. Please try again!");
}
}
}
}
Para usar esta classe no seu cdigo, fcil. Basta adicion-la ao seu projeto e ento usar seus
mtodos para carregar variveis.
Exemplos:
String texto = Console.readLine(Digite aqui:);
Sendo que o argumento passado o prompt que o usurio v. Usando este mtodo, seu programa em
modo texto vai parar neste ponto, aguardando a digitao por parte do usurio.
De forma semelhante, use os mtodos:
double x = Console.readDouble();
int x = Console.readInt();
E por a vai.
Sobrepondo mtodos uma tcnica essencial
Uma das coisas fundamentais sobre Java que tudo o que existe na linguagem, ou quase tudo, so
classes das quais criamos mtodos. No existe, portanto, nenhuma sada para quem no sabe
trabalhar com classes.
Uma das coisas mais legais que h no Java que ns podemos pegar uma classe que existe com
certos mtodos, e podemos criar objetos que no obedecem a estes mtodos mas os sobrepe, no
criando uma nova classe com a modificao, e sim criando um objeto que tem a modificao em si.
Eu vou dar um exemplo, Vou criar uma classe Pessoa que s vai possuir um mtodo, para fins de
exemplo.
class Pessoa {
void gritar() {
System.out.println(Socorro!);
}
}
Agora, eu vou criar uma classe principal que vai criar uma Pessoa e ento pedir que ela grite.
class prog {
Pessoa P1 = new Pessoa();
P1.gritar();
}
}
A pessoa P1 vai gritar Socorro!, e at a morreu Neves, porque ns j vimos isso antes. Mas agora eu
vou criar uma segunda pessoa, que ter seu prprio mtodo gritar(), diferente do padro das outras
pessoas.
class prog {
Pessoa P1 = new Pessoa();
P1.gritar();
Pessoa P2 = new Pessoa () {
void gritar() {
System.out.println("Shoryuken!");
}
};
P2.gritar();
}
}
Fbio Burch Salvador
Interface grfica em Java

Cansado de programar Java e Est com medo do seu
s ver letrinhas pretas sobre futuro profissional por
um fundo branco? saber apenas
desenvolver
Sente inveja do seu aplicaes Java com
vizinho que faz interface de DOS?
programas em Java
com telas cheias de
campos e botes?
SEUS PROBLEMAS
ACABARAM!
Vamos trabalhar agora a interface grfica do
seu programa em Java! Leia as prximas
pginas e sua vida ser iluminada!
Bibliotecas AWT e SWING

So as fontes das classes que utilizaremos a partir daqui. Nelas moram os componentes grficos para
Java, e por isso devemos import-las no incio de nossas classes gerenciadoras de telas:
import javax.swing.*;
import java.awt.*;
Nossa primeira tela

Pode parecer estranho para quem vem de outras linguagens, como o Delphi ou o VB, mas em Java,
cada tipo de componente grfico uma classe com atributos e mtodos prprios. E para utiliz-las,
devemos instanci-las.
A primeira e mais simples chama-se JFrame, e cria telas retangulares sem nada dentro, um espao
onde trabalharemos logo depois.
import java.awt.*;
class classetela {
JFrame tela = new JFrame("Primeira tela");
tela.setBounds(100,100,600,400);
O mtodo SetBounds trabalha com a localizao e tamanho da tela, sendo a seguinte ordem: distncia
do canto esquerdo da tela, distncia do topo da tela, largula e altura.
tela.getContentPane().setBackground(Color.RED);
Aqui, invocamos o mtodo que verifica qual o campo de Content do JFrame, ou seja, a regio onde
no est o menu nem as bordas, e muda sua cor a partir do mtodo set Background. Eu usei uma
biblioteca de cores, a Color, e defini a janela como vermelha; Poderia ter usado azul, cinza, verde, etc.
tela.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
Aqui, eu determino qual a ao a executar quando este JFrame for fechado. No caso, ele fecha o
programa todo, num efeito de BREAK. A instruo DISPOSE_ON_CLOSE apenas levar o JFrame a
fechar sem derrubar o programa todo.
tela.setLayout(null);
Aqui, escolhi um Layout para o meu JFrame. Ou melhor, escolhi que seja nenhum. Existem Layouts
prontos para JFrames, onde os botes ficam dispostos em forma de fileira, ou nos cantos, ou
expandidos. A maioria tem um resultado grotesco. Se quisermos desenhar nossa tela com liberdade
para faz-la bonita, temos que escolher o NULL;
tela.setVisible(true);
Depois de preparado, o JFrame pode j ficar visvel. Este passo vem no final de toda a sua montagem.
}
}
Fbio Burch Salvador
JLabel
um pequeno componente com o qual colocamos pedaos de texto sem nenhuma funo, a no ser a
de indicar para qu servem os campos de uma tela qualquer.
import java.awt.*;
class classetela {
JLabel texto = new JLabel("Frase indicativa");
tela.getContentPane().setBackground(Color.RED);
texto.setBounds(100,100,200,30);
tela.add(texto);
}
}
O cdigo acima no apresenta grandes novidades. Apenas instanciamos o JLabel, dando-lhe um texto
qualquer para exibir. Depois, demos o mesmo setBounds nele, e em seguida fizemos a ao realmente
revolucionria:
tela.add(texto);
Adicionamos o objeto texto ao objeto tela. Note que o setBounds do texto passa a usar como
bordas as bordas do JFrame. E fica contido nele.
O JLabel pode ter desenhos por dentro, mas veremos isso mais adiante, quando tratarmos do Icon,
outro tipo de objeto Java.
JButton
O JButton , finalmente, o boto. Colocamos ele nas telas com inmeras funes. Estas funes sero
tratadas mais adiante, quando chegarmos s aulas sobre Eventos. Por enquanto, basta-nos desenhar
os botes.
O JButton poder ser instanciado de trs formas diferentes:
JButton() aqui, teremos depois que rodar um mtodo setText(algum texto) para dar-lhe um contedo
(um contedo que aparece para o usurio).
JButton(String) aqui, escrevemos algum texto para aparecer no boto e o usurio saber do que se
trata.
JButton(icon) neste caso, adicionamos uma figura ao boto para dar-lhe uma aparncia
personalizada.
Veja este cdigo:
import java.awt.*;
class classetela {
tela.getContentPane().setBackground(Color.YELLOW);
tela.add(texto);
JButton botao= new JButton("Pressione aqui");

botao.setBounds(100,200,200,30);
botao.setBackground(Color.GREEN);
botao.setForeground(Color.BLUE);
botao.setToolTipText("Um exemplo de ToolTip");
tela.add(botao);
}
}
No exemplo acima, eu usei praticamente a mesma tela criada antes, mas adicionei as rotinas de criao
de um boto. Primeiro, instanciei a classe, e usei os mtodos j conhecidos setBounds e
setBackground.
Em seguida, usei o setForeground, com o qual determino a cor da letra do texto do boto. E logo
abaixo, determinei o texto da ToolTipText, ou seja, o texto que aparece na caixinha amarela de ajuda
quando passamos o mouse sobre o boto.
Na seqncia, apenas usei o ADD para colocar o boto na tela e dei a tradicional ordem para que ela
ficasse visvel.
Fbio Burch Salvador
JTextField
O JTextField uma caixa utilizada para que o usurio possa escrever um texto de uma linha s. Trata-
se de um componente bastante simples, que tem basicamente as mesmas especificaes dos que
acabamos de ver: setBounds, setBackground, setForeground, e o ADD da tela sobre ele.
Um exemplo do cdigo anterior, enriquecido com um JTextField:
import java.awt.*;
class classetela {
tela.add(texto);

tela.add(botao);
JTextField caixa = new JTextField();

caixa.setBounds(100,300, 200,30);
caixa.setBackground(Color.RED);
caixa.setForeground(Color.WHITE);
tela.add(caixa);
}
}
O tratamento do texto de um JTextField dar-se- por meio de dois mtodos bastante simples:
getText() servir para capturar o qu o usurio digitou no campo.
setText() servir para determinarmos que texto deve ir no campo. Muito til quando se abre um
registro de um banco de dados e o campo JTextField deve receber um campo de registro para
alterao.
JFormattedTextField
So campos parecidos com a JTextField - o usurio pode escrever dentro normalmente. S que agora o
nmero de caracteres digitveis limitado, pode-se limitar o tipo de catacter digitado, e pode-se fazer o
campo j esperar com alguns sinais prontos. isso o que se usa nos campos onde uma pessoa deve
digitar seu CPF e a caixinha de texto j vem com os pontos e o trao, por exemplo. Vamos ver como se
faz, bem fcil.
package Componentes;
import java.awt.event.*;
public class rodar {

public static void min(String[]args) {
JFrame tela = new JFrame();
tela.setBounds(0,0, 800,600);
try{
txtCPF = new JFormattedTextField(new MaskFormatter("###.###.###-##"));
txtData = new JFormattedTextField(new MaskFormatter("##/##/####"));
txtCNPJ = new JFormattedTextField(new MaskFormatter("###.###.###/####-##"));
}
catch (Exception erro){
JOptionPane.showMessageDialog(null,"Essa porcaria deu problema");
}
Este programa comea normalmente com a criao da JFrame e tudo mais. E ele termina normalmente.
Na verdade, seria mais um programa banal, desses que desenvolvemos todos os dias, no fosse pelo
fato de eu ter adicionado uns objeto novos tela. Esses objetos novos so como JTextFields. S que
com uma mscara.
A mscara, no caso um MakFormatter, um objeto de uma classe criada apenas com o fim de
associar-se a JFormattedTextFields e formar um campo com parmetros para digitao.
No caso, o formato da Dat, por exemplo, j mostrar a TextField com as barras. J os sinais de
sustenido ficaro em branco, aguardando que o usurio digite nmeros - EU DISSE NMEROS! NO
LETRAS!
Se voc quiser que o usurio possa digitar o que quiser em uma determinada posio, basta colocar um
asterisco ao invs do sustenido.
Assim como a JTextField, sua variante Formatted precis ser adicionada tela. Ento, vamos acabar
logo esse programa.
tela.add(txtCPF);
tela.add(txtData);
tela.add(txtCNPJ);
tela.setDefaultCloseOperation(JInternalFrame.DISPOSE_ON_CLOSE);
}
}
Fbio Burch Salvador
JToggleButton
uma variao bem bsica do JButton. Trata-se de um boto que, uma vez pressionado, fica
afundado, demonstrando que tal opo est selecionada ou que tal funcionalidade est ativada.
import java.awt.*;
class classetela {
tela.add(texto);

tela.add(botao);
JTextField caixa = new JTextField();

caixa.setBounds(100,300, 200,30);
caixa.setBackground(Color.RED);
caixa.setForeground(Color.WHITE);
tela.add(caixa);
JToggleButton toglebotao= new JToggleButton("Toggle Button");

toglebotao.setBounds(300,200,200,30);
toglebotao.setBackground(Color.GREEN);
toglebotao.setForeground(Color.BLUE);
toglebotao.setToolTipText("Um exemplo de ToolTip");
tela.add(toglebotao);
}
}
O uso do JToggleButton torna-se possvel por causa do mtodo isSelected(), que retorna True ou False
e nos diz se o boto est afundado ou no.
Icon
A classe Icon tem um uso bastante simples, mas muito importante. Com ela, podemos carregar uma
imagem (devidamente criada em um arquivo JPG ou PNG), para dentro do programa, utilizando esta
imagem como quisermos. O comando para isso bastante simples. Basta instanciar a classe Icon
criando uma ImageIcon que carregar o arquivo, cujo nome ou localizao completa
Comando assim:
Icon imagem = new ImageIcon(arquivo.jpg);
Existe ainda uma funcionalidade que muita gente desconhece: O formato de imagem PNG, que capaz
de armazenar instrues sobre transparncias, quando lido, acaba numa imagem com transparncias,
pois o Java consegue respeitar bem estes parmetros.
Depois de carregarmos uma imagem para dentro de uma varivel, podemos atribu-la a uma srie de
objetos atravs do mtodo setIcon.
Exemplos:
JButton botao = new JButton();
boto.setIcon(imagem);
JLabel rotulo = new JLabel();

rotulo.setIcon(imagen);
Um detalhe importante a notar que, quando atribumos o Icon a um JButton, o boto ganha o desenho
mas permanece com o aspecto de boto, mudando a cor da borda quando colocamos o mouse sobre
ele.
J quando atribumos o Icon a uma JLabel, a imagem fica parecendo solta no ar entro da tela. E a, a
transparncia tem realmente sua funo efetiva, uma vez que o fundo atrs da JLabel aparece
plenamente.
possvel fazer botes redondos, triangulares ou com qualquer forma, usando JLabel, simplesmente
desenhando o boto, colocando em uma JLabel e, na funo do boto, incluir um comando para mudar
o Icon da JLabel, trocando-o por uma figura do mesmo boto, mas com aparncia de pressionado.
Fbio Burch Salvador
JOptionPane
JOptionPane o componente que cria as famosas caixinhas de mensagem para o usurio. Com ele,
possvel fazer no apenas mensagens na tela mas tambm pedir dados, dar opes (do tipo Ok,
Cancel), e fazer algumas outras operaes.
Uma das facilidades de se usar o JOptionPane que seus mtodos so estticos (static), ento nem
precisamos criar um objeto para executar nada. Usamos a classe, direto.
Um exemplo bem simples:
import java.awt.*;
class optiones {
JOptionPane.showMessageDialog(null, "Uma mensagem!", "Titulo", JOptionPane.ERROR_MESSAGE);
}
}
No exemplo acima, chamamos o mtodo showMessageDialog, que mostra apenas uma mensagem
simples com um boto de OK embaixo. Os argumentos utilizados so:
NULL, colocado num campo onde devemos informar o objeto pai do JOptionPane. Este objeto pai
(parent) ficar congelado embaixo da caixa de mensagem at que o usurio clique no OK.
J o segundo argumento, fcil de entender, a mensagem em si, uma String sem grande mistrio.
O terceiro o ttulo da caixa de mensagem, aquele que vai no alto da caixa em sua barra superior, ao
lado do boto de Fechar.
O ltimo argumento o tipo de mensagem que queremos exibir. Conforme o tipo, aparecer um cone
ao lado do nosso texto.
JOptionPane com cone prprio

Eu poderia ainda acrescentar um quinto argumento, colocando ali um objeto do tipo Icon. Da, eu teria
uma mensagem com minha prpria figurinha de erro.
A sintaxe ficaria assim:
Icon figura = new ImageIcon ("foto.jpg");
JOptionPane.showMessageDialog(null, "Errou, seu imbecil!", "Erro", JOptionPane.PLAIN_MESSAGE, figura);
Tipos de mensagem:
JOptionPane.ERROR_MESSAGE Mensagem de Erro, do tipo com o X na bolinha
vermelha. Usando em caso de erros,
normalmente, tratamento de excees.
JOptionPane.INFORMATION_MESSAGE Usado em mensagens do tipo Help, aparece
com um pequeno I tpico de placa da
informaes.
JOptionPane.WARNING_MESSAGE Mensagens de aviso. Aparece um tringulo
com um ponto de exclamao dentro.
JOptionPane.QUESTION_MESSAGE Vem com um ponto de interrogao.
JOptionPane.PLAIN_MESSAGE Aqui, no tem nada desenhado. Usado para
casos nos quais queremos uma mensagem s
com texto.
Alm do mtodo showMessageDialog, temos o showConfirmDialog, o showInputDialog e o

showOptionDialog. Vejamos ento cada um deles.
Fbio Burch Salvador
showConfirmDialog
Muito utilizado para operaes do tipo confirme ou cancele o que acabou de pedir, o melhor remdio
contra usurios desavisados que clicam nas opes da tela a esmo.
import java.awt.*;
class optiones {
int opcao = JOptionPane.showConfirmDialog(null, "Voc quer mesmo ler minha mensagem?", "Pergunta besta",
JOptionPane.YES_NO_CANCEL_OPTION);
if (opcao == JOptionPane.OK_OPTION) {
JOptionPane.showMessageDialog(null, "Voc escolheu ler a mensagem!", "Parabns!",
JOptionPane.INFORMATION_MESSAGE);
}
else if (opcao == JOptionPane.NO_OPTION) {

JOptionPane.showMessageDialog(null, "Voc um imaturo!", "Porcaria!", JOptionPane.ERROR_MESSAGE);
}
else if (opcao == JOptionPane.CANCEL_OPTION) {

JOptionPane.showMessageDialog(null, "Voc ficou indeciso e resolveu recuar! um fraco?", "Covarde!",
JOptionPane.QUESTION_MESSAGE);
}
}
}
No cdigo acima, nossa pergunta feita atravs de um JOptionPane.showConfirmDialog, cujos

argumentos mais uma vez so o objeto pai, a mensagem, o ttulo e o tipo de mensagem.
S que o tipo de mensagem aqui JOptionPane. YES_NO_CANCEL_OPTION. Com isso, eu obtive
trs botes, o Yes, o No, e o Cancel. Alm do YES_NO_CANCEL, temos outras modalidades de
pergunta:
YES_NO_CANCEL_OPTION Botes Yes, No e Cancel

YES_NO_OPTION Botes Yes e No
OK_CANCEL_OPTION Botes OK e Cancel
PLAN_MESSAGE Boto OK apenas, deixando igual ao showMessageDialog
showOptionDialog
Este mtodo , sem sombra de dvidas, o mais legal de todos da coleo JOptionPane. Com ele,
podemos fazer nossos prprios botes, em nmero indeterminado.
import java.awt.*;
class optiones {
String[]botoes = {"Abort", "Retry", "Fail", "CTRL+ALT+DEL"};
int opcao = JOptionPane.showOptionDialog(null, "Escolha uma opo", "Sem sada",

JOptionPane.DEFAULT_OPTION, JOptionPane.QUESTION_MESSAGE, null, botoes, botoes[0]);
JOptionPane.showMessageDialog(null, botoes[opcao], "Opo escolhida", JOptionPane.WARNING_MESSAGE);
}
}
No cdigo acima, temos o seguinte:

Primeiro, eu criei um vetor de Strings chamado botoes. Nele, guardei uma srie de textos para usar
dentro dos botes da minha caixa de opes.
Depois, eu declarei uma varivel int chamada opcao, onde ficar guardada a escolha que o usurio
fizer. A esta varivel, atribu diretamente o valor da operao de JOptionPane.showOptionDialog. Veja
que ele tem um monto de 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 (eu marque 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 botoes" que eu acabara de criar), e em seguida, a opo que vem destacada como
default (no caso, coloquei a primeira).
Na linha final do programa, eu simplesmente mandei exibir uma JOptionPane.showMessageDialog com
os seguintes argumentos:
Componente pai: null.
Mensagem: o texto do vetor botoes", no ndice que corresponde opo clicada (ou seja, vai aparecer
o texto do boto clicado).
Ttulo: Opo escolhida
Tipo de mensagem: WARNING_MESSAGE
Fbio Burch Salvador
showInputDialog
Este mtodo simplssimo. Ele exibe na tela uma
caixinha de mensagem com um campo de texto
para o usurio colocar alguma coisa. Esta texto
ser carregado em uma String, que deve ser logo
colocada como varivel para a qual vamos atribuir
o resultado.
Um cdigo de exemplo:
import java.awt.*;
class optiones {
String texto = JOptionPane.showInputDialog(null, "Escreva seu nome a", "Pegadinha",

JOptionPane.QUESTION_MESSAGE);
JOptionPane.showMessageDialog(null, texto, "O otrio do ano", JOptionPane.INFORMATION_MESSAGE);
}
}
Este cdigo simplssimo apenas pega o nome do usurio e depois o exibe como o otrio do ano, numa
premiao de mrito duvidoso.
JMenuBar, JMenu e JMenuItem
Estas classes so utilizadas sempre em conjunto, para criar um menu na parte superior do JFrame, e
deixar seu software com aquela facilidade de uso que os usurios modernos exigem.
Aqui, comeamos a trabalhar uma modalidade de programao que costumo chamar informalmente de
empilhamento de objetos, pois os objetos s funcionam quando colocamos um dentro do outro em
uma espcie de pirmide.
O objeto que serve de base o JMenuBar, adicionado diretamente ao JFrame, e sobre ele vo todas as
coisas. Ele a barra clara no alto do JFrame, dentro da qual os menus ficaro. Depois, temos os
JMenu, que ficam dentro da MenuBar e podem, inclusive, ficar um dentro do outro. Dentro dos JMenu,
ficam os JMenuItem, que tm uma funo cada um. Para ativar suas funes, utilizaremos os Listeners,
mais adiante. Deixemos isso para outro captulo.
import java.awt.*;
class menus {
JMenuBar menuzao = new JMenuBar();
JMenu menuarquivo = new JMenu("Arquivo");

JMenu menuhelp = new JMenu("Help");
JMenu menudentro = new JMenu("Mais opes");
JMenuItem itemnovo = new JMenuItem("Novo");

JMenuItem itemsalvar = new JMenuItem("Salvar");
JMenuItem itemajuda = new JMenuItem("Ajuda");
JMenuItem itemsobre = new JMenuItem("Sobre");
JMenuItem itempanico = new JMenuItem("CTRL+ALT+DEL");
JMenuItem itemterror = new JMenuItem("Tela Azul da Morte");
menuarquivo.add(itemnovo);
menuarquivo.add(itemsalvar);
menuhelp.add(itemajuda);
menuhelp.add(itemsobre);
menudentro.add(itempanico);
menudentro.add(itemterror);
menuzao.add(menuarquivo);
menuzao.add(menuhelp);
menuarquivo.add(menudentro);
tela.setJMenuBar(menuzao);
}
}
Fbio Burch Salvador
JCheckBox
Uma JCheckBox um daqueles componentes em que vemos uma caixinha quadrada com uma frase ao
lado, e podemos marcar ou desmarcar a caixinha quadrada. As CheckBoxes no so usadas para fazer
escolhas com apenas uma opo vlida, podendo ser todas marcadas ou todas desmarcadas
livremente, desde que o programador no coloque restries no prprio cdigo.
public class checa { Nesta parte inicial nada de novo:
public static void main(String[]args) { criamos um JFrame comum para
JFrame tela = new JFrame("Checks!"); receber os novos componentes.
final JCheckBox pizza = new JCheckBox("Quero uma Pizza.");

final JCheckBox refri = new JCheckBox("Quero um refri.");
Aqui, criamos os JCheckBoxes,
pizza.setBounds(100,30,200,35); dando-lhes, no ato de instanci-los,
refri.setBounds(100,80,200,35); j o texto que tero. E logo depois,
usamos o setBounds para dar-lhes
pizza.setSelected(true); localizao e tamanho.
O mtodo setSelected, cujo
tela.add(pizza); argumento um boolean, diz se a
tela.add(refri); caixinha vem marcada ou no.
}
Depois, para termos um retorno do valor de cada JCheckBox, utilizamos o mtodo isSelected(), que
retorna um valor boolean. Assim:
boolean x = pizza.isSelected();
Ou ainda:
If (pizza.isSelected()) {
- Funes a serem executadas.
}
Na pgina seguinte, temos um cdigo de exemplo sobre como utilizar a CheckBox e ter seu retorno
atravs de um boto ao qual foi adicionado um ActionListener.
Voc vai ver ActionListeners ao longo dos nossos exemplos, ento, para no ficar confuso demais, por
favor d uma lida no captulo que se chama Eventos (Listeners).
Exemplo de cdigo com uma JCheckBox retornando valor
Voltamos a proceder com a criao da tela e
public class radio { dos JCheckBoxes como no exemplo anterior.
JFrame tela = new JFrame("Checks!");
tela.setLayout(null);p
final JCheckBox pizza = new JCheckBox("Quero uma Pizza.");

final JCheckBox refri = new JCheckBox("Quero um refri.");
pizza.setBounds(100,30,200,35); Aqui, criamos um JButton, em um

refri.setBounds(100,80,200,35); esquema igual ao que j vimos
anteriormente na parte dos Eventos
pizza.setSelected(true); (ActionListener, MouseListener, etc.).
Note que, quando o JCheckBox pizza
JButton botao = new JButton("Fazer pedido"); retornar TRUE no seu mtodo
botao.setBounds(100,150,200,35); isSelected(), o programa exibe uma
botao.addActionListener(new ActionListener() { mensagem.
public void actionPerformed(ActionEvent e) {

if (pizza.isSelected()) {
JOptionPane.showMessageDialog(null, "O sujeito quer uma pizza.", "Pedido",
}
if (refri.isSelected()) {
JOptionPane.showMessageDialog(null, "O sujeito quer um refrigerante.", "Pedido",
} Eu utilizei dois IFs, independentes, sem ELSE, para que quando o
}
usurio marcar apenas uma opo, aparea s aquela opo, e
quando ele marcar as duas, pizza e refri, me apaream duas
});
mensagens consecutivas. claro que isso s um exemplo de
programa. Na realidade, devemos concatenar duas Strings para
formar a lista do pedido, ou gravar os dados em um Banco de Dados,
tela.add(botao);
ou fazer alguma outra coisa mais til e funcional.
tela.add(pizza);
tela.add(refri);
}
}
Fbio Burch Salvador
JRadioButton
O JRadioButton funciona apenas quando pensamos nele inserido em um grupo. Eu posso colocar
quantas opes quiser, formando um menu, e se todos os meus JRadioButtons estiverem no mesmo
grupo, o usurio s poder marcar um deles. Ao marcar um, os outros perdem a marcao.
Eu comeo como quem no quer nada: criando
um JFrame sem nenhuma novidade. Nenhuma,
mesmo.
public class radio {
JFrame tela = new JFrame("Radios!"); Logo depois, instancio os JRadioButton, j
tela.setBounds(10,10,800,600); determinando seu texto de apresentao.
tela.setLayout(null); Abaixo, uso o tradicional setBounds para
posicionar e dimensionar cada um deles.
JRadioButton designer = new JRadioButton("Eu sou WebDesigner!");
JRadioButton programador = new JRadioButton("Eu sou programador Java!");
designer.setBounds(20,20,250,35);
programador.setBounds(20,60,250,35); Mais abaixo, vem a verdadeira novidade: eu sou
obrigado a criar um ButtonGroup para que os
ButtonGroup grupo = new ButtonGroup(); JRadioButtons saibam que so irmos e
grupo.add(designer); comportem-se como tal, tendo sempre somente
grupo.add(programador); um deles selecionado.
Este ButtonGroup tem fins apenas lgicos, e no
tela.add(designer); grficos. Portanto, eu ainda preciso dar um ADD
tela.add(programador); em cada boto para dentro da tela.
}
Na prxima pgina, teremos um exemplo de como funciona o retorno dos valores (novamente, assim
como o JCheckBox, o JRadioButton retorna um BOOLEAN atravs do mtodo isSelected()).
Exemplo funcional de uso do JRadioButton
Nesta primeira parte, eu fao tudo o que fiz
no exemplo anterior: criar a tela e criar os
JRadioButtons. S que eu usei o mtodo
setSelected para dizer que a opo
public class radio {
public static void main(String[]args) { programador j vem marcada como TRUE
JFrame tela = new JFrame("Radios!"); desde o comeo, ficando como opo
tela.setBounds(10,10,800,600); default.
final JRadioButton designer = new JRadioButton("Eu sou WebDesigner!");

final JRadioButton programador = new JRadioButton("Eu sou programador Java!");
designer.setBounds(20,20,250,35);
programador.setBounds(20,60,250,35);
ButtonGroup grupo = new ButtonGroup();

grupo.add(designer); Aqui, usei nosso j conhecido ActionListener,
grupo.add(programador); para descobrir qual a caixa que est marcada.
Note que usei novamente IFs independentes:
programador.setSelected(true); o prprio ButtonGroup encarregar-se- de
manter apenas um deles marcado.
JButton botao = new JButton("Teste!");

botao.addActionListener(new ActionListener() {

if (designer.isSelected()) {
JOptionPane.showMessageDialog(null, "Eu fao site colorido com logo cor
lils.","Homem de rosa, o que que voc faz?",JOptionPane.INFORMATION_MESSAGE);
}
if (programador.isSelected()) {
JOptionPane.showMessageDialog(null, "Escrevo cdigo-fonte que assusta o
satans.","Homem de preto, o que que voc faz?",JOptionPane.INFORMATION_MESSAGE);
}
}
});
tela.add(botao);
tela.add(designer);
tela.add(programador);
}
Fbio Burch Salvador
JComboBox
A JComboBox desenha uma caixinha parecida com a JTextField, s que ao invs de termos um texto a
escrever, temos uma seta com a qual abrimos uma fileira de possibilidades de preenchimento para a
caixa.
import java.awt.*;
public class combo {

public static void main(String[]args){ Eu comeo como sempre: criando uma
JFrame tela = new JFrame("Combo"); JFrame para abrigar nosso JComboBox.
JComboBox comb = new JComboBox(); Na hora de criar as JComboBoxes, eu comeo

comb.setBounds(100,100,150,35); instanciado-a na varivel COMB. Depois, uso o
comb.addItem("Gacho"); mtodo addItem(xxx) para escrever as opes
comb.addItem("Baiano"); que aparecero ao usurio.
comb.addItem("Paulista"); O mtodo setEditable(boolean) diz se o usurio
comb.addItem("Carioca"); ter a opo de escrever na caixa (ignorando as
opes disponveis) ou no.
comb.setEditable(false); O mtodo setSelectedIndex diz qual o item que
aparecer como default ao usurio. Usa-se aqui a
comb.setSelectedIndex(0); mesma idia dos ndices de vetor para as opes.
tela.add(comb);
Para obter o retorno das informaes, temos uma srie de mtodos que nos dizem o que, afinal, o
usurio escolheu. Os mais usados so os seguintes:
comb.getSelectedItem()
Este retorna o texto que est na caixa do Combo. Poder ser usado especialmente para quando
colocamos o setEditable em TRUE, ou seja, quando o usurio pode escrever na caixa. O retorno deste
mtodo uma String, com o texto da caixa.
comb.getSelectedIndex();
Este mtodo retorna o ndice do item selecionado (como se as opes fossem um vetor). Caso o
usurio possa escrever algo na caixa de texto, e escreva alguma coisa que no consta das opes
fornecidas, ento o ndice que retorna o -1. Portanto, s use se o setEditable for FALSE.
JTabbedPane
Este componente utilizado para criarmos um daqueles menus separados em abas, as quais podem
ser alternadas na parte superior da tela.
Uma TabbedPane funciona de maneira bem simples: primeiro, criamos nossas JTextFields, JLabels,
Combos, Radios, Checks e o que mais quisermos. Depois, colocamos tudo isso dentro de JPanels.
Em seguida, dizemos ao Java que cada JPanel uma das abas da JTabbedPane.
import javax.swing.*; No incio, nada de novo: criamos os objetos e s. Mas
note que o argumento da criao da JTabbedPane
import java.awt.*; JTabbedPane.TOP no meu tabbed de exemplo,
teremos os nomes das abas no topo. Pode-se usar
public class table { ainda LEFT, RIGHT e BOTTOM.
JFrame tela = new JFrame("Telex");
JTabbedPane tabs = new JTabbedPane(JTabbedPane.TOP);
tabs.setBounds(10,10,770,550);
Depois de criar os JPanels, inserimos eles
JPanel painel1 = new JPanel(); com o mtodo ADD da JTabbedPane,
painel1.setBackground(Color.RED); especificando qual a palavra que os
representar no menu das abas.
JPanel painel2 = new JPanel();
painel2.setBackground(Color.BLUE);
tabs.add("Primeiro",painel1);
tabs.add("Segundo",painel2);
tela.add(tabs);
}
}
possvel iniciar o programa com uma aba especfica j selecionada, atravs do mtodo:
tabs.setSelectedIndex(X) onde X o ndice da tab que queremos ver selecionada os ndices
atribuem-se por ordem de adio das abas JTabbedPane, comportando-se como um vetor.
possvel tambm atribuir cones s Tabs, usando o mtodo:
tabs.seiIconAt(I) onde I um objeto do tipo Icon, j com uma imagem carregada.
Fbio Burch Salvador
JScrollPane
Uma JScrollPane apenas um objeto que, associado a outras coisas (caixas de texto, tabelas, etc.)
confere-lhes o poder de ter uma barra de Scroll.
import java.awt.*;
public class scroler {
Este programa em si no
tem quase nada de novo:
criamos uma JFrame, um
JTextField tex = new JTextField();
JTextField, e damos
tex.setBounds(0,0,300,700);
setBounds em tudo.
A nica novidade que criamos um
JScrollPane scrots = new JScrollPane(tex); JScrollPane associado JTextField. E
scrots.setBounds(100,100,300,300); depois o colocamos na tela. Note que a
JTextField vai parar dentro do JScrollPane.
tela.add(scrots); Tente agora escrever um texto longo na
caixa de texto e veja o que acontece.
}
}
JTables
As tabelas que usamos para exibir dados no Java so o componente mais complexo que temos na rea
da interface grfica.
Em primeiro lugar, uma tabela serve para demonstrar os dados de uma forma esttica, sendo depois
muito difcil de mudar seus dados durante a execuo do programa. Por isso, usamos um modelo
(DefaultTableModel), que malevel, e atribumos JTable este modelo depois de modificarmos seus
dados.
O exemplo abaixo um cdigo no qual nossa tabela no tem barras de rolagem. Se tivermos mais
dados do que espao para exibi-los no espao da tabela, no veremos os de baixo.
import java.awt.event.*; De incio, so apenas as coisas

import javax.swing.*; tradicionais: imports, criao da
import javax.swing.table.DefaultTableModel; JFrame, etc.
import java.awt.*;
public class tabelas {
JFrame tela = new JFrame("Tabelas");
Aqui, eu crio a JTable e dou-lhe
JTable tabela = new JTable(); uma dimenso, adicionando-a
tabela.setBounds(10,10,200,400); tela logo em seguida.
tela.add(tabela);
Crio um vetor de Strings para serem os

String[] colunas = {"Nome", "Salrio"}; cabealhos das minhas colunas.
DefaultTableModel modelo = (DefaultTableModel) (new DefaultTableModel(){

public boolean isCellEditable(int row, int column) {
return false;
} Aqui, eu criei modelo, um objeto da classe
}); DefaultTableModel, e tive a preocupao de modificar o
retorno do seu mtodo isCellEditable, tornando seu
retorno false, para que o usurio no possa escrever
diretamente na tabela. Este objeto modelo, uma vez
preenchido com os dados, dever ser colado na JTable.
modelo.setColumnIdentifiers(colunas); Aqui, eu transformei o meu vetor de Strings

em cabealhos de colunas atravs do mtodo
setColumnsIdentifiers().
modelo.setRowCount(0);
Com o mtodo setRowCount, dizemos quantas linhas da tabela devero ficar (o resto
some). Eu disse que so ZERO, ou seja, zerei a tabela. Este procedimento deve ser
feito sempre no comeo do processo de carregar dados na tabela.
Aqui, criamos um vetor de objetos do tipo Object a

Object[] objetos = new Object[2]; base de todas as coisas existentes em Java. Dentro
deste vetor, poderemos gravar imagens (Icon), Strings,
o que quisermos.
Fbio Burch Salvador
O prximo passo consiste em carregar este vetor objetos
objetos[0] = "Z das Couves";
no caso, com Strings. Em seguida, uso o mtodo
objetos[1] = "1000";
addRows do DefaultTableModel para adicionar o vetor
modelo.addRow(objetos);
objetos como uma linha de dados no modelo de tabela.
objetos[0] = "Silvio Santos";

objetos[1] = "50000"; Note que estou reutilizando o vetor objetos para carregar
modelo.addRow(objetos); novas linhas no modelo. Eu vou repetir esta operao
quantas vezes forem necessrias. Poderia ter feito esta
objetos[0] = "Lula-l"; operao repetitiva usando um FOR ou um WHILE. Isso ser
objetos[1] = "12000"; muito til depois de vermos a parte de Banco de Dados.
Agora, meu objeto modelo est pronto. Ele uma espcie de

uma tabela virtual, que no visualizvel. Para podermos
v-lo graficamente na tela, temos que usar um objeto JTable.
E por isso mesmo criamos o tabela (lembra?). Agora,
tabela.setModel(modelo); usamos o mtodo setModel para unir os dois.
tela.setVisible(true); O resto apenas a perfumaria de sempre: tirar o
Layout, especificar o DefaultCloreOperation, e dar um
} setVisible na tela.
}
Depois, eu posso conseguir o retorno de dados da tabela, por exemplo, quando o usurio clicar duas
vezes na minha tabela. Para isso, bastaria adicionar aps o tela.setVisible(true) um MouseListener
tabela.addMouseListener(new MouseListener() { Aqui, apenas especifiquei que a

ao ocorrer quando o usurio
public void mouseClicked(MouseEvent e) { der um duplo clique. Nada novo.
if (e.getClickCount() == 2) {
int linha = tabela.getSelectedRow();

String mensagem = (tabela.getValueAt(linha,0).toString()) + " ganha R$ " +
(tabela.getValueAt(linha,1).toString());
A instruo acima a nica novidade deste cdigo: temos um mtodo chamado getSelectedRow,
que vai descobrir qual o ndice da linha selecionada. Depois, temos o mtodo tabela.getValueAt,
no qual passamos como argumento uma coordenada parecida com as que usvamos para as
matrizes. Assim, no caso, eu coloquei o nmero da linha, vrgula, o ndice da coluna (zero e um,
porque s temos essas duas).
JOptionPane.showMessageDialog(null, mensagem, "Dados", JOptionPane.INFORMATION_MESSAGE );

}
}
public void mouseEntered(MouseEvent e) {
}
public void mouseExited(MouseEvent e) {
}
public void mousePressed(MouseEvent e) {
}
public void mouseReleased(MouseEvent e) {
}
});
JTables e a interao com outros objetos - Uma JTable o objeto perfeito para associar a um
JScrollPane.Tambm podemos criar JTables carregadas com imagens.
Fbio Burch Salvador
JFileChooser
O JFileChooser o componente que nos exibe uma caixinha para selecionar um arquivo no sistema de
pastas do Windows ou do Linux (ou, de seja l o que estivermos usando).
import sun.audio.*;
import com.sun.java.util.*;
import java.awt.*;
import java.awt.Event.*; criao de objetos, no caso, do JFrame
import java.io.*; e do JFileChooser.
public class filechus {

JFileChooser filex = new JFileChooser();
O mtodo showOpenDialog, que tem como
argumento algum objeto ao qual a caixa de seleo
estar associada. Este mtodo retorna um valor
INT, que a resposta do usurio (se ele selecionou
int opcao = filex.showOpenDialog(tela); um arquivo ou se desistiu). Outro mtodo,
showSaveDialog(tela) d uma caixinha apropriada
para SALVAR o arquivo.
Se o retorno da opo anterior for

afirmativo (esta a questo no IF), eu
carrego o arquivo selecionado em uma
if (opcao==JFileChooser.APPROVE_OPTION) { varivel do tipo FILE, que guarda vrios
File nomearquivo = filex.getSelectedFile(); dados sobre o arquivo, e que podem ser
extrados por diversos mtodos que
veremos logo em seguida
try {
InputStream arq = new FileInputStream(nomearquivo);
AudioStream som = new AudioStream(arq);
AudioPlayer.player.start(som);
O resto do cdigo no faz parte realmente
System.out.println("Tocando");
do JFileChooser trata-se do cdigo j
}
visto para tocar msica. O usurio dever
selecionar um arquivo WAV para tocar.
System.out.println("Deu merda");
}
O resto do cdigo so nossos conhecidos
comandos de exibir o JFrame (quando o
JFrame for fechado, o programa cair fora
do ar e a msica cessar).
}
}
}
Mtodos de retorno de dados mais usados do JFileChooser:
Boolean x = filex.getSelectedFile().canRead(); - retorna se o arquivo pode ser lido.
Boolean x = filex.getSelectedFile().canWrite(); - retorna se o arquivo pode ser sobrescrito.
String x = filex.getSelectedFile().getName(); - retorna o nome do arquivo.
String x = filex.getSelectedFile().getPath(); - retorna o local do arquivo.
boolean x = filex.getSelectedFile().exists(); - retorna se o arquivo existe ou no.
Fbio Burch Salvador
JInternalFrame
Finalmente, estamos chegando ao ponto no qual podemos criar uma aplicao funcional. Agora,
criaremos as famosas telinhas internas do programa. Voc j deve ter observado que, quando usamos
o Microsoft Word, por exemplo, o programa em si tem uma grande tela com uma rea dentro da qual
fica apenas o JFrame com o texto que estamos trabalhando.
Aqui, faremos isso e no nada muito complicado. A lgica a seguinte: primeiro, precisamos ter um
JDesktopPane, que uma rea, dentro de uma grande JFrame. Dentro desta JDesktopPane, teremos
nossas JInternalFrame, que nada mais so do que pequenas telas internas.
import sun.audio.*;
import com.sun.java.util.*; Comeamos o programa como sempre: imports e criao da
import java.awt.*; JFrame. Mas note que eu instanciei a classe JDesktopPane.
import java.awt.Event.*; Ela servir apenas para fazer a acomodao dos
import java.awt.event.*; JInternalFrame dentro da JFrame maior.
import java.io.*;
public class filechus {

JDesktopPane deska = new JDesktopPane();
final JInternalFrame telinha1 = new JInternalFrame("Tela Interna 1", true, true, true, true);
final JInternalFrame telinha2 = new JInternalFrame("Tela Interna 2", true, true, true, true);
Na hora de instanciar as duas JInternalFrame (telinha1 e telinha2), note que eu coloquei

como argumentos o ttulo da janelinha e quatro TRUEs. Estes TRUEs (que bem
poderiam ser FALSEs), so respectivamente:
A telinha redimensionvel?
A telinha tem o boto FECHAR em forma de X no canto?
A telinha pode ser maximizada?
A telinha pode ser minimizada?
telinha1.setBounds(0,0,300,400); Aqui, eu usei o setBounds normalmente nas

telinha2.setBounds(0,0,300,400); JInternalFrames, para logo em seguida dar-lhes a
instruo HIDE. Elas ficaro escondidas at que
telinha1.hide(); sejam chamadas. Elas esto vivas, na memria,
telinha2.hide(); mas escondidas. Hide em ingls significa
esconder.
telinha1.setDefaultCloseOperation(JInternalFrame.HIDE_ON_CLOSE);
telinha2.setDefaultCloseOperation(JInternalFrame.HIDE_ON_CLOSE);
Note que eu escolhi, como DefaultCloseOperation, o HIDE_ON_CLOSE. Isso quer dizer

que, quando fechadas, minhas telinhas internas no sero descarregadas da memria (o
que aconteceria se fosse DISPOSE_ON_CLOSE) e nem o programa sair do ar (o que
aconteceria com EXIT_ON_CLOSE). As telinhas vo simplesmente ser escondidas,
ficando invisveis.
JMenuItem t1= new JMenuItem ("Tela 1");
JMenuItem t2 = new JMenuItem ("Tela 2");
JMenuBar barra = new JMenuBar();
JMenu menu = new JMenu("Opes");
Os passos seguintes no constituem novidade

alguma. Aqui, criamos um menu para que o
barra.add(menu); usurio possa chamar as duas telinhas de
menu.add(t1); teste.
menu.add(t2);
t1.addActionListener(new ActionListener() {
Aqui, eu simplesmente adicionei
ActionListeners aos meus itens de
telinha1.show();
menu. A ao de cada um deles
}
simplesmente ativar o mtodo
});
show() de uma das telinhas, o que
as far ficar visveis.
t2.addActionListener(new ActionListener() {
telinha2.show();
}
});
Agora, aqui importante notar como as coisas so
estruturadas umas dentro das outras. Eu tenho minhas
JInternalFrames (telinha e telinha2) presas dentro de um
deska.add(telinha1);
JDesktopPane (deska). E o JDesktopPane preso dentro da
deska.add(telinha2);
JFrame (tela).
tela.add(deska);
As instrues que vm logo em seguida so antigas para ns:
a insero da JMenuBar dentro da JFrame, e as instrues
tela.setJMenuBar(barra);
finais de exibio da tela.
}
}
Fbio Burch Salvador
Tree
Vamos ver agora um componente que d um certo estilo a qualquer projeto. Trata-
se do Tree. Com ele, podemos criar aqueles menus em que as opes ficam umas
dentro das outras e vo se abrindo medida que o usurio clica nelas.
A aplicao de um Tree segue um esquema parecido com o das Jtables ns temos
uma modelagem toda feita em um objeto que no visvel, e no final temos a encarnao deste
modelo em um objeto que passvel de adio na tela.
import java.sql.*;
import javax.swing.tree.DefaultMutableTreeNode;

static Connection con; Eu comeo meu cdigo de uma forma bem banal: criando
public static void main(String[]args) { uma JFrame.
tela.setBounds(10,10,600,400); Notem que logo em seguida eu crio um Array de Object. Este
Array contm as informaes para um n da minha Tree.
Object[] opcoes = { Vejam que eu criei um objeto DefaultMutableTreeNode (um n
"Opes", da Tree, que ser atribudo a ela depois).
"Opo 1",
"Opo 2", Este primeiro n, eu criei importando opcoes[0], que a palavra
"Opo 3" Opes - este n ser paii de outros que eu criarei depois.
};
DefaultMutableTreeNode nos = new DefaultMutableTreeNode(opcoes[0]);
DefaultMutableTreeNode child;
for(int cont = 1; cont < opcoes.length; cont++){
Object obj = opcoes[cont]; Depois de criar o n nos, eu criei o child - este guardar os
child = new DefaultMutableTreeNode(obj); filhotes do nos. Eu usarei um nico objeto do tipo n, o child,
nos.add(child); que ser reutilizado vrias vezes.
}
Veja que eu fiz um FOR. Ele roda todos os elementos do Array
opcoes, menos o de ndice zero (que a palavra Opes, e
que eu j usei para fazer o n pai).
A cada rodada do FOR, eu carrego a palavra do ndice em que

JTree tri = new JTree(nos); a varivel CONT est (e ela corre do 1 ao, no caso, 3). E a cada
rodada, ela carregada no n child.
tri.setBounds(0,0,200,400);
Depois, eu adiciono child dentro do n no, e o FOR faz outro
tela.add(tri); giro, reutilizando child para adicionar mais um filho a no.
}
}
Depois de adicionar todos os ns filhotes, a varivel child torna-se intil. Mas a varivel nos
agora guarda o n que tem a palavra Opes e mais todos os sub-ns adicionados no processo
que rodamos no FOR. Assim, temos o menu completinho.
Eventos (Listeners)
ActionListener
Hoje, vamos ver algo muito interessante: o ActionListener. Trata-se de uma classe que detecta se
houve uma ao no objeto a que ela est associada (um boto, por exemplo), e que, dependendo da
ao executada, rodar uma funo qualquer. Vejamos um exemplo de cdigo usando o ActionListener:
import java.awt.*;
public class mongol {
JFrame tela = new JFrame("Teste");
JButton botao = new JButton("Aperte aqui");
At aqui, no fizemos nada de diferente. Criamos a JFrame e um boto.

ActionListener ac = new ActionListener() {
Aqui, instanciamos a classe ActionListener, mas modificamos um de seus mtodos, no caso, o

ActionPerformed, que tem o poder de fazer alguma coisa quando o usurio clicar no objeto que tem
ActionListener.
A declarao acima um mtodo, o mesmo que citamos antes. O argumento dele um evento ocorrido
que fica em uma lista de eventos possveis determinados pelo usurio, como veremos mais adiante.
if ("botao1".equals(e.getActionCommand())) {
JOptionPane.showMessageDialog(null, "Apertou o boto!", "Ol!",

}
Aqui, a coisa simples: caso o ActionCommand do evento e seja igual a botao1, uma caixa com
uma mensagem aparecer na tela.
}
};
Quando alteramos um mtodo da classe no momento de sua instanciao, terminamos com chaves e
ponto-e-vrgula; Agora, vem o final, montar a tela e colocar este ActionListener para funcionar.
botao.setActionCommand("botao1");
botao.addActionListener(ac);
Acima, eu determinei qual o ActionCommand do boto (no caso botao1), e depois adicionei o
ActionListener ao boto, fazendo com que ele passe a detectar quando o usurio clica no boto,
acionando o mtodo ActionPerformed.
tela.add(botao);
}
}
Fbio Burch Salvador
FocusListener
O FocusListener se parece com o ActionListener em seu modo de construo, mas serve para detectar
quando o foco (ou seja, o cursor, a seleo, no o ponteiro do mouse) est sobre um objeto ou no.
Ele possui dois mtodos que precisam ser implementados: o focusGained e o focusLost, um para
quando o objeto ganha foco e outro para quando perde.
import java.awt.*;
final JFrame tela = new JFrame("Teste");
final JTextField tex = new JTextField();
final JTextField tex2 = new JTextField();
tex2.setBounds(50,150,300,35);
FocusListener foc = new FocusListener() {
public void focusGained(FocusEvent e) {

tex.setBackground(Color.RED);
}
public void focusLost(FocusEvent e) {

tex.setBackground(Color.BLUE);
}
};
tex.addFocusListener(foc);
tela.add(tex);
tela.add(tex2);
}
}
KeyEvent
O KeyEvent serve para que eu possa coordenar as aes do usurio com o teclado quando ele est
escrevendo em algum espao ou utilizando alguma funo. Posso atribuir KeyListener a qualquer objeto
grfico do Java QUALQUER! e detectar o que, afinal, o meu usurio est apertando no teclado.
import java.awt.*;

KeyListener key = new KeyListener() {

public void keyPressed(KeyEvent e) {
tex.setBackground(Color.BLUE);
tex.setForeground(Color.WHITE);
}
Acima, defini a ao do mtodo keyPressed, ou seja, quando o usurio enfia o dedo no boto.
public void keyReleased(KeyEvent e) {
tex.setBackground(Color.BLACK);
tex.setForeground(Color.YELLOW);
}
Acima, defini a ao a executar para quando o usurio tira o dedo do boto que havia pressionado.
public void keyTyped(KeyEvent e) {
JOptionPane.showMessageDialog(null, "Typou rapaz", "Obviedades",
}
O mtodo keyTyped funciona quando o aperto da tecla faz efeito. Isso quer dizer que se eu botar o
dedo numa letra do teclado, e no tirar mais, e esta letra ficar se repetindo, o evento keyTyped tambm
ficar.
};
tex.addKeyListener(key);
tela.add(tex);
tela.add(tex2);
}
}
NOTA: Pode-se detectar qual o boto apertado pelo usurio explorando a varivel KeyEvent e, que
retornar o cdigo da tecla apertada.
Fbio Burch Salvador
MouseListener
O MouseListener, como seu nome obviamente revela, serve para tratarmos eventos relacionados ao
uso do mouse.
import java.awt.*;

MouseListener mickey = new MouseListener() {
public void mouseClicked(MouseEvent e) {

int contador = e.getClickCount();
if (contador == 1) {
tex.setText("Voc deu um clique!");
}
else if (contador == 2) {
tex.setText("Voc deu um duplo clique!");
}
}
No mtodo acima, o mouseClicked, ou detecto que o usurio deu um ou mais cliques no meu
componente que possui o MouseListener. Bom. Uma vez definido que isto ocorre, eu resolvi dificultar
um pouco as coisas, colocando em prtica o mtodo getClickCount, que detecta quantas clicadas
rpidas o usurio deu sobre o objeto. Com isso, posso definir aes para o clique, o duplo clique, o
triplo clique, at o milhonsimo clique (os usurios que ficariam cansados, mas tudo bem).
public void mouseEntered(MouseEvent e) {
tex.setText("O mouse entrou!");
}
O mtodo mouseEntered ocorre quando o mouse adentra, quando o ponteiro passar por cima.
public void mouseExited(MouseEvent e) {
tex.setText("O mouse saiu!");
}
Obviamente, o mouseExited ocorre quando o ponteiro sair de cima do objeto.

public void mousePressed(MouseEvent e) {
tex.setBackground(Color.YELLOW);
}
mousePressed um evento que continua em ao enquanto o usurio no tirar o dedo de cima do

boto do mouse, ficando com ele apertado.
public void mouseReleased(MouseEvent e) {
tex.setBackground(Color.WHITE);
}
O evento mouseReleased acontece quando o usurio finalmente larga o boto.
};
tex.addMouseListener(mickey);
tela.add(tex);
tela.add(tex2);
}
}
Ns podemos saber qual a localizao do ponteiro do mouse utilizando dois mtodos:

getX() retorna a posio do mouse no eixo X (horizontal) dentro do objeto a que estamos atribuindo o
MouseListener.
getY() Faz o mesmo, s que com a posio do eixo Y (vertical).
Fbio Burch Salvador
Uma coleo de pequenos comandos soltos
Leitura de dimenses de componentes grficos e da prpria tela

int x = qualquer componente grfico.getHeight();
Pega a altura de qualquer componente grfico.
int x = qualquer componente grfico.getWidth();
Pega a largura de qualquer componente grfico.
double alt = Toolkit.getDefaultToolkit().getScreenSize().getHeight();

double larg = Toolkit.getDefaultToolkit().getScreenSize().getWidth();
Estes dois commandos pegam, respectivamente, a altura e a largura da TELA, no de um componente

ou da JFrame. Com isso, possvel centralizar nossa JFrame no vdeo do usurio, mesmo que no
saibamos a definio (em pixels) utilizada por ele. A frmula para isso simples:
Posio da JFrame no eixo X igual a: Largura da tela, dividida por dois, menos a largura do JFrame,
dividida por dois. E o mesmo repete-se em relao ao eixo Y, mas associado altura da tela.
Converso de dados
Transformar Strings em int

int qualquercoisa = Integer.parseInt(stringqualquer);
Transformar int em String

stringqualquer = Integer.toString(intzinho);
Transformar String em double

double numero = Double.ValueOf(stringzinha).doubleValue();
Transformar double em String

stringzinha = Double.toString(doublequalquer);
Transformar double em int

int x = (int) numerodouble;
Fazendo uma JFrame sumir, morrer e derrubar o programa
J estudamos a JFrame em diversos exemplos, mas vale a pena dar uma olhada na relao que existe
entre o setDefaultCloseOperation e os modos de fechamento da JFrame.
Existem trs formas de uma JFrame desaparecer da tela:
HIDE Apenas esconde a JFrame, mas o objeto continua na memria, podendo ser recuperada a
qualquer momento pelo mtodo SHOW (tela.hide() e tela.show()).
DISPOSE O objeto JFrame destrudo completamente. Para faz-lo reaparecer na tela, preciso
usar o NEW e criar um objeto novo, re-declarar a varivel, e tudo mais. Este o mtodo mais utilizado
para operar com JInternalFrames, onde utilizar-se- a sintaxe tela.dispose().
EXIT Na verdade, no uma operao associada JFrame, e sim, uma ordem de fechamento do
programa inteiro.
Relaes com o setDefaultCloseOperation

O setDefaultCloseOperation serve para dizermos ao programa o que queremos que o sistema faa
quando fechamos uma JFrame qualquer.
HIDE_ON_CLOSE O fechamento leva a janela a esconder-se, embora ela ainda exista.
DISPOSE_ON_CLOSE O fechamento leva a tela a se destruir, e para faz-la reaparecer, precisamos
usar o NEW, re-declarar a varivel, etc.
EXIT_ON_CLOSE Faz com que, ao fechar uma JFrame, o programa inteiro seja descarregado da
memria do computador. Utilize esta definio na JFrame principal do programa.
Sintaxe de exemplo:
Ringo no minimiza!
MATA!
Ordenando a uma JFrame que abra em modo
maximizado
Existe um mtodo, o setExtendedState, no qual podemos colocar como valor MAXIMIZED_BOTH, o
que nos trar a JFrame maximizada. Se for um JInternalFrame, ele vir maximizado dentro do
JDesktopPane ao qual pertence.
Sintaxe:
tela.setExtendedState(JFrame.MAXIMIZED_BOTH);
Existe uma grande diferena entre maximizar e simplesmente descobrir o tamanho da tela,
redimensionando o JFrame para o tamanho da tela. Quando usamos redimensionamento com
setBounds ou setSize, o programa continua tendo o boto de MAXIMIZAR, o que no acontece com o
caso explicado acima.
Fbio Burch Salvador
Redimensionando imagens para caberem dentro da JLabel
Para realizar esta tarefa, vamos explorar mais a fundo a classe ImageIcon, que at agora utilizamos
apenas de forma secundria, para carregar arquivos dentro de Icons, conforme todos devem j ter
testado algumas vezes. Esta classe possui uma funo bem interessante, na qual as imagens podem
ser lidas e redimensionadas (na tela, no no seu respectivo arquivo JPG ou PNG, claro).
O primeiro comando o conhecido

ImageIcon imagem = new ImageIcon("foto.jpg"); carregamento da imagem de arquivo para
dentro da varivel.
Image redimensionadora = imagem.getImage().getScaledInstance(largura, altura, Image.SCALE_DEFAULT);

Este segundo comando mais interessante. Nele, eu instancio a classe Image, que guardar
uma imagem abstrata, invisvel, mais ou menos na mesma lgica do DefaultTableModel (a
tabela invisvel, lembram?). Dentro deste objeto criado, carregarei o que resultar da seguinte
operao:
De dentro de imagem, retiramos s a imagem sem dados adicionais (mtodo getImage). E

neste objeto mesmo rodamos o mtodo getScaledInstance, que recebe como argumentos a
largura que a imagem deve ter, a altura, e o tipo de redimensionamento desejado. Usei o
SLACE_DEFAULT, que bem equilibrado. Poderia ter usado SCALE_FAST, no qual a imagem
pode ficar meio pixelada, mas o processamento mais rpido, ou SCALE_SMOOTH, que fica
sempre bem feito, mas mais lento.
imagem = new ImageIcon(redimensionadora); No final, carrego a imagem abstrata, invisvel, em

um formato visvel: o nosso tradicional ImageIcon
imagem, que ser utilizado de forma prtica.
Colocando uma imagem de plano de fundo dentro do JDesktopPane
Na verdade, colocar uma imagem de fundo no JDesktopPane igualzinho a colocar uma imagem em
qualquer lugar: usamos o JLabel, e colocamos ele dentro do JDesktopPane. Porm, ficam no ar
algumas questes, como o dimensionamento desta JLabel. Ora, acabamos de ver comandos que
descobrem a largura da tela, comandos de converso de dados em tipos diferentes, comandos de
redimensionamento de imagem. Chegou a hora de usar tudo isso ao mesmo tempo.
Um cdigo de exemplo:
import java.awt.*;
public class dentro { Primeiro passo, instanciar os objetos

public static void main(String[]args) { que usaremos. Vamos montar um menu
JFrame tela = new JFrame("Programa"); com uma opo s.
final JDesktopPane deska = new JDesktopPane();
JMenuBar barra = new JMenuBar();
JMenu opcoes = new JMenu("Opes");
JMenuItem abreinterna = new JMenuItem("Abrir telinha interna");
Nestas 4 linhas, eu
double alt = Toolkit.getDefaultToolkit().getScreenSize().getHeight();
descobri o tamanho da
double larg = Toolkit.getDefaultToolkit().getScreenSize().getWidth();
tela e converti suas
dimenses em INT.
int altura = (int) alt;
int largura = (int) larg;
ImageIcon imagem = new ImageIcon("foto.jpg");

Image redimensionadora = imagem.getImage().getScaledInstance(largura, altura, Image.SCALE_DEFAULT);
imagem = new ImageIcon(redimensionadora);
Aps redimensionar a imagem dentro do
ImageIcon, criei a Label com a imagem dentro
JLabel lab = new JLabel();
e a adicionei ao JDesktopPane. Note que eu
lab.setIcon(imagem);
dimensionei a JLabel e portanto a imagem a
partir do tamanho da tela. Assim, criei uma
lab.setBounds(0,0,largura,altura);
imagem de fundo para o programa.
deska.add(lab);
abreinterna.addActionListener(new ActionListener() {
JInternalFrame interna = new JInternalFrame("Tela menor", true, true, true, true);
interna.setBounds(10,10,400,400);
interna.setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);
deska.add(interna);
interna.setVisible(true); Dentro do ActionListener, eu coloquei toda a
}}); rotina de criao da JInternalFrame.
Inclusive, note que seu mtodo ao fechar o
DISPOSE_ON_CLOSE. Ou seja, a telinha
opcoes.add(abreinterna); interna ser criada para uso, e destruda
barra.add(opcoes); (liberando memria) quando no se quiser
tela.setJMenuBar(barra); usar.
tela.getContentPane().add(deska);
Fbio Burch Salvador
tela.setExtendedState(JFrame.MAXIMIZED_BOTH);
} Os comandos finais so a adio do JDesktopPane dentro da tela,
} e os tradicionais comandos que colocam a tela no ar. Ou seja,
nosso habitual final de cdigo de todos os exemplos. S que aqui a
tela abre maximizada.
Ateno!
No passe deste ponto sem ler algum material sobre SQL!
Voc deve conhecer SQL e bem provvel que, em breve, haja

tambm uma obra do mesmo autor sobre SQL.
Se voc no manja nada de SQL e nem sabe o que um banco

de dados, ento no prossiga! Procure informar-se primeiro.
Se voc no sabe como funciona um Banco de Dados,
NO PROSSIGA!
Eu avisei! Os incrdulos iro pagar!!!! h h h ha!!
Fbio Burch Salvador
Conexo Java + Banco de Dados

Hoje comearemos a conexo do nosso programa com um banco de dados. De incio, vamos usar a
ODBC para conectar com uma base Access.
O que a ODBC? ODBC um dispositivo existente no Windows com o qual podemos listar as bases de
dados configuradas neste computador ou pela rede e na qual as bases de dados recebem um nome
(um Alias). Uma vez criada a conexo ODBC, podemos acessar o banco de dados usando este Alias.
Como se configura o ODBC? Fcil! Primeiro, eu crio uma base de dados,

digamos, no Access.
Depois, v ao Painel de Controle do Windows.
Escolha as Ferramentas Administrativas.
Depois, escolha as Fontes de Dados (ODBC).
Depois, v ao boto Adicionar e escolha o tipo de base de dados. No caso, eu escolho neste exemplo
a do Access.
Da, aparecer a caixinha abaixo. Voc precisar encontrar o arquivo do banco de dados Access, que
Fbio Burch Salvador
voc gravou ao cria-lo. Para isso, use o boto Selecionar e v navegando pelas pastas at achar seu
arquivo.
No campo Descrio, escreva um nome (um Alias) para o seu banco de dados. Nada muito
complicado. Opte por nomes curtos. Coisas como bd_compras ou algo assim.
O uso de ODBC para conectar base de dados serve para a maior parte dos SGBD (Sistemas
Gerenciadores de Banco de Dados) existentes na face da Terra. Voc pode implementar nos seus
clientes se quiser. S que h outras maneiras de ligar um Banco de Dados a um programa.
Em seguida, voc dever criar sua aplicao Java com interao com o Banco de Dados. Vamos em
frente ento.
Criando a aplicao integrada
Eu vou comear construindo uma classe bem simples cuja nica funo criar uma conexo com o
banco de dados, que ser armazenada no objeto CON, que recebeu este nome por preferncia minha
(ele poderia se chamar CONECTA, CHUMBINHO ou MARIOLA, tanto faz).
import java.sql.*;
public class conecta{
static Connection con;
static void getConexao () {
try {
Class.forName("sun.jdbc.odbc.JdbcOdbcDriver");
}
catch(ClassNotFoundException e) {
System.out.println("Classe do driver nao encontrada:");
System.out.println(e.getMessage());
System.exit(1);
}
try {
String url = "jdbc:odbc:dbase";
con = DriverManager.getConnection(url, "username", "senha");
} catch (SQLException e) {
// TODO Auto-generated catch block
}
}
}
BONITO, N? Vamos agora esmiuar este cdigo linha por linha:

import java.sql.*;
Importa a biblioteca de classes para trabalhar com banco de dados.
public class conecta{

Aqui eu instanciei a classe Connection, que armazenar a conexo com o BD.

static void getConexao () {
try {
Class.forName("sun.jdbc.odbc.JdbcOdbcDriver");
}
Aqui, dei incio ao meu mtodo getConexao, que recebeu este nome tambm de forma casual o
mtodo que conecta pode ter qualquer nome. Aqui, usei um comando que talvez seja novidade para
alguns: o Class.forName. O Java tem dessas: aqui eu mando ele tentar achar essa classe pelo nome
dela e carregar. Na hora que eu fiz isso, comecei a ter acesso a umas coisas novas, como o
DriverManager, associada a esse driver que eu acabei de carregar (no caso, o JDBC-ODBC).
interessante notar que, quando usamos a classe SUN.JDBC.ODBC, dificilmente teremos como resposta
um erro de ausncia da classe, a no ser que o usurio esteja usando uma JRE do tempo das Grandes
Navegaes. S que esta verificao ser ainda muito til, quando importarmos uma classe que faz, por
exemplo, o trabalho de conexo do Java com uma base de dados MySQL esta classe dever ser
anexada ao projeto, de modo que pode ou no estar disponvel e se no estiver, gerar um erro,
visto logo no Catch.
catch(ClassNotFoundException e) {
System.out.println("Classe do driver nao encontrada!");
Fbio Burch Salvador
System.exit(1);
}
Bom, aqui eu tratei o erro, caso o programa no ache a classe a partir do forName. O negcio aqui
derrubar o programa. No caso dos programas que fazemos na prtica, do dia a dia das empresas, a
idia nunca ser derrubar o programa, e sim avisar ao usurio que deu algum problema e mand-lo
entrar em contato com o fabricante.
Um erro desses jamais acontece em condies normais, porque a classe que tem o driver sempre ser
compactada dentro do JAR junto com o programa. Se o usurio tiver esta surpresa desagradvel, de o
programa no achar a classe, ento o software no deveria nem ter sado da fase de testes, porque o
defeito vem desde a mesa do desenvolvedor e por alguma razo jamais foi detectado.
try {
String url = "jdbc:odbc:banco";
con = DriverManager.getConnection(url, "username", "senha");
Agora, olhem que legal: a classe DriverManager tem um mtodo que o getConnection, e ele retorna
uma conexo com banco de dados no uma String ou coisa assim, mas a conexo. E joga ela para a
varivel CON, que j uma Connection. Notem que eu usei ali trs argumentos: COM, USERNAME e
SENHA. O Con necessariamente sempre uma Connection que j tenha uma conexo a banco de
dados guardada. J no lugar de USERNAME e SENHA, colocamos o nome de usurio e a senha para
aquela determinada base de dados.
} catch (SQLException e) {
}
}
}
Depois, tem o Catch do carregamento da conexo. Aqui, no tem segredo se o banco falhar, ele tem
que fazer alguma coisa. Eu no coloquei nada, deixei s o cdigo que o Eclipse gera. Mas vocs vo
colocar uma mensagem de erro ou coisa assim. Erros de conexo a banco de dados normalmente
ocorrem por queda da rede (caso o BD fique em um servidor) ou porque algum ser quase humano, de
inteligncia rara e formidvel, desligou o servidor. Ou ainda porque a filha do dono da empresa resolveu
limpar o servidor, removendo os vrus e acabou com a base de dados.
Consultando o Banco de Dados
Para carregar os dados, voc vai precisar usar o Connection em associao com um Statement, que
um tipo de ordem para a Connection retornar alguma coisa.
Depois de mandar a classe CONECTA rodar seu mtodo getConexao, eu fao assim:
Statement comandoSQL = conecta.con.createStatement();
Aqui, criei o Statement chamado comandoSQL ligado conexo CON da classe CONECTA.
Lembrando que estes nomes no so fixos, e eu poderia ter usado outro nome de objeto ao invs de
COM ELKEMARAVILHA, por exemplo. A classe Conecta tambm, poderia chamar-se CHURROS e
no faria a menor diferena.
String sql = Select * from tabela;;
ResultSet resultado = comandoSQL.executeQuery(sql);
Aqui, logo depois de criar o Statement, eu crio uma String armazenando um comando SQL qualquer.
Depois, eu crio uma varivel do tipo RESULTSET, que como um vetor de dados tipo OBJECT, e que
armazena os dados que retornam uma consulta SQL qualquer chamada pelo mtodo executeQuery. Ele
recebe como argumento uma String onde h o comando SQL. Eu bem poderia escrever a String ali
mesmo, dentro do argumento do ResultSet, mas decidi fazer isso antes porque fica mais fcil de
entender o cdigo mais tarde, quando eu fizer manuteno no sistema.
modelo.setRowCount(0);
while(resultado.next()){
Object[] objetos = new Object[3];
for(int i = 0; i < 3; i++) {
objetos[i] = resultado3.getObject(i+2);
}
}
Bom, aqui eu usei os dados da tabela para carregar um DefaultTableModel, como ns j vimos l na
parte das JTables. No caso, o comando resultado.next faz rodar uma linha do ResultSet, e cada linha
dessas um pequeno vetor com os campos do registro. Da saiu a idia de usar um FOR e tudo mais.
Mas essa coisa de carregar um vetor de Objects e atirar para dentro do TableModel matria velha.
Ns tambm j vimos como se faz a leitura linha a linha de uma base de dados quando trabalhamos
com o BufferedReader, naquela parte da matria na qual escrevemos e lemos arquivos-texto.
Fbio Burch Salvador
Gravando no BD (Insert e Update)
Para gravar e dar um update ou um delete no banco de dados, enfim, para fazer qualquer coisa que no
seja um Select, ns fazemos assim: Comeamos por criar uma String com o comando SQL desejado.
String sql = "insert into pessoas values (" + codigo + ", '" + name + "', " + idade + ", '" + salario +"');";
T, nenhuma novidade.
Statement comandoSQL = con.createStatement();

int resultado = comandoSQL.executeUpdate(sql);
comandoSQL.close();
Aqui temos as novidades do momento: Ns criamos o Statement igualzinho ao da consulta, mas depois,
ao invs de darmos um executeQuery, damos um executeUpdate, o que no significa que utilizamos
isso apenas para dar UPDATE, mas tambm INSERT e tudo o mais que eu j expliquei antes. A idia
aqui que ele vai executar, mas no vai retornar um ResultSet, tanto que o retorno disso um INT
esse INT nos diz quantas linhas foram afetadas pela nossa instruo. Ou seja, se retornar 0, podes crer
que quase sinnimo de erro. Ele vai retornar alguma coisa, isso certo. Da temos que tratar o retorno
de alguma forma.
Viram? No tem muito segredo. Colocar o banco de dados em MySQL exige umas pequenas mudanas
e a importao de umas classes diferentes, mas nada alm disso. Vejamos a seguir como se faz:
Java + MySQL
A primeira coisa que devemos fazer um download: vamos baixar o MySQL Connector/J, um
pequeno arquivo JAR com tudo o que precisamos. Ele faz uma converso do protocolo usado pelo
JDBC do Java para o de rede usado pelo MySQL.
Preste muita ateno porque voc poder incorporar Bancos de Dados Oracle, SQLServer, ou qualquer
outro que aparea por a usando o mesmo caminho. Cada empresa que desenvolve um banco de
dados prprio automaticamente cria um JAR com o conector para Java, para que os desenvolvedores
Java possam usar seus produtos. Ento, fique tranqilo!
O endereo para download : http://dev.mysql.com/downloads/connector/j/ - Este endereo poder
mudar no futuro. Caso isso acontea, recorra ao Google mesmo.
Depois de baixar o componente para
alguma pasta qualquer. Eu vou ao meu
projeto e clico nele com o boto direito.
Ento, escolho a opo Build Path e
ento entro em Add External Archive.
Ento, atravs do sistema de pastas do
Windows, ache o arquivo JAR do
Connector. Ele ser adicionado ao
Path do programa. Mais tarde veremos
como se faz para compilar o conector
MySQL junto com o JAR todo.
Veja como fica o projeto com o JAR
adicionado:
Agora, s falta construir a aplicao.
Fbio Burch Salvador
A aplicao Java com MySQL integrado
import java.sql.*; Nesta parte inicial eu estou criando uma
import javax.swing.*; aplicao normal como j conhecemos h
muito tempo, com um boto que ativa o
public class teleca { mtodo conector() antes de fechar o
static Connection con; programa. A nica novidade so os imports
public static void main(String[]args) { novos e a instanciao da classe
final JFrame tela = new JFrame(); Connection. Mas isso j vimos no exemplo
tela.setBounds(10,10,600,400); anterior.
JButton botao = new JButton("Aperte");
botao.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent arg0) {
JOptionPane.showMessageDialog(null, "Opa! Pidi-pra-par-parou!");
conector();
tela.dispose();
}
});
tela.add(botao);
}
A primeira parte o uso do
forName que ns j usamos antes,
static void conector () { para colocar em operao a classe
try { que lida com o MySQL e a JDBC
Class.forName("com.mysql.jdbc.Driver"); veja que eu mudei essa linha em
} relao aplicao com ODBC.
catch(ClassNotFoundException err) {
System.out.println(err.getMessage());
System.exit(1);
}
A seguir, eu vou construir um mtodo que realmente abre a base de dados e faz alguma coisa com ela:
A primeira coisa carregar alguma coisa para a Connection que aqui tem o nome de
con. Eu vou passar como parmetros uma URL formada pelo IP do servidor, barra,
nome da base de dados. E vou passar o username e a senha.
try {
String url = "jdbc:mysql://192.168.86.25/fabio";
con = DriverManager.getConnection(url, "root", "churros");
Statement comandoSQL = con.createStatement();
String sql = "Select nome from personagens;";
ResultSet resultado = comandoSQL.executeQuery(sql);
A, eu criei o Statement, algo que ns j fizemos no exemplo com ODBC. Abaixo, temos
uma rotina bem simples que apenas roda um WHILE que vai rodar todo o ResultSet at o
final e exibir os dados levantados na consulta SQL da primeira ltima linha. Ele vai
exibir esses dados numa JOptionPane, o que deixa tudo mais espalhafatoso, mas para
fins de exemplo est bom.
while(resultado.next()){
JOptionPane.showMessageDialog(null, resultado.getObject(1).toString());
}
}
catch (SQLException err) {
}
}
}
Se eu quisesse gravar informaes, apagar ou dar um UPDATE, eu usaria as rotinas SQL dentro do
Statement como eu usei no exemplo da base de dados no ODBC, pois isso nunca muda.
Na verdade, o que muda o conector importado para o projeto e tambm a classe que usamos no
forName. Ah, e tambm os parmetros necessrios para a conexo (o MySQL exige o IP, j o ODBC
no, etc.). O resto do sistema continua igualzinho.
Nota sobre componentes de conexo baixados da Web

Eu j disse que os componentes de conexo dos bancos de dados com o Java podem ser baixados da
Internet. Pois os manuais e a documentao deles tambm podem. Normalmente, os fabricantes dos
BDs criam os conectores e fazem um pequeno manual. Como o manual quase sempre em ingls, no
tenha vergonha de pesquisar nos Fruns.
Antigamente, pesquisar uma tcnica qualquer na Internet era considerado coisa de amador, que bons
programadores conseguiam se virar sozinhos sem ficar olhando os Fruns. Hoje em dia, isso um
pensamento ultrapassado. As pessoas criam classes e as distribuem pela Web com a inteno simples
de tornar a vida dos outros mais fcil (e fazer fama, claro). Ento, aproveite!
Se o seu SGBD preferido no est listado nesta pequena apostila e se voc no encontrou
documentao oficial sobre ele em parte alguma, no tenha medo de usar o Google e catar uma classe,
mesmo que seja feita por algum outro programador. Voc no ser considerado burro por no saber,
magicamente, o nome de todos os conectores e as classes deles para usar o forName. Voc ser
considerado burro se tentar reinventar a roda. Faa o seu sistema, venda ele, e fature dinheiro. Sem
culpa e sem frescuras. Ningum burro por querer facilitar a vida. Burro quem no completa o projeto
no prazo.
Fbio Burch Salvador
Criando formulrios de impresso com IReport
Existem inmeros editores de relatrios na Internet. Mas ns vamos ter que escolher um deles para
trabalhar. Eu escolhi, para este livro, usar o padro JasperReports, que gratuito. Um JasperReport
um arquivo XML com instrues sobre a montagem de um relatrio utilizando os dados de um banco de
dados qualquer.
D para escrever um JasperReport na unha, usando o Bloco de Notas. Mas mais fcil fazer isso com
o editor apropriado. No caso, estou falando do IReports, um programa de interface visual no qual
podemos desenhar nosso relatrio para impresso puxando os dados no lugar certo, sem grandes
esforos.
Vamos ento criar um relatrio no IReports.
Esta a a interface do IReport. Vamos trabalhar, no comeo, apertando o boto da extrema-esquerda

para criar um NOVO documento.
Surge ento uma caixinha com configuraes de pgina. Aqui se escolhe o tipo de papel e as margens.
Para quem conhece Word e outros derivados, esta tela no tem nenhuma novidade.
Ao iniciar o novo projeto, surge para ns uma tela com uma folha de papel em branco. Esta folha est
separada em partes. Cada parte corresponde a um pedao do documento que vai sair impresso.
TITLE o ttulo do documento, e aparece apenas na primeira pgina. Serve para fazer capas e coisas
assim.
PAGEHEADER o cabealho do documento. Aparecer no topo de todas as pginas.
COLUMSNHEADER So os cabealhos das colunas. Aparecero sempre antes dos dados, mas ns
podemos fazer o IReport repetir estes cabealhos dentro dos grupos (veremos depois o que so grupos
de dados).
DETAIL Aqui vo os dados em si, empilhados, correndo uma tabela do banco de dados qualquer.
COLUMNFOOTER o rodap do espao iniciado com ColumnHeaders.
Fbio Burch Salvador
PAGEFOOTER o rodap da pgina, igual em todas as pginas.
LASTPAGEFOOTER o rodap da ltima pgina, uma espcie de antnimo para o Title.
SUMMARY um espao no final do documento utilizado para colocarmos sumrios ou resumos de
encerramento.
Podemos editar as propriedades de tamanho e setar se visvel ou no uma banda usando o
Gerenciador de Bandas. muito fcil abr-lo. Basta clicar sobre algum ponto vazio da folha com o boto
direito e escolher Properties. Da, veremos uma tela assim:
Aqui, no temos grande coisa. Vemos as bandas em uma lista na esquerda, e ao lado o Band Width. O
Band Width representa a altura de cada banda. Se colocarmos um zero ali, a banda desaparece.
J o campo Split Alowed, quando marcado, permite que uma determinada banda, ao no caber em
uma nica pgina, seja repartida. Se estiver desmarcada, ela fica presa primeira pgina e sai cortada
e a, azar!
Colocando dados no Report
Aps criarmos a pgina, nos falta ligar este relatrio base de dados. Para isso, usamos o menu Fonte
de Dados.
Dentro de Conexes, ns podemos criar conexes com o BD. Trata-se de um exerccio simples de
preencher campos. Se voc optar por escrever o endereo do servidor e o nome da base de dados nos
campos designados para tal, nunca se esquea de clicar em Wizard, para passar estes parmetros para
a string de conexo no segundo campo, de cima para baixo. ele quem vale na hora de conectar.
No confunda: Server Address um endereo IP ou domnio do servidor para encontra-lo em uma rede.
Se o prprio PC onde est sendo gerado o IReport for o portador do BD usado, ento ser preciso
escrever localhost.
No se preocupe com o fato de estarmos usando uma conexo com IP e tudo para ligar nosso IReport
a uma base de dados. Isso s vai ter validade para usarmos nos testes dos relatrios dos nossos
sistemas. Na hora de rodar o programa nos computadores de um cliente, por exemplo, ns podemos
dizer, atravs do programa em Java, qual o IP do Banco de Dados. Ento, crie seu Report com uma
base de dados que te sirva para os testes do programa, e depois quando ele for implementado nos
clientes, os Reports continuaro a funcionar numa boa.
Depois, no prprio menu Fonte de Dados, escolha a opo Consultas do Relatrio. Aqui, voc deve ir
Report SQL Query e escrever uma Query SQL que vai retornar dados, preenchendo o relatrio com
Fbio Burch Salvador
informaes a serem trabalhadas.
De volta tela principal do IReports, chegou a hora de dar uma olhada no menu da parte inferior
esquerda. L, vamos ativar a aba Objects Library, que contm os objetos que formam o nosso relatrio.
Os principais tipos de dados a colocar dentro do relatrio so os FIELDS, os VARIABLES e os
PARAMETERS.
FIELDS So campos tirados da base de dados. Colocar um Field faz o Report imprimir os dados que
aquele campo contm.
VARIABLES So variveis. Podemos cria-las para executar funes de soma ou outras coisas
parecidas.
PARAMETERS So utilizado para importar os valores passados pelo programa feito em Java. Estes
parmetros devem ser passados no momento de se chamar a impresso.
Eu posso criar variveis e parmetros, clicando com o boto direito sobre os menos da esquerda e
escolhendo ADD, e ento, o que eu quero adicionar.
Para fazer os campos, variveis e parmetros aparecerem no Report, eu devo arrasta-los para dentro
da folha branca, na sesso que eu quiser.
No meu exemplo, eu usei como banco de dados a base de dados do meu site, que alis, voc deveria
visitar. Mas isso outra histria. O fato que eu sei meu site, e com minha Query SQL, mandei retornar
os ttulos das colunas de opinio do site e o nome do autor de cada uma. Obviamente, aparecer uma
enorme lista de ttulos com nomes repetidos, pois eu mandei ordenar pelo cdigo do autor.
Ento, o resultado ser esse:
Fbio Burch Salvador
Montando grupos
No parece ser muito promissor. E no . Mas a, vamos ver uma coisa nova. Clique no boto Groups.
Aparecero os nomes dos grupos que ns temos no Report, mas como no temos nenhum ainda, no
aparecer nada disponvel a no ser o boto NEW, que ns vamos pressionar, claro.
Uma vez dentro do quadro de criao de grupos, precisamos definir duas coisas: o nome do nosso
grupo e qual ser a expresso agrupadora dele. O nome algo bem simples, basta escrever qualquer
coisa ali dentro.
Eu vou escrever Grupex.
J a expresso segue uma lgica mais complexa, mas no muito. preciso dizer que tipo de coisa se
est usando como parmetro de agrupamento se um campo do banco de dados, se um Parameter
ou se uma Variable. Para distinguir um do outro, usa-se uma letra (F para Field, campo; V para
Variable; P para Parameter).
Eu, no caso, estou agrupando as colunas dos meus articulistas de opinio dentro de grupos formados
pelas colunas de um mesmo autor. Ento, vou aproveitar o campo NOME, escrevendo a expresso
$F{nome}.
Existem umas caixinhas para eu marcar tambm. Vamos ver o que elas fazem.
Start on a New Column repete os ColumnHeaders dentro do grupo.
Start on a New Page Ele quebra a pgina a cada vez que um novo grupo vai se iniciar.
Reset Page Number A primeira pgina de cada grupo ser numerada como se fosse a primeira do
relatrio, caso usemos numerao de pginas (veremos isso adiante).
Print header on each Page Caso o grupo extenda-se por mais de uma pgina, o GroupHeader ser
repetido em cada uma delas.
O que o GroupHeader?
um cabealho que existe para cada item de um determinado grupo. Seu nome no aparece como
GroupHeader, e sim como <nome_do_grupo>Header. Assim, se eu criei o grupo Grupex, eu terei
um GrupexHeader.
No se preocupe. Ao criar um grupo, o prprio IReport coloca um Header para ele.
No meu exemplo, veja que eu usei o GrupexHeader para colocar o NOME do colunista cujos textos
sero listados, e coloquei um retngulo meio cilndrico (ou sei l o que aquilo ali). Esse desenho se
repetir como cabealho de cada grupo formado pelos textos de um mesmo autor. O resultado fica
assim:
Fbio Burch Salvador
Claro, meu relatrio est uma porcaria, muito feio e sem planejamento grfico algum. Mas voc vai criar
relatrios bonitinho. Isso aqui apenas um exemplo. Mas j deu para ver como se faz, certo?
Bem, e se eu quiser colocar um grupo dentro do outro? Sem problemas! Basta criar mais grupos l no
botozinho Groups. Voc poder depois arrast-los com o mouse para dentro e para fora uns dos
outros, montando sua prpria hierarquia.
Testando o Report
Quando eu crio um Report, como sei que ele est ficando legal? Atravs da F? No! Eu uso botes
exatamente criados para testes. Este comando testa seu relatrio com
os dados do Banco de Dados, dando uma viso
realista do trabalho como ficar no fim.
Este boto roda o relatrio com uma base de dados

vazia, apenas para conferirmos o visual que
ficar. Isso evita que tenhamos que rodar
consultas pesadas ao BD a cada pequeno teste.
Botes do IReport
J que viemos at aqui, vamos ver ento os botes do IReport e para que servem:
O boto com o T insere um campo O primeiro boto desta carreirinha um gerenciador de

de texto esttico algo que Fields, Variables e Parameters. O segunto o j explicado
escrevemos aqui como se fosse Groups. O terceiro gerencia as bandas do relatrio (que ns
uma Label apenas para indicar j abrimos de outro jeito). E o quarto o gerenciador de
que dado vem a seguir ou para bases de dados. Depois deles, vem o Zoom.
mostrar informaes fixas.
Esses botes aqui, todos, abrem caixinhas que

Esses trs botes do O boto com a seta faz o Ireport des-selecionar nos ajudam a criar funes mais complexas
canto tm a mesma uma utra opo eventualmente clicada. A linha, no nosso projeto.
funo que teriam A primeira trata de sub-relatrios, a possibilidade
bem... ela desenha linhas. Depois, temos as de inserirmos um relatrio dentro do outro.
no Word: criar um ferramentas para desenhar retngulo, crculo,
novo arquivo, abrir retngulo com as quinas arredonadadas. A segunda, de grficos (no melhor estilo Excel).
um existente e salvar O boto laranja com um pr-do-sol desenhado A terceira uma das mais completas, e serve
o que estamos para inserirmos cdigos de barra. Ela tem um
serve para importarmos fotos de arquivos externos campo chamado Barcode Expression onde
fazendo. como JPG ou BMP, GIF, essas coisas. botamos o valor a ser convertido em cdigo de
barras. Mais adiante vamos ver como
manipul-lo para obter um emissor de cdigos
de barras.
Uma das coisas mais legais, apesar de no parecerem, so os elementos grficos como o retngulo e o
crculo. Se voc clicar duas vezes sobre um objeto, ele lhe mostrar suas caractersticas. E se voc
manipular estas caractersticas, poder ento fazer grficos. Cada figura tem, por exemplo, Width e
Height, o que nos permite setar sua altura e largura com base em dados da base de dados ou clculos
dentro do Report mesmo!
Trabalhando com variveis
Quando queremos criar uma varivel, usamos o seguinte mtodo: clicamos com o boto direito sobre as
Variables, Fields ou Parameters, e selecionamos ADD VARIABLE. Aparecer uma tela para nos
ajudar a fazer os clculos que queremos.
S para fins de demonstrao, veja que eu estou criando uma varivel que vai calcular quantas colunas
de opinio cada colunista escreveu. Eu defini o tipo dela como Java.lang.Integer, ou seja, um nmero
inteiro. Coloquei o tipo de clculo dela em COUNT, ou seja, contagem (ela vai ficar somando cada
rodada de Detail que rolar, ou seja, vai contar quantos registros ocorreram no Detail).
Eu preciso dizer o que, afinal de contas, esta varivel est calculando. Ento, eu defini isso em Variable
Expression, onde botei o campo titulo tirado da minha base de dados.
Veja que em Reset Type, eu marquei Group. Ou seja, a contagem ser reiniciada a cada grupo. Eu
preciso definir qual grupo, ento marquei o Grupex na ComboBox ao lado.
Por fim, eu preciso inicializar esta varivel com algum valor. Eu coloquei um New Integer, um novo
nmero Integer, que zero.
No final, eu vou colocar minha varivel logo no final da lista de cada colunista (em GrupexFooter), e
vejamos o resultado:

Fbio Burch Salvador
Depois, veremos como usar Parameters. No vem ao caso agora. Eu vou finalizar o processo salvando
o arquivo JRXML para dentro da pasta onde o meu programa Java est sendo desenvolvido. Mais
tarde, este JRXML dever acompanhar o resto do projeto tambm.

Como integrar o JasperReport ao programa Java

Para comear, vamos precisar fazer a importao de uma montanha de pequenos componentes que
esto dentro da pasta de instalao do IReport, sub-pasta Lib. Eles so:
Commons-digester
Commons-collection
Commons-logging
Commons-logging-api
Commons-beanutils
Commons-itext (esse serve para quando formos fazer um PDF a partir de um relatrio que deveria ser
impresso).
Da, construo um programa que vai, primeiro, compilar meu relatrio para dentro de uma varivel, criar
uma conexo para dizer ao Report que eu estou usando aquela conexo, e gerar o relatrio. A primeira
coisa a fazer importar as classes necessrias. A lista enorme:
import java.io.IOException;
import java.net.URL;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;
import java.util.HashMap;
import net.sf.jasperreports.engine.*;
import net.sf.jasperreports.engine.design.JasperDesign;
import net.sf.jasperreports.engine.util.JRLoader;
import net.sf.jasperreports.view.JasperViewer;
import org.apache.commons.digester.*;
import org.apache.*;
import org.apache.commons.collections.*;
import org.apache.commons.logging.*;
public class imprimir {

new imprimir().imprime();
}
A acima, eu criei o mtodo MAIN que apenas instancia a prpria classe qual ele pertence e depois
roda o mtodo IMPRIME. Acontece que o mtodo MAIN Static. Toda varivel ou objeto dentro de um
mtodo Static tambm Static, ento, eu no posso rodar direto a impresso dentro do MAIN porque
diversos objetos utilizados neste processo no suportam ser Static. O jeito criar outro mtodo, no-
Static, e cham-lo a partir do MAIN.
void imprime() {
try {
Class.forName("com.mysql.jdbc.Driver");
}
A acima, temos o bom e velho Class.forName, que vai primeiro verificar a existncia da classe de
componentes que usamos para conextar base de dados MySQL. Se houver um erro, o problema
naquela pea de hardware que fica entre o teclado e o encosto da cadeira. Voc esqueceu de incluir no
Build Path a classe certa.
catch(ClassNotFoundException err) {

Fbio Burch Salvador
System.out.println(err.getMessage());
System.exit(1);
}
try {
String url = "jdbc:mysql://192.168.86.13/javanoite";
con = DriverManager.getConnection(url, "root", "123");
}
catch (SQLException err) {
}
Bla bla bla Acabamos de repetir o cdigo que j usamos para incorporar o programa em Java a uma
base de dados MySQL. Nada de novo. Se voc ficou em dvida sobre o cdigo acima, por favor faa
uma pergunta ao instrutor (se voc no estiver estudando sozinho em casa, claro, mas neste caso
mande sua dvida ao autor da apostila). O cdigo que acabamos de ver deveria ser conhecido, porque
trata s da conexo a banco de dados. O JasperReport no tem como saber, dinamicamente, onde est
o BD do nosso programa e ns no vamos criar um grupo de relatrios para cada cliente em separado.
Ento, vamos deixar o papel de guia sobre a localizao do BD nas mos do programa.
try {
JasperReport jr = JasperManager.loadReport("exemplo.jasper");
JasperPrint jp = JasperManager.fillReport(jr, new HashMap(), con);
JasperExportManager.exportReportToPdfFile(jp, "arquivo.pdf");
Os trs commandos acima tm funes diferenciadas. O primeiro deles serve para instanciar um objeto
JasperReport, puxando o arquivo exemplo.jasper (que eu criei antes, no IReport), e deixando-o pronto
para eu fazer o que quiser dele. O arquivo externo na verdade o meu modelo de relatrio.
O segundo comando preenche o relatrio com dados. Mas quais dados? Bom. Ele tem como
argumentos o JasperReport JR (o nome foi escolha minha, pode ser qualquer coisa), depois tem um
HashMap com argumentos que ns no usaremos agora, e finalmente a conexo que dever ser usada
pelo JasperReport (a boa e velha CON). Se voc tiver feito direitinho o trabalho de criao das rotinas
SQL no IReport, ento tudo dever dar certo, e a varivel JP armazenar um relatrio preenchido.
O terceiro comando lida com exportao do relatrio preenchido. Eu no preciso us-lo pois posso usar
o relatrio pronto (que est no objeto JP) para visualizar e imprimir. S que, digamos, eu resolvi
exportar para um PDF o relatrio. O comando est aqui porque interessante que vocs aprendam
como se faz. Ele exporta o relatrio prontinho que est em JP para um arquivo (no caso, arquivo.pdf).
}
catch (JRException e) {
System.out.println("Deu pau");
e.printStackTrace();
}
}
}
Acima, temos apenas o tratamento do Catch daquele TRY no qual geramos o relatrio. Porque,
digamos que algum gnio pensador tenha deletado o arquivo JASPER, ou algo assim.
Depois de fazer tudo isso, podemos simplesmente visualizar nosso relatrio na tela e dar ao usurio a
possibilidade de imprimi-lo com o Jasper Report Viewer:
JRViewer jrv = new JRViewer(report);
viewer.getContentPane().add(jrv);
viewer.show();
Agora, se eu gerei um PDF e quero abrir o PDF, no tem problema, so usar:

Runtime.getRuntime().exec("rundll32 url.dll,FileProtocolHandler " + "arquivo.pdf");
Note que na linha acima eu usei a classe Runtime. Esta classe uma espcie de genrico
significando o sistema sobre o qual estou rodando seja qual for. Ento, dou um getRuntime() (o
programa descobre onde estamos rodando). E manda executar um programa (bem evidente no mtodo
EXEC).
Depois, eu dou um comando que bem poderia ser comparado com um comando no MS-DOS. Alis, a
mesma coisa. Eu mando ele rodar o componente que abre um arquivo descobrindo qual o programa-
padro para aquele tipo de arquivos. No caso, como eu mandei ele rodar o arquivo ARQUIVO.PDF, o
sistema vai certamente abrir o Adobe Reader e me mostrar o contedo do PDF.

Fbio Burch Salvador
Compilando o projeto depois de pronto

Para compilar seu projeto criando portanto um arquivo JAR executvel, voc deve seguir alguns
passos. O primeiro deles IMPORTAR todas as classes que voc est usando e que no fazem parte
do ncleo do seu projeto para dentro do projeto. Fazemos isso usando o IMPORT, e dando um
BROWSE no arquivo. Abaixo, alguns screenshots deste processo.
Agora, eu vou criar o JAR em si. Primeiro, eu clico com o boto direito sobre o nome do meu projeto e
escolho EXPORT.

Em seguida, eu vou escolher JAR FILE, que o que eu quero fazer mesmo.
Em seguida, eu entro em uma tela na qual devo dar um BROWSE e escolher a pasta e nome de
arquivo para o meu projeto fechado. Vemos isso na figura abaixo.
Depois de clicar NEXT, eu passo por uma tela na qual devo dizer se quero fechar no JAR at mesmo
classes com erros ou Warnings. Warnings so avisos sobre criao de variveis que no sero usadas
e coisas do tipo. Nada que trave o programa.

Fbio Burch Salvador
Agora, cheguei ltima tela. Ela tem escolhas bastante importantes. Eu posso escolher que o Eclipse
gere para mim o MANIFEST, um arquivo que na verdade contm toda a informao que a Mquina
Virtual precisa para saber como rodar este programa (tipo, saber qual classe contm o mtodo MAIN a
ser rodado no comeo, etc.).
Eu escolhi Generate Manifest File, para o Eclipse gerar o arquivo automaticamente. Ento, fui at o
BROWSE da Main Class e escolhi qual a classe que possui o mtodo principal MAIN.
Ao final, cliquei em FINISH (nesta mesma tela, mas mais embaixo), e o Eclipse me gerou o JAR
executvel. Agora s levar at o PC do meu cliente. Se houverem problemas ao rodar o JAR, veja nos
EXTRAS deste livro como solucion-los.
Para que o seu programa funcione no computador do seu cliente, voc vai ter que instalar nele a JRE,
que pode ser baixada da Internet gratuitamente sem nenhum problema.
Agora, se o computador do cliente j tinha uma JRE, ou se est se confundindo na hora de abrir seus
JARs, o procedimento para consertar isso muito simples. Isso normalmente ocorre no Windows. Basta
desassociar os JARs de qualquer programa, que o Windows mesmo achar a maneira certa de abrir o
programa.
Para fazer isso, abra Meu Computador, v ao menu Ferramentas, abra Opes da pasta, v at a aba
Tipos de Arquivo e EXCLUA o formato JAR. Pronto! Seu Windows perdeu as configuraes que o
estavam confundindo e agora obedecer JRE bem bonitinho, abrindo seu JAR e rodando o programa.

Extras
Ao acabar o corpo principal desta apostila, percebi que algumas funes realmente interessantes
ficaram de fora. Por isso, resolvi fazer um apndice com extras interessantes para os desenvolvedores
novos em linguagem Java. Espero que alguma coisa disso seja til aos leitores.
Como chamar um outro programa EXE

Em Java, podemos pedir que o computador execute um outro programa, um EXE, permitindo ento que
nossas aplicaes tenham interao com outras j existentes e at com softwares nativos do sistema
operacional que estamos usando.
Fazer isso muito simples.
try {
Runtime rt = Runtime.getRuntime() ;
Process p = rt.exec("hanoi.EXE") ;
p.destroy() ;
}
catch(Exception e){
}
}
}
Meu cdigo acima consiste simplesmente de um TRY dentro do qual:

a) Eu crio um objeto Runtime, carregando nele a especificao de qual o ambiente no qual meu
programa est rodando.
b) Eu ordeno que, neste ambiente, seja chamada a execuo do programa (e da, eu coloco o nome do
programa, que no meu caso o joguinho Torre de Hani).
H uma maneira mais complexa, e completa, de fazer isso na qual ns usamos o InputStream para
receber, do programa, especificaes de erros que possam eventualmente travar seu funcionamento.
Neste caso, o programa em Java capaz de saber se houve alguym problema com a aplicao que ele
chamou. O cdigo ento fica um pouco maior.
import java.io.*;
try {
Runtime rt = Runtime.getRuntime() ;
Process p = rt.exec("hanoi.EXE") ;
InputStream in = p.getInputStream() ;
OutputStream out = p.getOutputStream ();
InputStream err = p.getErrorStream() ;
p.destroy() ;
}
catch(Exception e){
}
}
}

Fbio Burch Salvador
Usando impressoras matriciais diretamente
Imprimir coisas com o JasperReports realmente uma maravilha. O sujeito chega l, desenha um
relatrio cheio de enfeites grficos, e fica esperando a folha sair parecendo um caderno de menininha
de 12 anos, tudo floreado e coloridinho.
O problema que no mundo real dos negcios, existem as impressoras matriciais e as impressoras
fiscais. E estas impressoras so utilizadas em larga escala para imprimir dados em folhas padronizadas
que j vm prontas o caso dos contracheques, das notas fiscais, das Darfs, dos Docs bancrios, e
de inmeros outros documentos que existem e so utilizados. Imprimir corretamente dados sobre uma
folha que j vem com os campos impressos pode parecer um desafio absurdo. Mas no .
Antes de existirem CrystalReports, IReports e outros softwares de criao de formulrios padronizados,
as pessoas imprimiam as coisas enviando o texto diretamente para a impressora. As impressoras
tinham um tamanho-padro e formato-padro de letras, e o texto saa, corrido, naquele tamanho. As
impressoras matriciais e fiscais tm um tamanho que prprio delas para imprimir letras. Este tamanho
pode ser alterado atravs de comandos de compresso, negrito e outros (dependendo da impressora),
mas de uma forma geral todas imprimem do mesmo tamanho. Os documentos impressos por bancos,
governo e empresas seguem os padres de espaamento de linha destes tamanhos-padro das
impressoras matriciais.
Ento, ns precisamos saber como enviar um documento para a impressora sem usar o IReport. Fazer
isso vai nos dar um pouco de trabalho, mas por isso que eu trouxe hoje uma classe para a gente usar.
Tenho ela aqui no meu cinto de utilidades.
import javax.print.*;
import java.io.ByteArrayInputStream;
import java.io.InputStream;
public class matricial {
private static PrintService impressora = null;
static void imprime(String texto) {
Eu estou criando o mtodo como Static para que possamos cham-lo de uma foma rpida a partir de
qualquer ponto do sistema com o comando matricial.imprime(Texto a imprimir);
try {
DocFlavor df = DocFlavor.SERVICE_FORMATTED.PRINTABLE;
PrintService[ ] ps = PrintServiceLookup.lookupPrintServices(df, null);
for (PrintService p: ps) {
System.out.println("Impressora encontrada: " + p.getName());
if (p.getName().contains("Text") || p.getName().contains("Generic")) {
System.out.println("Impressora Selecionada: " + p.getName());
impressora = p;
break;
}
}
} catch (Exception e) {
System.out.println("J deu pau na hora de catar a impressora");
}
Este primeiro Try simplesmente abre os PrintServices (as impressoras disponveis no Sistema
Operacional) e tenta catar uma impressora. Ele roda um FOR que vai girar enquanto for possvel
carregar um PrintService para dentro da varivel PS. No se preocupe, este comando captura as
impressoras configuradas tanto no Windows como no Linux.
Dentro do FOR, ele faz uma verificao (veja o IF ali dentro). Se o nome da impressora contiver
(mtodo CONTAINS) a palavra Text ou Generic, ele vai carregar a varivel IMPRESSORA com o
nome da impressora. Esta verificao existe porque as impressoras matriciais, hoje em dia, so
normalmente cadastradas com nomes como Generic 9 Pins Text Only, e coisas parecidas. Mas se a
sua impressora matricial tiver outro nome, tipo Epson LX310, ento bom alterar o IF desta

verificao.
Bem. Se ele no encontrar impressora alguma cadastrada no sistema operacional, ento ele vai
simplesmente pular o FOR.
O Catch s ser disparado caso no haja um servio de cadastro das impressoras disponveis. Da, o
erro no seu sistema operacional e s Deus pode te ajudar, porque eu no fao a mnima idia do que
possa estar acontecendo. Algum com certeza apagou arquivos de sistema. O que fazer num caso
desses? No sei. Isso nunca aconteceu comigo ou com algum que eu conhea. Imagino que seja
preciso recuperar o sistema ou reinstal-lo.
if (impressora == null) {
System.out.println("Que merda! Nenhuma impressora matricial encontrada!");
} else {
Aqui, eu verifiquei se a impressora, aquela varivel que s seria carregada caso houvesse uma
impressora matricial instalada, NULL ou no. Se ela for NULL, ento o IF dentro do FOR no
procedimento anterior no encontrou nada que s possa usar.
No entanto, se ele encontrou, ento vamos para o ELSE, onde a impresso realmente acontece.
try {
DocPrintJob dpj = impressora.createPrintJob();
InputStream stream = new ByteArrayInputStream(texto.getBytes());
DocFlavor flavor = DocFlavor.INPUT_STREAM.AUTOSENSE;
Doc doc = new SimpleDoc(stream, flavor, null);
dpj.print(doc, null);
} catch (PrintException e) {
e.printStackTrace();
}
}
}
}
Aqui est o ncleo deste cdigo. Primeiro, eu uso a classe DocPrintJob, que vai armazenar um
documento para a impressora. Este documento permanece vazio at que eu mande ele imprimir alguma
coisa.
Depois, eu crio um InputStream para guardar um Array de bytes, formado pelo texto a ser impresso.
Agora, eu tenho um trabalho de impresso vazio e uma Array de bytes loucos para serem impressos.
S falta juntar tudo. E da que eu configuro o flavor do meu servio de impresso, programando-o
para auto-gerenciar os bytes que forem entrando nele.
Depois, eu instancio a classe Doc, criando um documento de impresso completo. Ele tem como
parmetros os dados que formam o documento, o Flavor (modo de trabalhar os dados) e os atributos
especiais, que eu coloquei como NULL, porque no precisamos usar eles (na verdade, eu jamais vi um
caso em que se usasse para alguma coisa, mas...).
No comando seguinte eu peo para o meu DocPrintJob fazer uma impresso, finalmente, recebendo os
dados j tratados do Stream. Novamente, eu tenho como colocar atributos que eu no vou colocar
no segundo argumento do comando.
Agora, o documento dever sair na impressora matricial numa boa. Se voc montou sua String Texto
com todos os dados com espaamentos corretos, ento seu contracheque dever sair bem impresso.
Espero que o valor tambm d prazer aos olhos no momento da leitura.
As quebras de linha devero ser feitas na prpria String Texto. Ao invs de usarmos o bom e velho
caracter \n, vamos usar outros. E h como enviar comandos de Negrito, Compressed e outras coisas
diretamente para a impressora. O nico problema que os comandos que precisamos passar variam de
impressora para impressora. Vale sempre consultar os manuais delas. A maioria das impressoras
fiscais quebra a linha quando mandamos a expresso \r\n.

Fbio Burch Salvador
Gerando um relatrio com Cdigos de Barra
Eu vou comear criando uma tabela de produtos bem simples no meu banco de dados. Nesta tabela, eu
tenho apenas descries de produtos com seus cdigos de barra respectivos. Assim:
Agora, eu vou criar o Report consultando nesta tabela para procurar dados. Para isso, sigo o
procedimento que j vimos criando um Report perfeitamente normal.
S que l pelas tantas, eu vou inserir um componente Cdigo de Barras ao lado do nome dos produtos
na banda Detail. E vou clicar duas vezes neste componente criado, fazendo ento uma edio de suas
Properties.
Ao atribuir dentro da Barcode Expression o valor de um campo, eu fao com que o Ireport desenhe o
cdigo de barras para aquele nmero. Assim, fica fcil criar boletos, controles de patrimnio e outras
utilidades que necessitem de cdigo de barras.
O resultado final o seguinte:

Como ler um cdigo de barras
Bom, primeiro, voc vai ter que acoplar um leitor de cdigo de barras ao seu PC. Isso no complicado,
pois esses aparelhos funcionam ligados USB do computador.
O fato que quando temos uma JtextField com o cursor dentro dela, e passamos um cdigo de barras
pelo leitor, a reao do programa ser de receber os nmeros lidos no cdigo, e de acionar o
ActionListener do TextField, se houver algum.
O ActionListeneter pode ser adicionado a um JTextField e ser chamado quando o usurio apertar
ENTER, normalmente aps digitar alguma coisa. Isso tambm ocorre quando passamos um cdigo de
barras atravs do leitor.
Ento, basta construir uma tela com um JtextField equipado com ActionListener, que pegar o valor
passado pelo leitor de cdigo de barras e far a comparao com um nmero que ele tenha
armazenado como sende de algum produto.
Veja o cdigo de exemplo, no qual o cdigo 123456 est estampado no Sabo em P de um
supermercado:
import java.sql.*;

final JTextField texto = new JTextField();

texto.addActionListener(new ActionListener() {

if (texto.getText().equals("123456")) {
JOptionPane.showMessageDialog(null, "Sabo em p");
}
});
tela.add(texto);
}
}

Fbio Burch Salvador
Crditos
Cast (in order of appearance)
Friedrich Nietzsche as Himself

Fbio as Himself
Bruno as Himself
Luis as Himself
Srgio as Himself and Angry JOptionPane Face
Diego as Himself
Daniel as Sir Not Apeearing in this Film
Michel as Himself
Mauricio as Himself
Maicon as Himself
Fernando Pozzebon as Himself
Clauber Junio as Himself
Dejair as Himself
Plato as Scrates (quote by Rene Descartes)
Edith Piaf as Herself
Jon Bauman as Sha-na-na's "Bowzer"
The Sha na na Boys as Sha-na-na Singers
Kenneth Branagh as Hamlet, prince of Denmark
PacMan as Himself
John Wayne as Ringo
Lon Chaney as London After Midnight Monster
Java By
Sun Microsystems
Soundtrack
"Blue Moon", by The Marcels
"La Vie en Rose", by Edith Piaf
Directed by
Fbio Burch Salvador
Produced by
Senac So Leopoldo
Printed by
ACCpias
Chief of Project Engeneering

Sergio Costi
Special Cleaning Specialist

Tia Rose
Chief Manager of Development Compilator Programator Memory-Gastator

Daniel Beckel
Sample Codes Inspirator

Angus McGyver
Food and Coke Supplies Manager

Saddam da Feitoria

System.out.println(Fim do livro);
}
}
2008 Fbio Burch Salvador All rights reserved by the Laws of Moldania
(qu? No sabe onde fica a Moldnia, imbecil? Fica entre a Eslovnia e a Sbrnia)

Apostilajava PDF

Enviado por

Dados do documento

Título original

Direitos autorais

Formatos disponíveis

Compartilhar este documento

Compartilhar ou incorporar documento

Opções de compartilhamento

Você considera este documento útil?

Este conteúdo é inapropriado?

Direitos autorais:

Formatos disponíveis

Apostilajava PDF

Enviado por

Direitos autorais:

Formatos disponíveis

AUTOR (ERA S O QUE FALTAVA)...

Fbio Burch Salvador

UM GUIA PARA QUEM NO SABE NADA DA LINGUAGEM JAVA, MAS QUER

Homem de preto, qual a

aprender logo Java e tirar

Homem de preto, o que

Escrevo um cdigo fonte

And we should consider every day lost on

The book is on the table.

Luis, Michel, Bruno,

O que uma API

J2SE, J2EE e J2ME

Java Virtual Machine (JVM)

Java Developer Kit (JDK)

O que uma IDE

Temos ento agora:

Se eu mandar que o objeto P2 execute um mtodo:

Por qu interessante trabalhar com Orientao a Objetos?

Vetor V[100] de PESSOA (vai armazenar at 100 objetos do tipo PESSOA).

Em Java, tudo classe e objeto

Se voc ainda no entendeu nada

Principais tipos de dados

Ou seja, se fizer sol mas eu estiver duro, no vou praia. Se eu

Exemplo: SE ((HOUVER UM NIBUS) || (ARRUMAR CARONA)) {

Ou seja, se eu arrumar um jeito de viajar, seja ele qual for, eu vou

Exemplo: SE ((ELE GAY) XOR (ELE MULHER)) {

Ou seja, para gostar de homem, OU o sujeito gay, OU mulher.

Montando um programa simples

Aplicando Orientao a Objetos

Instanciando uma classe

As duas linhas acima podem ser resumidas em:

H ainda outra instruo que poderia ser resumida:

Ao fazer redues, o cdigo da classe principal ficaria assim:

Na classe Veculo, eu coloquei 3 atributos:

package pai; A classe classepai, que pertence ao pacote pai, tem um

A classe classefilho pertence ao pacote

E se ele quiser importar tudo de uma vez s, usar:

2 - Organizar o programa em pedaos

Tratamento de erros e excees

Escrevendo dados em arquivos textos e lendo eles

BufferedWriter saida = new BufferedWriter(gravador);

saida.write("Ol mundo \n");

E agora faremos um leitor para o arquivo que acabei de escrever:

BufferedReader entrada = new BufferedReader(gravador);

A classe irm de BufferedWriter faz a leitura de um arquivo-texto.

StringTokenizer tok = new StringTokenizer(linha, ";");

System.out.println("Bebida: " + tok.nextToken());

Tocando sons em Java

import sun.audio.*; Primeira coisa, importar as classes que

public static void main(String[] args){

Da, temos o comando

Podemos, depois, usar um comando para fazer o som parar de tocar:

...Quand il me prend dans ses bras

Pronto! Je vois la vie en rose

Agora voc j pode aterrorizar os seus clientes, amigos e at familiares dando a

modorrena de La Vie em Rose, um experimento psicolgico

com trilha sonora tocada pelo Sha Na Na!

juntos Edith Piaf COM os caras do Sha Na Na!

public class Console

public static void printPrompt(String prompt)

public static String readLine()

@param prompt the prompt string to display

public static String readLine(String prompt)