JAVA 6 - Alta Books

Ivan Mecenas
JAVA 6
Fundamentos, Swing, BlueJ e JDBC
R
Rio de Janeiro.2008
Java 6 Fundamentos, Swing, BlueJ e JDBC
Copyright © 2008 da Editora Alta Books Ltda.
Todos os direitos reservados e protegidos pela Lei 5988 de 14/12/73. Nenhuma parte deste livro,
sem autorização prévia por escrito da editora, poderá ser reproduzida ou transmitida sejam quais
forem os meios empregados: eletrônico, mecânico, fotográfico, gravação ou quaisquer outros.
Todo o esforço foi feito para fornecer a mais completa e adequada informação, contudo a editora
e o(s) autor(es) não assumem responsabilidade pelos resultados e usos da informação fornecida.
Recomendamos aos leitores testar a informação, bem como tomar todos os cuidados necessários
(como o backup), antes da efetiva utilização. Este livro não contém CD-ROM, disquete ou qualquer outra mídia.
Erratas e atualizações: Sempre nos esforçamos para entregar a você, leitor, um livro livre de erros
técnicos ou de conteúdo; porém, nem sempre isso é conseguido, seja por motivo de alteração de
software, interpretação ou mesmo quando alguns deslizes constam na versão original de alguns
livros que traduzimos. Sendo assim, criamos em nosso site, www.altabooks.com.br, a seção Erratas,
onde relataremos, com a devida correção, qualquer erro encontrado em nossos livros.
Avisos e Renúncia de Direitos: Este livro é vendido como está, sem garantia de qualquer tipo, seja
expressa ou implícita.
Marcas Registradas: Todos os termos mencionados e reconhecidos como Marca Registrada e/ou
comercial são de responsabilidade de seus proprietários. A Editora informa não estar associada a
nenhum produto e/ou fornecedor apresentado no livro. No decorrer da obra, imagens, nomes de
produtos e fabricantes podem ter sido utilizados, e desde já a Editora informa que o uso é apenas
ilustrativo e/ou educativo, não visando ao lucro, favorecimento ou desmerecimento do produto/
fabricante.
Produção Editorial Editora Alta Books
Coordenação Editorial: Fernanda Silveira
Revisão: Denise Rossato Agostinetti
Diagramação: Marcelo Matos
Capa: Equipe Alta Books
Impresso no Brasil
O código de propriedade intelectual de 1º de Julho de 1992 proíbe expressamente o uso coletivo
sem autorização dos detentores do direito autoral da obra, bem como a cópia ilegal do original.
Esta prática generalizada nos estabelecimentos de ensino, provoca uma brutal baixa nas vendas dos
livros a ponto de impossibilitar os autores de criarem novas obras.
R
Rua Viúva Claudio, 291 – Jacaré
Rio de Janeiro – RJ CEP: 20020-100
Tel: 21 3278-8069/8419 Fax: 21 3277-1253
www.altabooks.com.br
[email protected]
DEDICATÓRIA
Este livro é dedicado ao meu neto Gabriel Mecenas Nina, nascido no dia 21 de maio de
2003. Carinhosamente, chamo-o de “Gabinho”. Nos abraços carinhosos dos seus pequenos
braços, sinto que minha vida não foi em vão.
Gabinho acaba de completar 5 anos. O tema de sua magnífica festa foi o Homem
Aranha.
Uma boa notícia é que o seu irmãozinho, Eduardo Mecenas Nina, está a caminho.
SOBRE O AUTOR
Ivan José de Mecenas Silva é graduado em Ciências Econômicas pela Universidade
Federal de Sergipe, possuindo cursos de extensão em Análise Administrativa e Análise
de Sistemas.
Atualmente é Analista de Sistemas da POLITEC, escreve artigos para revistas
especializadas em informática e eventualmente realiza trabalhos como desenvolvedor
independente.
Sites:
www.ivanmecenas.com
www.ivanmecenas.com.br
www.ivanmecenas.ecn.br
OUTROS LIVROS DO AUTOR
Editora Book Express:
Delphi 5 Objetos e Herança
Delphi 5 Análise de Pontos de Função
InterBase 6 Guia do Desenvolvedor
Delphi 6 & InterBase 6
Editora Alta Books:
Delphi 6 Desenvolvendo Projetos
Firebird & Delphi 6 Guia do Desenvolvedor
Manual do Empregador Doméstico
Eclipse 3.0.1 Programando com Visual Editor
Qualidade em Software Uma Metologia para Homologação de Sistemas
Banco de Dados do Modelo Conceitual à Implementação Física
Eclipse 3.1 Programando com Visual Editor
NetBeans 4.1 Ambiente Integrado de Desenvolvimento
Ruby Investigando a Linguagem
NetBeans 6.1 (em produção)
PREFÁCIO À TERCEIRA EDIÇÃO
Nesta terceira edição, como nas versões anteriores, os exemplos continuam o mais simples
possível, com o objetivo exclusivo de mostrar os preceitos da linguagem.
Todos os capítulos foram revistos, alguns ampliados, e vários exemplos foram introduzidos,
a fim de incluir alguns dos aprimoramentos julgados mais importantes da versão Java SE
6, na qual o texto se baseia.
Várias implementações do Java SE 6 dizem respeito a elementos externos à linguagem
como, por exemplo, redução do tempo de carga das aplicações e maior gestão no download
da Máquina Virtual Java. Tais mudanças, contudo, não têm interferência direta no
aprendizado da linguagem.
Uma modificação visível nesta edição é a utilização do BlueJ como ferramenta básica
de apoio na produção dos códigos-fontes, visto que esse ambiente tem sido utilizado
com reconhecido êxito por centenas de instituições de ensino em todo o mundo.
Adicionalmente, o texto se utiliza do ambiente NetBeans BlueJ Edition, um produto
resultante da interação entre as equipes BlueJ e NetBeans.
O NetBeans BlueJ Edition, uma versão adaptada do NetBeans IDE, que é um produto
de grande sucesso na atualidade, permite que os usuários do BlueJ possam ampliar os
conhecimentos sobre a programação Java e criar aplicações mais complexas, sem perder a
facilidade de poder criar projetos BlueJ.
O leitor poderá utilizar qualquer das ferramentas, sem nenhum obstáculo ou prejuízo, para
lidar com os exemplos descritos no texto.
A idéia central do livro continua sendo ensinar os fundamentos de Java e fazer com que
o leitor decida se vale a pena utilizar a linguagem na construção dos seus projetos de
software.
Ivan Mecenas
Brasília, maio de 2008
PREFÁCIO À SEGUNDA EDIÇÃO
Lançado no início de 2003, este livro me deu algumas alegrias inesperadas ao ser citado
em diversos trabalhos acadêmicos e ter sido indicado como a única sugestão bibliográfica
referente a Java no concurso público para Analista de Sistemas da Prefeitura Municipal de
Paracatu/MG – Edital 01/2004.
Nesta segunda edição, baseada na versão 1.5, tive o cuidado de manter a simplicidade dos
exemplos, mesmo lidando com os aprimoramentos da linguagem, alguns bastante complexos.
Algumas implementações da linguagem ocorridas na versão 1.4.2, não abordadas na
primeira edição, foram também introduzidas nesta, de forma a tornar o material mais
completo. Assim é que, no Capítulo 7, por exemplo, foram tratados os mecanismos de
asserções (Assertions) e de mensagens (Logging). Nessa mesma linha, o Capítulo 12
foi enriquecido com exemplos do novo pacote de entrada e saída de dados, New Input/
Output, que complementa o pacote original java.io.
Com relação à versão 1.5, conhecida externamente como JDK 5.0, procurei apresentar as
implementações que julguei mais importantes no momento:
a)
Enumerações (enums)
b)
Argumentos variáveis (Varargs)
c)
Tipos genéricos (Generics)
d)
Instrução for-each
No tocante às ferramentas adotadas na edição anterior, fiz menção ao Eclipse 3.0.1, um
ambiente de desenvolvimento integrado liderado pela IBM. Com isso, os usuários também
poderão testar os exercícios nessa interface. O ambiente Sun One Studio 4 Community
Edition foi trocado pelo NetBeans 3.6, no qual se baseia, por ser um projeto livre.
Creio que consegui manter a estrutura básica do livro, que tenta ensinar a linguagem Java
de maneira suave e progressiva.
Ivan Mecenas
Brasília, outubro de 2004
PREFÁCIO
Já faz algum tempo desde que escrevi o meu primeiro programa de computador: um
código Fortran, escrito em meia dúzia de cartões perfurados, que obtinha os números
primos existentes num determinado intervalo de valores inteiros.
Desde então tenho convivido com o acelerado processo de evolução da informática e
tomado contato com diversas linguagens de programação. Em 1998, comecei a obter
alguma informação sobre Java. Entretanto, estava envolvido demais com o ambiente
Delphi, lançado em 1995, que passei a adotar como ferramenta de trabalho nos meus
projetos de sistema (sem qualquer arrependimento, é claro).
Recentemente, com o crescimento acelerado da plataforma Java, resolvi investigar um
pouco mais a linguagem, tentando enxergar as possibilidades que ela oferece para produzir
aplicações comerciais desktop.
É consenso que Java tem se revelado eficiente em ambientes distribuídos. Quanto ao
lado cliente, ainda não se pode fazer uma afirmação definitiva. Os avanços incorporados
à plataforma Java, como os compiladores “Just in Time”, em que os bytecodes vão sendo
progressivamente convertidos para o código binário da plataforma hospedeira, podem
mudar consideravelmente esse panorama.
A pergunta fica no ar: seria a linguagem um substituto ideal para o Delphi ou para o Visual
Basic, por exemplo? Evidentemente, a resposta não é fácil. Se temos um aplicativo Delphi
de relativa complexidade, com interface gráfica rebuscada e uso razoável de componentes
de terceiros, é certo que a conversão para Java implicaria um trabalho gigantesco.
Entretanto, a vida está em constante processo de mutação. Ao longo do tempo, muitos de
nós, programadores, tivemos que adotar linguagens que surgiam e converter aplicativos
antigos. Talvez você mesmo já tenha tido oportunidade de migrar aplicações Clipper para
Delphi ou para outro ambiente gráfico.
A idéia do livro é dar ao leitor a oportunidade de conhecer os fundamentos de Java e,
talvez, até fazer comparações com a linguagem de sua preferência.
Sempre tive vocação para códigos estruturados e, nesse ponto, a elegância de Java tem um
inegável fascínio.
Ivan Mecenas
Brasília, dezembro de 2002
IX
SUMÁRIO
PARTE I - FUNDAMENTOS DA LINGUAGEM . ............................................................... 1
CAPÍTULO 1 - Java: Um Pouco de História.............................................................................. 3
CAPÍTULO 2 - Orientação a Objetos........................................................................................ 7
INTRODUÇÃO.................................................................................................................. 7
ABSTRAÇÃO...................................................................................................................... 8
ENCAPSULAMENTO....................................................................................................... 8
HERANÇA.......................................................................................................................... 8
POLIMORFISMO.............................................................................................................. 9
BYTECODES...................................................................................................................... 9
A MÁQUINA VIRTUAL JAVA.......................................................................................... 9
FERRAMENTAS................................................................................................................ 10
EXEMPLOS DO LIVRO................................................................................................... 11
CAPÍTULO 3 - Lidando com Classes......................................................................................... 13
INTRODUÇÃO.................................................................................................................. 13
CLASSES............................................................................................................................. 13
PROGRAMAS EM JAVA................................................................................................... 14
AS REGRAS E CONVENÇÕES EM JAVA...................................................................... 15
REGRAS...................................................................................................................... 16
CONVENÇÕES......................................................................................................... 16
AS PALAVRAS-CHAVES DE JAVA........................................................................ 16
ESCOPO DE UMA CLASSE............................................................................................ 17
OBJETOS............................................................................................................................. 17
SUPERCLASSES E SUBCLASSES.................................................................................. 18
CLASSES ANINHADAS E INTERNAS.......................................................................... 19
ACESSO AOS MEMBROS DE UMA CLASSE.............................................................. 21
CLASSES ABSTRATAS..................................................................................................... 23
CLASSES FINAIS............................................................................................................... 23
PACOTES............................................................................................................................ 24
STATIC IMPORT............................................................................................................... 25
A VARIÁVEL DE AMBIENTE CLASSPATH................................................................ 26
INTERFACES..................................................................................................................... 27
CAPÍTULO 4 - Lidando com Atributos..................................................................................... 29
INTRODUÇÃO.................................................................................................................. 29
TIPOS PRIMITIVOS......................................................................................................... 29
O TIPO boolean........................................................................................................... 30
O TIPO byte................................................................................................................. 30
O TIPO short............................................................................................................... 32
O TIPO int................................................................................................................... 32
O TIPO long................................................................................................................ 33
O TIPO float................................................................................................................ 35
O TIPO double............................................................................................................ 36
O TIPO char................................................................................................................ 38
ARRAYS............................................................................................................................... 41
ARRAYS MULTIDIMENSIONAIS.......................................................................... 47
STRING............................................................................................................................... 48
CLASSES EMPACOTADORAS....................................................................................... 51
X
A CLASSE VECTOR......................................................................................................... 54
ATRIBUTOS FINAIS E ESTÁTICOS.............................................................................. 57
ENUMERAÇÃO................................................................................................................. 57
TIPOS GENÉRICOS.......................................................................................................... 58
OPERADORES................................................................................................................... 61
OPERADORES ARITMÉTICOS............................................................................ 61
OPERADORES RELACIONAIS............................................................................. 61
OPERADORES CONDICIONAIS.......................................................................... 62
OPERADORES DE DESLOCAMENTO............................................................... 63
OPERADORES LÓGICOS...................................................................................... 63
OPERADORES DE ATRIBUIÇÃO......................................................................... 63
CAPÍTULO 5 - Lidando com Métodos...................................................................................... 65
INTRODUÇÃO.................................................................................................................. 65
A ASSINATURA DE UM MÉTODO.............................................................................. 65
LISTA DE PARÂMETROS DE UM MÉTODO.................................................... 66
ARGUMENTOS VARIÁVEIS (Varargs)................................................................... 68
RETORNO DE UM MÉTODO............................................................................... 68
ESCOPO DE UM MÉTODO............................................................................................ 69
MODIFICADORES DE MÉTODOS.............................................................................. 70
MÉTODOS CONSTRUTORES....................................................................................... 70
POLIMORFISMO.............................................................................................................. 75
SOBRECARGA DE MÉTODOS............................................................................. 75
SOBRECARGA DE MÉTODOS CONSTRUTORES........................................... 76
SOBREPOSIÇÃO DE MÉTODOS.......................................................................... 79
SOBREPOSIÇÃO DE MÉTODOS - INTERFACES............................................. 81
RECURSÃO......................................................................................................................... 85
MÉTODOS DESTRUIDORES......................................................................................... 86
BLOCOS ESTÁTICOS....................................................................................................... 86
A CLASSE Class.................................................................................................................. 86
CAPÍTULO 6 - Estruturas de Controle...................................................................................... 91
INTRODUÇÃO.................................................................................................................. 91
A ESTRUTURA if............................................................................................................... 91
A ESTRUTURA if/else........................................................................................................ 92
A ESTRUTURA switch....................................................................................................... 94
A ESTRUTURA while......................................................................................................... 97
A ESTRUTURA do/while................................................................................................... 98
A ESTRUTURA for............................................................................................................. 98
A INSTRUÇÃO continue.................................................................................................... 100
A INSTRUÇÃO for-each..................................................................................................... 103
CAPÍTULO 7 - Lidando com Exceções, Assertions e Logging................................................. 107
INTRODUÇÃO.................................................................................................................. 107
A ESTRUTURA try/catch................................................................................................... 117
DISPARANDO EXCEÇÕES............................................................................................. 110
EXCEÇÕES ENCADEADAS........................................................................................... 112
A CLÁUSULA throws......................................................................................................... 113
O MÉTODO printStackTrace()........................................................................................... 115
ASSERTIONS..................................................................................................................... 116
INVARIANTES INTERNAS..................................................................................... 116
FLUXOS DE CONTROLE INVARIANTES........................................................... 116
CLASSES INVARIANTES........................................................................................ 116
PRECONDIÇÕES...................................................................................................... 116
XI
PÓS-CONDIÇÕES.................................................................................................... 116
CONSIDERAÇÕES SOBRE ASSERÇÕES............................................................ 121
LOGGING........................................................................................................................... 122
LOGGER, HANDLER, FORMATTER e FILTER................................................. 123
LOGGING ESTÁTICO............................................................................................. 124
LOGGING DINÂMICO........................................................................................... 125
CONSIDERAÇÕES SOBRE LOGGING................................................................ 127
CAPÍTULO 8 - Threads: Linhas de Execução............................................................................. 129
INTRODUÇÃO.................................................................................................................. 129
ORIENTAÇÃO A EVENTOS............................................................................................ 129
A CLASSE Thread................................................................................................................ 130
A INTERFACE RUNNABLE............................................................................................ 136
LIDANDO COM SINCRONISMO.................................................................................. 138
FINALIZANDO.................................................................................................................. 144
PARTE II - INTERFACES GRÁFICAS E BANCOS DE DADOS ..................................... 145
CAPÍTULO 9 - AWT – Abstract Windowing Toolkit............................................................... 147
INTRODUÇÃO.................................................................................................................. 147
GRÁFICOS.......................................................................................................................... 147
O AWT EM AÇÃO............................................................................................................. 148
A CLASSE Container ......................................................................................................... 149
A CLASSE Frame................................................................................................................ 150
O EXEMPLO FrameUm............................................................................................. 150
O EXEMPLO FrameDois........................................................................................... 152
O EXEMPLO FrameTres............................................................................................ 153
O EXEMPLO FrameQuatro....................................................................................... 155
O EXEMPLO FrameCinco......................................................................................... 156
O EXEMPLO FrameSeis............................................................................................ 159
COMPREENDENDO EVENTOS.................................................................................... 160
O EXEMPLO EventoUm........................................................................................... 162
O EXEMPLO EventoDois.......................................................................................... 163
O EXEMPLO EventoTrês........................................................................................... 164
O EXEMPLO EventoQuatro...................................................................................... 168
O EXEMPLO EventoCinco........................................................................................ 169
LIDANDO COM IMAGENS............................................................................................ 171
CAPÍTULO 10 - Componentes Swing....................................................................................... 175
INTRODUÇÃO.................................................................................................................. 175
JFRAME............................................................................................................................... 175
GERENCIADORES DE LAYOUT................................................................................... 176
BORDER LAYOUT................................................................................................... 176
FLOW LAYOUT........................................................................................................ 179
GRID LAYOUT.......................................................................................................... 181
BOX LAYOUT............................................................................................................ 182
CARD LAYOUT......................................................................................................... 184
GRIDBAG LAYOUT................................................................................................. 189
NULL LAYOUT......................................................................................................... 193
MENUS................................................................................................................................ 194
CAPÍTULO 11 - JDBC – Java Database Connectivity.............................................................. 203
INTRODUÇÃO.................................................................................................................. 203
SOBRE ODBC.................................................................................................................... 203
SOBRE JDBC...................................................................................................................... 204
XII
CAPÍTULO 12 - Lidando com Arquivos.................................................................................... 207
INTRODUÇÃO.................................................................................................................. 207
A CLASSE File..................................................................................................................... 208
A CLASSE Writer................................................................................................................ 210
A CLASSE Reader............................................................................................................... 212
AS CLASSES OutputStream e InputStream....................................................................... 219
A CLASSE RandomAccessFile............................................................................................ 224
ENTENDENDO A CLASSE Mensagem.................................................................. 225
ENTENDENDO A CLASSE Arquivo...................................................................... 226
ENTENDENDO A CLASSE Registro...................................................................... 227
ENTENDENDO A CLASSE JanProduto................................................................. 230
A CLASSE System............................................................................................................... 239
NOVO INPUT/OUTPUT.................................................................................................. 239
TRANSFERÊNCIA INDIRETA............................................................................... 239
TRANSFERÊNCIA DIRETA................................................................................... 240
BUFFERS.................................................................................................................... 241
IMPLEMENTAÇÕES NA CLASSE FILE....................................................................... 244
CAPÍTULO 13 - Conexão com o Access..................................................................................... 247
INTRODUÇÃO.................................................................................................................. 247
OBJETOS DE CONEXÃO................................................................................................ 247
CRIANDO A FONTE DE DADOS ODBC..................................................................... 248
PROJETANDO A CONEXÃO.......................................................................................... 250
A CLASSE ConexaoAccess.................................................................................................. 250
A CLASSE JanPrincipal....................................................................................................... 257
A CLASSE JanCliente................................................................................................. 258
A CLASSE JanCategoria...................................................................................................... 269
CRIANDO ARQUIVO EXECUTÁVEL........................................................................... 273
CAPÍTULO 14 - Conexão com o Firebird.................................................................................. 275
INTRODUÇÃO.................................................................................................................. 275
ENTENDENDO O DRIVER JayBird................................................................................ 275
A APLICAÇÃO-EXEMPLO.............................................................................................. 276
A CLASSE ConexaoFirebird....................................................................................... 276
A CLASSE JanMenu................................................................................................... 280
A CLASSE JanPaises................................................................................................... 282
A CLASSE JanCargos................................................................................................. 289
A CLASSE JanSobre.................................................................................................... 297
O COMPONENTE JTable................................................................................................. 299
CAPÍTULO 15 - Arquivos JAR e JavaDoc................................................................................. 303
INTRODUÇÃO.................................................................................................................. 303
O ARQUIVO MANIFEST................................................................................................. 303
ARQUIVOS JAR NA JANELA DE COMANDOS.......................................................... 304
ARQUIVOS JAR NA FERRAMENTA BlueJ.................................................................... 306
ARQUIVOS JAR NA FERRAMENTA NetBeans BlueJ Edition...................................... 306
IMPLEMENTAÇÕES DO JAVA SE 6 ............................................................................. 307
A FERRAMENTA javadoc.................................................................................................. 307
APÊNDICE A - Exemplos do Livro............................................................................................ 312
INTRODUÇÃO.................................................................................................................. 312
EXECUTANDO OS EXEMPLOS.................................................................................... 312
APÊNDICE B - BlueJ – Ambiente Interativo Java.................................................................... 313
INTRODUÇÃO.................................................................................................................. 313
XIII
SITE...................................................................................................................................... 313
INSTALAÇÃO..................................................................................................................... 314
ASPECTOS BÁSICOS....................................................................................................... 315
CRIANDO PROJETOS............................................................................................. 315
CRIANDO CLASSES................................................................................................ 317
ABRINDO PROJETOS............................................................................................. 318
EXECUTANDO CLASSES....................................................................................... 319
CRIANDO OBJETOS................................................................................................ 319
DEPURANDO CÓDIGO.......................................................................................... 321
COMPILAÇÃO................................................................................................................... 323
COMPILANDO CLASSES....................................................................................... 323
COMPILANDO PROJETOS.................................................................................... 324
BLOCO DE CÓDIGO (CODE PAD).............................................................................. 324
TEMPLATES...................................................................................................................... 326
REDIMENSIONANDO SÍMBOLOS.............................................................................. 327
CONFIGURAÇÃO............................................................................................................. 328
O TERMINAL WINDOWS.............................................................................................. 329
FINALIZANDO.................................................................................................................. 330
APÊNDICE C - NetBeans IDE 5.5.1BlueJ Edition.................................................................. 331
INTRODUÇÃO.................................................................................................................. 331
SITE...................................................................................................................................... 331
A INTERFACE.................................................................................................................... 333
ABRINDO OS PROJETOS-EXEMPLOS........................................................................ 333
CONFIGURANDO............................................................................................................ 335
APÊNDICE D - O Visual Nimbus.............................................................................................. 339
INTRODUÇÃO.................................................................................................................. 339
O PROJETO MyAppCap14a.............................................................................................. 339
A CLASSE Visual................................................................................................................ 340
A CLASSE JanMenu............................................................................................................ 341
OS VISUAIS......................................................................................................................... 341
O VISUAL Nimbus...................................................................................................... 341
O VISUAL System....................................................................................................... 342
O VISUAL Motif......................................................................................................... 343
O VISUAL Metal......................................................................................................... 343
FIXANDO Nimbus.............................................................................................................. 344
JANELA DE COMANDOS...................................................................................... 344
ARQUIVO SWING DE PROPRIEDADES............................................................ 345
APÊNDICE E - O Banco de Dados Firebird............................................................................. 347
INTRODUÇÃO.................................................................................................................. 347
Referências Bibliográficas............................................................................................................ 349
Introdução
Objetivo
Este livro se propõe a ensinar os fundamentos da linguagem Java, utilizando exemplos deliberada e
didaticamente simples, de forma que o leitor possa assimilar, sem muito esforço, a proposta da linguagem. Adicionalmente, estabelece alicerces para a construção de aplicações comerciais desktop,
mostrando os componentes básicos de interfaces gráficas e a conexão com bancos de dados. Em
momento algum o livro trata de applets ou de Internet. E por falar em applets, a tecnologia que
abriu caminho para o crescimento de Java tem ficado num plano inferior em relação a ferramentas
como o Flash, que permite animação vetorial.
O texto não pretende ser um manual de referência, o que significa que centenas de classes e métodos não serão aqui abordados. Quando o leitor se sentir mais à vontade com os aspectos básicos
da linguagem, poderá obter farta documentação nos sites especializados, principalmente nos da
Sun Microsystems:
http://www.sun.com
http://java.sun.com
Público-Alvo
O livro pode ser compreendido, sem muito esforço, por principiantes ou por pessoas que já lidam
com alguma linguagem de programação. A primeira parte do livro não requer conhecimentos
mais profundos, além das noções elementares de informática. Com relação à segunda parte, será
preciso que o leitor tenha algum conhecimento sobre bancos relacionais e esteja familiarizado
com os conceitos da linguagem SQL, especialmente as cláusulas SELECT, INSERT, UPDATE
e DELETE.
O Que é Necessário
Para ler e entender o conteúdo do livro, não é necessário qualquer tipo de aparato especial. Entretanto, para testar os exercícios, o leitor vai precisar instalar alguns produtos em sua máquina.
Primeiramente, é necessário instalar a Máquina Virtual Java:
( JDK 6)
Java SE Development Kit 6
Para testar os exemplos, deve-se instalar o ambiente BlueJ, abordado no Apêndice B. Também é
possível, e aconselhável, testá-los no ambiente NetBeans BlueJ Edition, ferramenta apresentada
no Apêndice C.
Os exemplos do Capítulo 14 requerem a instalação do Firebird, um gerenciador de bancos de
dados relacionais, apresentado no Apêndice E.
Todos os elementos acima referenciados podem ser obtidos sem qualquer custo, de acordo com as
regras estabelecidas em licença. No corpo do livro são indicados os locais onde podem ser encontrados, além de outras informações.
A Organização do Livro
Há duas seções, ou duas partes, no livro: a Seção I, denominada “Fundamentos da Linguagem”,
explora o conteúdo básico de Java, a fim de que o contexto e a proposta da linguagem se tornem
claros para o leitor. A Seção II, com o título “Interfaces Gráficas e Bancos de Dados”, traça as primeiras linhas para a construção de interfaces gráficas com o usuário e para a conexão com bancos
de dados relacionais.
Os Capítulos 1 a 8 formam a primeira parte do livro.
O Capítulo 1, “Java: Um Pouco de História”, contém um breve relato sobre a história de Java, de
modo que o leitor tenha idéia da sua origem.
O Capítulo 2, “Orientação a Objetos”, aborda os conceitos relacionados à orientação a objetos,
mas sem o enfoque técnico.
Os fundamentos técnicos da orientação a objetos são explorados nos Capítulos 3, 4 e 5, que reúnem informações necessárias à compreensão dos seus elementos essenciais: classes, atributos e
métodos. Os títulos dos capítulos são, portanto, bastante objetivos: Capítulo 3 – “Lidando com
Classes”; Capítulo 4 – “Lidando com Atributos”; Capítulo 5 – “Lidando com Métodos”.
O Capítulo 6 aborda um tema importante em qualquer linguagem: as estruturas de controle. Nele
são estudadas formas de se produzirem fluxos de controle necessários à obtenção de informações
relevantes para o usuário. Qualquer linguagem existe para produzir resultado útil. É o que pretende
ilustrar o capítulo.
No Capítulo 7, “Lidando com Exceções, Assertions e Logging”, o leitor tem a oportunidade de
entender as técnicas de Java envolvidas no tratamento de exceções. Como qualquer elemento produzido por humanos, programas de computador estão sujeitos a incidentes e acidentes, modestamente chamados de “exceções”, que podem provocar, entre outras coisas, resultados inconsistentes.
O capítulo se destina a mostrar como as exceções podem ser previstas e devidamente tratadas.
Além disso, aborda a técnica de Assertions, que permite testar a qualidade do código produzido,
e também o processo de Logging, que pode ser utilizado pelos desenvolvedores na depuração das
aplicações durante a fase de desenvolvimento ou para diagnosticar o funcionamento interno das
aplicações durante a fase de produção.
Encerrando a Seção I, o Capítulo 8 destaca um assunto reconhecidamente complexo: linhas de execução. Como o título – “Threads: Linhas de Execução” – sugere, o capítulo enfoca as questões envolvidas com o tema e os cuidados necessários para se lidar com o problema de multiencadeamento.
A segunda parte do livro se consolida nos Capítulos 9 a 15.
O Capítulo 9, “AWT – Abstract Windowing Toolkit”, inicia a Seção II lançando as primeiras
luzes sobre o conceito de interfaces gráficas com o usuário, exibindo os componentes AWT, que
acompanham o Java desde a primeira versão, destinados a produzir aplicações baseadas em modo
gráfico.
O Capítulo 10, “Componentes Swing”, mostra os filhos do AWT – os componentes Swing – mais
leves e mais precisos, que agora desfilam na passarela das interfaces gráficas produzidas em Java.
Preparando a trilha para os Capítulos 13 e 14, o Capítulo 11, “JDBC – Java Database Connectivity”, explica a tecnologia Java envolvida com conexão de bancos de dados e os tipos de drivers
suportados pela linguagem.
O Capítulo 12, “Lidando com Arquivos”, sintetiza o uso de fluxos de dados e de caracteres e
demonstra como utilizar arquivos binários. São abordados exemplos referentes ao novo sistema de
entrada e saída, encontrado no pacote java.nio, que complementa o pacote original java.io.
O Capítulo 13, “Conexão com o Access”, enfatiza um modesto aplicativo Java, construído para
utilizar a tecnologia ODBC, utilizando conexão com o banco de dados MS Access.
O Capítulo 14, “Conexão com o Firebird”, amplia os conhecimentos do Capítulo 13, mostrando
um aplicativo, também elementar, que possibilita ligação direta com o banco de dados Firebird,
sem a presença de uma fonte de dados ODBC. O aplicativo, a exemplo do que ocorre no Capítulo
13, atende ao modelo de três camadas, isto é, apresenta a aplicação cliente, a aplicação servidora e
o banco de dados perfeitamente delineados.
Para finalizar a Seção II, o Capítulo 15, “Arquivos Jar e javadoc”, aborda a questão dos arquivos
JAR – arquivos baseados na tecnologia zip –, construídos para agrupar arquivos e recursos numa
peça única, facilitando o seu manuseio. Trata, ainda, da ferramenta javadoc, utilizada para produzir
documentação HTML a partir do código Java.
Por fim, há cinco apêndices:
Apêndice A
Trata do arquivo java2se_3ed.zip, que contém os exemplos do livro e os programas de instalação
das ferramentas utilizadas e do banco de dados Firebird.
Apêndice B
Trata do ambiente interativo BlueJ, ferramenta de apoio utilizada no livro.
Apêndice C
Trata do ambiente NetBeans BlueJ Edition, ferramenta opcional de apoio com a qual foram produzidos alguns dos códigos do livro.
Apêndice D
Trata do Look & Feel Nimbus, o visual vetorial desenvolvido para os componentes Swing, introduzido no Java SE 6.
Apêndice E
Trata do Firebird, o banco de dados relacional utilizado nos projetos-exemplos do Capítulo 14.
PARTE I
FUNDAMENTOS DA
LINGUAGEM
CAPÍTULO 1
Java: Um Pouco de História
Sempre que se escreve um livro sobre linguagem de programação, surge a necessidade quase compulsiva de se fazer uma biografia a fim de identificar suas raízes. Este é um livro sobre Java, logo, a
tradição nos diz que devemos conhecer um pouco da personalidade de Java.
Será mais interessante descrever os traços típicos de Java indo ao passado, numa espécie de regressão uterina, até chegarmos ao seu conteúdo genético básico: a linguagem C.
Não é mais novidade para os programadores o fato de C ter sido inventada e implementada inicialmente por Dennis Ritchie num computador da Digital, o DEC PDP 11, governado pelo sistema
operacional Unix.
Essencialmente, C é como o fruto maduro da linguagem BCPL, desenvolvida por Martin Richards, que resultou numa linguagem chamada B (idealizada por Ken Thompson). Temos, então,
a célebre trilogia: BCPL, B e, finalmente, C.
Há um detalhe que, surpreendentemente, diferencia C das outras linguagens: ela foi criada, influenciada e testada por programadores profissionais. Como resultado, a linguagem oferece ao
programador poucas restrições, estruturas de código e um conjunto limitado de palavras-chaves.
Tal característica de C possivelmente explica o fato de que a linguagem costuma brilhar nos bastidores, nunca nos palcos. Muitos sistemas operacionais e linguagens de programação que se projetaram no mundo da informática estão baseados em C. Clipper e Pascal são dois exemplos clássicos.
Java é uma das filhas de C. Criada por James Gosling, da Sun Microsystems, com o nome de
“Oak”, a linguagem deveria incorporar os benefícios da programação orientada a objetos sem, no
entender do criador, a desnecessária complexidade de C.
Em agosto de 1993, Kathy Walrath foi contratada pela FirstPerson, uma pequena empresa criada
pela Sun, que, à época, se concentrava no desenvolvimento de um controle remoto doméstico com
uma pequena tela sensível ao toque. O código por trás do artefato baseava-se na linguagem de
programação criada por James Gosling.
A tarefa de Kathy consistia em escrever a especificação da linguagem. Entretanto, o projeto perdeu fôlego, o que fez a FirstPerson mudar de estratégia. Na realidade, a empresa percebeu que a
lingua
gem Oak, com capacidade de produzir código seguro, facilidade de transporte e independência de
plataforma, era um produto vital para a Internet.
A partir dessa constatação, a empresa criou o navegador chamado WebRunner, que entregava código Oak na Internet na forma de applets, pequenos programas que podiam ser executados em páginas HTML. Mesmo que você seja muito distraído, certamente já deve ter ouvido falar de applets.
Pouco depois, em 1995, a linguagem Oak recebeu o honroso nome de Java, e o navegador WebRunner, o de HotJava.
Com o auxílio de Mary Campione, Kathy produziu, em maio de 1995, a primeira versão de The
Java™ Programmer’s Guide (Guia do Programador Java), que fornecia informações para o início
da programação na plataforma Java. No final daquele ano, o guia recebeu nome mais acessível: The
Java™ Tutorial.
Embora existam diversos termos e siglas associados a Java, podemos fazer uma filtragem e fornecer
as expressões mais importantes atreladas à linguagem:
JSDK ( Java Software Development Kit) ou JDK ( Java Development Kit)
O conjunto de ferramentas de desenvolvimento oferecido pela Sun e outros fabricantes,
que inclui, como estrutura mínima, um compilador e um interpretador.
JVM ( Java Virtual Machine)
O mecanismo responsável pela interpretação do código intermediário Java (os famigerados bytecodes). A Máquina Virtual Java, embora possa parecer estranho, não conhece
a linguagem Java. Ela somente reconhece o formato de arquivo .class que contém os
bytecodes, os quais serão traduzidos para o código binário da plataforma hospedeira.
JRE ( Java Runtime Environment)
O ambiente de execução Java existente nas máquinas dos usuários finais, que apenas executam aplicações Java. O ambiente inclui, portanto, a Máquina Virtual Java e as classes
que formam a plataforma Java.
J2SE ( Java 2 Standard Edition)
A denominação da primeira edição de Java, contendo as principais classes da plataforma Java.
J2ME ( Java 2 Micro Edition)
A extensão da plataforma J2SE para o desenvolvimento de aplicações Java em pequenos dispositivos como telefones celulares, sendo este apenas um dos exemplos de suas
múltiplas aplicações.
J2EE ( Java 2 Enterprise Edition)
A extensão da plataforma J2SE para o desenvolvimento de aplicações distribuídas. Engloba um conjunto de tecnologias que, em conjunto, fornecem APIs e um ambiente para
desenvolvimento e execução de aplicações corporativas.
JDBC ( Java Database Connectivity)
Arquitetura baseada em interfaces e especificações que permite acesso multiplataforma a
bancos de dados. O acesso aos dados baseia-se em drivers JDBC, que são implementados
por conjuntos de classes que dominam a arquitetura e os comandos dos bancos de dados.
Servlets
Extensões do padrão CGI, escritas em puro Java, usadas para a geração de conteúdo
dinâmico para a Web.
JSP ( JavaServer Pages)
Conjunto de APIs que permitem a criação de páginas web dinâmicas, com acesso a dados e interação com o usuário. Atualmente, há uma forte tendência a se utilizar JSP para
a parte visual das aplicações e Servlets para a lógica de validação e controle.
EJB (Enterprise JavaBeans)
Define padrão para componentes de negócio distribuídos. A sigla também é utilizada
para referir-se aos componentes criados segundo o padrão. Os componentes fornecem
serviços básicos como: gerenciamento de transações e persistência.
RMI (Remote Method Invocation)
Solução para a distribuição de aplicações Java, permitindo a comunicação entre objetos
localizados em máquinas virtuais diferentes.
Em passagem pelo Brasil (outubro de 2002), James Gosling revelou não ter idéia do futuro da
linguagem Java. Segundo ele, tudo depende dos desenvolvedores. Acreditava ele, entretanto, que
Java seria utilizada com mais vigor em desktops.
Pesquisas realizadas por instituições consagradas como o Gartner Group mostram que o uso de Java
tem aumentado consideravelmente nas grandes corporações em detrimento de outras linguagens.
No cenário atual (2008), embora a tecnologia Java para desktops continue evoluindo, não existem
aplicações Swing sendo produzidas em massa como supunha Gosling. Em 2007, a Sun anunciou
vários aperfeiçoamentos para os desenvolvedores Java, os quais estão sendo consolidados no projeto conhecido como “Java SE 6 Update N”.
Há várias questões envolvidas no projeto como, por exemplo, o tempo de carga das aplicações, o
tamanho do Java Runtime Environment e o consumo exagerado de memória.
Uma das implementações importantes, tratada no Apêndice D, diz respeito ao Look & Feel Nimbus, desenvolvido para os componentes Swing. Trata-se de um visual inteiramente vetorial, criado
com a Java2D, em que todos os componentes são desenhados sem utilizar bitmaps. Isso significa
que as aplicações se adaptarão com precisão a qualquer resolução de monitor de vídeo.