Prefácio - Livraria Brasil.Net

Prefácio
‘Nunca mais viver em fragmentos, apenas se conectar’
— Edgar Morgan Foster
Bem-vindo ao Java e ao Java — Como programar, Sexta Edição! Na Deitel & Associates escrevemos livros-texto de ciência da computação
e livros profissionais. Foi um prazer escrever este livro. Para começar, colocamos a quinta edição do Java Como programar sob o
microscópio:
• Alinhamos a apresentação com as mais recentes recomendações curriculares da ACM/IEEE e do Computer Science Advanced
Placement Examination.
• Todos os capítulos foram significativamente atualizados e aprimorados.
• Mudamos para um método didático que introduz classes e objetos mais cedo no currículo. Agora, os alunos começam a criar suas
primeiras classes reutilizáveis no Capítulo 3.
• Todas as GUIs e imagens gráficas nos capítulos anteriores foram substituídas cuidadosamente por seções opcionais passo a passo
nos capítulos 3–10, com duas seções especiais de exercícios nos capítulos 11 e 12. Os instrutores têm uma ampla escolha quanto à
quantidade de GUIs e imagens gráficas a cobrir — de zero a uma seqüência introdutória com 10 seções e um tratamento
aprofundado nos capítulos 11, 12 e 22.
• Atualizamos nossa apresentação orientada a objetos a fim de utilizar a versão mais recente da UML (Unified Modeling Language)
— UML™ 2.0 — a linguagem gráfica padrão da indústria para modelar sistemas orientados a objetos.
• Substituímos o estudo de caso opcional do simulador de elevador na edição anterior por um novo estudo de caso do sistema ATM
(Automated Teller Machine) com OOD/UML nos capítulos 1–8 e 10. O novo estudo de caso é muito mais simples e mais atraente
para os primeiros e segundos semestres dos cursos de programação.
• Foram acrescentados vários estudos de caso com múltiplas seções sobre a programação orientada a objetos.
• Incorporamos novos recursos-chave da distribuição mais recente da Sun Microsystems — o Java 2 Platform, Standard Edition
version 5.0 (J2SE 5.0).
• O design do livro foi completamente refeito. O novo design utiliza cores, fontes e vários elementos de design para aprimorar o
processo de aprendizagem dos alunos.
Tudo isso foi cuidadosamente avaliado por uma equipe de 37 distintos revisores acadêmicos e da indústria.
Acreditamos que este livro e o material de suporte têm tudo o que os instrutores e estudantes precisam para uma experiência
educacional em Java informativa, interessante, desafiadora e divertida. Neste Prefácio fornecemos uma visão geral sobre as várias
convenções utilizadas no livro, como sintaxe colorida nos exemplos de código, ‘limpeza do código’ e destaque de código.
Ao ler este livro, se você tiver dúvidas, envie um e-mail (em inglês) para [email protected]; responderemos prontamente. Visite
nosso site da Web, www.deitel.com, regularmente e certifique-se de inscrever-se em www.deitel.com/newsletter/subscribe.html
®
para receber por e-mail (em inglês)o boletim Deitel Buzz Online. Utilizamos o site da Web e o boletim para manter nossos leitores e
clientes empresariais informados das últimas notícias sobre publicações e serviços da Deitel. Visite o site da Web ocasionalmente para
erratas, atualizações de software Java, downloads gratuitos e outros recursos.
Recursos deste livro
Esta nova edição contém muitos recursos novos e aprimorados incluindo:
TM
Atualização para Java 2 Standard Edition Development Kit (JDK), versão 5.0 (J2SE 5.0)
Atualizamos todo o texto para refletir a distribuição J2SE 5.0 mais recente. Novos tópicos incluem:
• obter entrada formatada com a classe Scanner
• exibir saída formatada com o método printf do objeto System.out
• utilizar instruções for aprimoradas para processar elementos e coleções do array
• declarar métodos com listas de argumentos de comprimento variável (‘varargs’)
• utilizar classes enum que declaram conjuntos de constantes
XVI
Prefácio
• importar membros static de uma das classes para utilização em outra
• converter valores de tipo primitivo em objetos do tipo empacotador e vice-versa utilizando o auto-empacotamento e
autodesempacotamento, respectivamente
• utilizar estruturas genéricas para criar modelos gerais de métodos e classes que podem ser declaradas uma vez e utilizadas com
diferentes tipos de dados
• utilizar estruturas de dados genéricas aprimoradas das Collections API
• utilizar Concurrency API para implementar aplicativos com multithread
• utilizar RowSet JDBC para acessar dados em um banco de dados
Além disso, alinhamos cuidadosamente o livro com a Java Language Specification (disponível em java.sun.com/docs/books/jls/
index.html). Os programas que você cria à medida que lê este livro devem funcionar em quaisquer plataformas Java compatíveis com o
J2SE 5.0.
[Nota: A Sun Microsystems recentemente renomeou o J2SE de Java 2 Platform, Standard Edition 1.5.0 para Java 2 Platform,
Standard Edition 5.0. A Sun, porém, decidiu não substituir todas as ocorrências de 1.5.0 por 5.0 na documentação Java on-line
(disponível em java.sun.com/j2se/1.5.0/docs/api/index.html) e no diretório de instalação do software (chamado jdk1.5.0). O
site da Web da Sun aceita URLs que substituem 1.5.0 por 5.0. Por exemplo, você pode utilizar o URL java.sun.com/j2se/5.0/docs/
api/index.html para acessar a documentação on-line.]
Novo design interno
Reelaboramos os estilos internos da nossa série Como Programar, em resposta às solicitações dos leitores. Agora colocamos os
termos-chave e a referência às páginas do índice para cada ocorrência importante estilo negrito azul, para mais fácil consulta.
Enfatizamos os componentes na tela com a fonte Helvetica em negrito (por exemplo, o menu File) e enfatizamos o texto do programa Java
na fonte Lucida (por exemplo, int x = 5).
Cores da sintaxe
A apresentação deste livro é totalmente colorida para mostrar os programas e suas saídas como eles tipicamente aparecem na tela de um
computador. Empregamos cores na sintaxe de todos os códigos Java, como faz a maioria dos ambientes de desenvolvimento integrado e
editores de código Java. Isso aprimora significativamente a legibilidade do código — um objetivo especialmente importante, dado o
fato de que este livro contém aproximadamente 20.000 linhas de código. Nossas convenções para cores de sintaxe incluem:
comentários aparecem em verde
palavras-chave aparecem em azul-escuro
erros e delimitadores de scriptlet JSP aparecem em vermelho
constantes e valores literais aparecem em azul-claro
todos os demais códigos aparecem em preto
Destaque de código
Extenso destaque de código torna fácil aos leitores identificar cada segmento do programa apresentado e ajuda os estudantes a revisar o
material rapidamente na preparação para exames ou para o laboratório.
‘Limpeza do código’
‘Limpeza do código’ é o nosso termo para aplicar comentários, utilizar identificadores significativos, aplicar convenções uniformes de
recuo e utilizar espaçamento vertical para destacar unidades significativas do programa. Esse processo resulta em programas fáceis de ler
e autodocumentados. Fizemos uma extensa ‘limpeza do código’ de todos os programas de código-fonte neste livro e nos exercícios.
Trabalhamos muito para tornar nosso código exemplar.
Abordagem que introduz classes e objetos logo no início
Os estudantes continuam a ter uma introdução aos conceitos básicos e à terminologia da tecnologia de objetos no Capítulo 1. Na edição
anterior, eles começavam a desenvolver suas classes e objetos personalizados no Capítulo 8, mas, nesta edição, começam a fazer isso no
Capítulo 3, completamente reformulado. Os capítulos 4–7 foram cuidadosamente reescritos a partir de uma abordagem de ‘classes e
objetos logo no início’. Para todos os efeitos, esta nova edição é orientada a objetos do começo ao fim. Deslocar a discussão sobre objetos
e classes para os capítulos iniciais faz com que os estudantes ‘pensem sobre objetos’ imediatamente e dominem esses conceitos mais
completamente. O Java não é de modo algum trivial, mas é divertido programar com ele e os estudantes podem ver resultados imediatos,
executar programas gráficos e programas baseados em texto rapidamente utilizando as extensas bibliotecas de classes de componentes
reutilizáveis do Java.
Tratamento da programação orientada a objetos nos capítulos 8–10 cuidadosamente revisado
Realizamos uma atualização de alta precisão na edição anterior. Esta edição está mais clara e mais acessível — especialmente se você
estiver iniciando na programação orientada a objetos (OO — object oriented programming). Reescrevemos completamente os capítulos
sobre a OOP com um estudo de caso integrado em que desenvolvemos uma hierarquia de um aplicativo de folha de pagamentos e
motivamos a utilização de interfaces com uma hierarquia de contas a pagar.
Recursos deste livro
XVII
Estudos de caso
Este livro está repleto de estudos de caso distribuídos por múltiplas seções e capítulos. Freqüentemente, tomamos por base uma classe
introduzida no início deste livro para demonstrar posteriormente novos conceitos da programação. Os estudantes aprendem os novos
conceitos no contexto dos aplicativos que eles já conhecem. Esses estudos de caso incluem o desenvolvimento de:
• classe GradeBook nos capítulos 3, 4, 5 e 7
• aplicativo ATM nas seções opcionais sobre OOD/UML dos capítulos 1–8 e 10
• programa de desenho polimórfico na seção opcional de imagens gráficas e GUIs dos capítulos 3–12
• classe Time em várias seções do Capítulo 8
• aplicativo de folha de pagamentos Employee nos capítulos 9 e 10
Estudo de caso GradeBook integrado
Para reforçar nossa apresentação das classes desde o início, apresentamos um estudo de caso integrado que utiliza classes e objetos nos
capítulos 3–5 e 7. Gradativamente construímos uma classe GradeBook que representa um livro de notas do instrutor, e realizamos vários
cálculos com base em um conjunto de notas de estudantes — encontrando as notas médias, máximas e mínimas e imprimindo um gráfico de
barras. Nosso objetivo é fazer com que eles aprendam os conceitos importantes de objetos e classes por meio de um exemplo prático de uma
classe substancial. Desenvolvemos essa classe a partir do zero, construindo métodos com base em instruções de controle e algoritmos
cuidadosamente desenvolvidos, e adicionando variáveis de instância e arrays conforme necessário para aprimorar a funcionalidade da classe.
Estudo de caso sobre GUIs e imagens gráficas (opcional)
O estudo de caso sobre as GUIs e imagens gráficas (opcional) nos capítulos 3–12 demonstra as técnicas para adicionar elementos visuais a
aplicativos. É projetado para aqueles que querem começar a aprender as poderosas capacidades do Java a fim de criar interfaces gráficas
com o usuário (GUIs — graphical user interfaces ) e imagens gráficas. Cada seção introduz conceitos básicos e fornece exemplos gráficos
visuais e o código-fonte completo. Nas primeiras seções mostramos como criar aplicativos gráficos simples. Nas seções subseqüentes
utilizamos os conceitos da programação orientada a objetos, apresentados no Capítulo 10, para criar um aplicativo que desenha
polimorficamente uma variedade de formas. No Capítulo 11 adicionamos uma interface GUI baseada em evento e no Capítulo 12
incorporamos os recursos gráficos do Java 2D.
Unified Modeling Language (UML) — Utilização da UML 2.0 para
desenvolver um projeto orientado a objetos de um caixa eletrônico
A Unified Modeling Language™ (UML) tornou-se a linguagem de modelagem gráfica preferida para projetar sistemas orientados a
objetos. Todos os diagramas da UML deste livro obedecem à nova especificação da UML 2.0. Utilizamos diagramas de classe UML para
representar visualmente classes e seus relacionamentos de herança e também diagramas de atividade UML para demonstrar o fluxo de
controle em cada uma das várias instruções de controle Java.
Esta Sexta Edição inclui um novo estudo de caso opcional (mas altamente recomendado) sobre um projeto orientado a objetos
utilizando a UML. O estudo de caso foi revisado por uma equipe distinta de profissionais acadêmicos e da indústria especializada em
OOD/UML, incluindo líderes neste campo da Rational (os criadores da UML e agora uma divisão da IBM) e do Object Management
Group (responsável pela manutenção e evolução da UML). No estudo de caso, projetamos e implementamos integralmente o software
para um sistema de caixa eletrônico (ATM — Automatic Teller Machine) simples. As seções ‘Estudo de caso sobre engenharia de
software’ no final dos capítulos 1–8 e 10 apresentam cuidadosamente uma introdução passo a passo ao projeto orientado a objetos
utilizando a UML. Introduzimos um subconjunto simplificado e conciso da UML 2.0 e então guiamos o leitor no seu primeiro projeto
concebido para projetistas e programadores iniciantes em orientação a objetos. O estudo de caso não é um exercício; é uma experiência de
aprendizagem de ponta a ponta que termina com uma revisão detalhada do código Java completo. As seções ‘Estudo de caso de
engenharia de software’ ajudam os alunos a desenvolver um projeto orientado a objetos para complementar os conceitos da
programação orientada a objetos que eles começaram a aprender no Capítulo 1 e a implementar no Capítulo 3. Na primeira seção no
final do Capítulo 1, introduzimos os conceitos básicos e a terminologia do OOD. Nas seções opcionais de ‘Estudo de caso de engenharia
de software’ no final dos capítulos 2–5, levamos em consideração questões mais importantes ao abordar um problema desafiador com as
técnicas do OOD. Analisamos um documento de requisitos típico que especifica um sistema a ser construído, determinamos os objetos
necessários para implementar esse sistema, os atributos que esses objetos precisam ter, os comportamentos que esses objetos precisam
exibir e especificamos como os objetos devem interagir uns com os outros para atender aos requisitos do sistema. No Apêndice J
incluímos uma implementação Java do sistema orientado a objetos que projetamos nos capítulos iniciais. Esse estudo de caso ajudará a
preparar os estudantes para os tipos de projetos substanciais que eles encontrarão na indústria. Empregamos um processo de projeto
orientado a objetos incremental cuidadosamente desenvolvido para produzir um modelo de UML para nosso sistema ATM. A partir
desse projeto, criamos uma rica implementação Java funcional utilizando noções-chave de programação incluindo classes, objetos,
encapsulamento, visibilidade, composição, herança e polimorfismo.
Desenvolvimento de banco de dados e de aplicativos Web com JDBC, Servlets e JSP
O Capítulo 25 demonstra como construir aplicativos baseados em dados com a API do JDBC™. Os capítulos 26 e 27 expandem nosso
tratamento dos tópicos sobre a programação da Internet e da Web, fornecendo aos leitores tudo o que eles precisam para desenvolver seus
próprios aplicativos baseados na Web. Os leitores aprenderão a construir os chamados aplicativos de n-camadas, em que a
funcionalidade fornecida por cada camada pode ser distribuída para computadores separados pela Internet ou executados no mesmo
XVIII
Prefácio
computador. Em particular, construímos um aplicativo de pesquisa baseado na Web de três camadas e um aplicativo de livro de visitas
baseado na Web de três camadas. As informações sobre cada aplicativo são armazenadas na camada de dados do aplicativo — neste livro,
um banco de dados implementado com o MySQL (há uma versão de avaliação no CD que acompanha este livro). O usuário insere
solicitações e recebe respostas na camada do cliente de cada aplicativo que, em geral, é um computador que roda um navegador Web
como o Microsoft Internet Explorer ou Netscape. Naturalmente, os navegadores Web sabem comunicar-se com sites da Web por toda a
Internet. A camada intermediária contém um servidor Web e um ou mais servlets específicos ao aplicativo (programas Java que estendem
o servidor para tratar solicitações de navegadores do cliente) ou JavaServer Pages (uma extensão dos servlets que simplifica o tratamento
de solicitações e a formatação das respostas para os navegadores do cliente). Utilizamos um servidor da Web Tomcat da Apache para
esses exemplos. O Tomcat e a implementação de referência para a tecnologia dos servlets e das JavaServer Pages estão incluídos no CD
que acompanha este livro e disponíveis gratuitamente para download em www.apache.org. O Tomcat comunica-se na Internet com os
navegadores Web do cliente utilizando o Hypertext Transfer Protocol (HTTP) — a fundação da World Wide Web. Discutimos o papel
crucial do servidor Web na programação Web e fornecemos exemplos extensos que demonstram as interações entre um navegador Web e
um servidor da Web.
A abordagem de ensino
Este livro contém uma rica coleção de exemplos, exercícios e projetos aproveitados de muitos campos para fornecer ao estudante a
oportunidade de resolver interessantes problemas do mundo real. O livro concentra-se nos princípios da boa engenharia de software e
destaca principalmente a clareza da programação. Evitamos terminologia obscura e especificações de sintaxe em favor de ensinar por meio
de exemplos. Nossos exemplos de código foram testados em populares plataformas Java. Somos educadores que ensinam tópicos
extremamente importantes em salas de aula de empresas no mundo todo. Harvey M. Deitel tem 20 anos de experiência em ensino superior e
15 anos no ensino em empresas. Paul Deitel tem 12 anos de experiência pedagógica em empresas e é um dos professores corporativos mais
experientes no mundo, desde 1996 ministrou cerca de 100 cursos sobre Java em todos os níveis para órgãos governamentais, militares, da
indústria e universidades clientes da Deitel & Associates.
Aprendendo Java via a abordagem de Live-Code (código ativo)
Este livro está repleto de exemplos de Live-Code — cada novo conceito é apresentado no contexto de um aplicativo Java funcional completo que
é imediatamente seguido por uma ou mais execuções de exemplo mostrando as entradas e as saídas do programa. Esse estilo exemplifica a
maneira como ensinamos e escrevemos sobre programação. Chamamos esse método de ensinar e escrever abordagem Live-Code. Utilizamos as
linguagens de programação para ensinar linguagens de programação. Ler os exemplos no livro é quase como digitar e executá-los em um
computador. Fornecemos todos os códigos-fonte para os exemplos do livro no CD que acompanha e em www.deitel.com — tornando fácil
para que os estudantes executem cada exemplo, à medida que eles estudam.
Acesso à World Wide Web
Todos os exemplos de código-fonte deste livro (e nossas outras publicações) estão disponíveis na Internet ( em inglês ) como downloads
nos seguintes sites da Web:
www.deitel.com
www.prenhall.com/deitel
O registro é rápido e fácil e os downloads são gratuitos. Sugerimos que os estudantes façam o download de todos os exemplos e então
executem cada programa enquanto lêem as discussões correspondentes neste livro. Fazer alterações nos exemplos e imediatamente ver os
efeitos dessas alterações é uma excelente maneira de aprimorar sua experiência de aprendizagem em Java.
Objetivos
Cada capítulo inicia com uma declaração de objetivos. Isso permite que os alunos saibam o que esperar e oferece uma oportunidade, depois
da leitura do capítulo, de determinar se alcançaram esses objetivos. Isso dá confiança ao estudante e é uma fonte de reforço positivo.
Citações
Os objetivos da aprendizagem são seguidos por citações. Algumas são humorísticas, filosóficas ou oferecem idéias interessantes.
Esperamos que você se divirta relacionando as citações com o material do capítulo. Muitas citações merecem uma segunda leitura após o
estudo do capítulo.
Sumário
O sumário dos capítulos ajuda a abordar o material em um estilo ‘de cima para baixo’, assim o leitor pode antecipar o que virá e
estabelecer um processo de aprendizagem adequado e eficiente.
Aproximadamente 20.000 linhas de código em 256 programas de exemplo (com saídas de programa)
O tamanho dos nossos programas de Live-Code varia de algumas poucas linhas de código até exemplos substanciais que contêm centenas de
linhas de código. Cada programa é seguido por uma janela com as saídas produzidas quando o programa é executado, assim os
estudantes podem confirmar se os programas são executados como o esperado. Relacionar saídas às instruções que produzem o programa
é uma excelente maneira de aprender e reforçar os conceitos. Nossos programas demonstram os vários recursos do Java. A sintaxe do
código é colorida, com palavras-chave do Java, comentários e outros textos do programa aparecendo em diferentes cores. Isso facilita a
leitura do código — os estudantes gostarão das cores de sintaxe especialmente ao ler programas maiores.
A abordagem de ensino
XIX
816 ilustrações/figuras
Incluímos uma quantidade enorme de gráficos, tabelas, desenhos a traço, programas e saídas de programa. Modelamos o fluxo de
controle em instruções de controle com diagramas de atividade UML. Os diagramas de classes UML modelam os campos, construtores e
métodos das classes. Utilizamos tipos adicionais de diagramas UML por todo o nosso estudo de caso opcional do sistema ATM em
OOD/UML.
481 dicas de programação
Incluímos dicas de programação para ajudar os estudantes a focalizar aspectos importantes do desenvolvimento de programas.
Destacamos essas dicas na forma de Boas práticas de programação, Erros comuns de programação, Dicas de prevenção de erros, Observações
sobre aparência e comportamento, Dicas de desempenho, Dicas de portabilidade e Observações de engenharia de software. Essas dicas e
práticas representam o melhor que reunimos a partir de seis décadas combinadas de programação e experiência pedagógica. Um de
nossos alunos — uma matemática importante — disse-nos que ele sente que essa abordagem é como o destaque que recebem os axiomas,
teoremas e corolários nos livros de matemática; ela fornece uma base sobre a qual construir um bom software.
Boas práticas de programação
Boas práticas de programação são dicas para escrever programas claros. Essas técnicas ajudam os estudantes a criar programas mais legíveis,
autodocumentados e mais fáceis de manter.
Erros comuns de programação
Alunos que começam a aprender a programação (ou uma linguagem de programação) tendem a cometer certos erros com freqüência. Focalizar esses
erros comuns de programação reduz a probabilidade de os alunos cometerem os mesmos equívocos e ajuda a reduzir as longas filas que se formam
na frente da sala dos instrutores fora do horário de aula!
Dicas de prevenção de erros
Quando pela primeira vez projetamos esse ‘tipo de dica’, achamos que as utilizaríamos estritamente para dizer às pessoas como testar e depurar
programas Java. Na realidade, boa parte das dicas descreve os aspectos do Java que reduzem a probabilidade de ‘bugs’, simplificando assim os
processos de teste e depuração.
Observações sobre aparência e comportamento
Observações sobre a aparência e comportamento destacam as convenções da interface gráfica com o usuário. Essas observações ajudam os
estudantes a projetar suas próprias interfaces gráficas com o usuário em conformidade com as normas da indústria.
Dicas de desempenho
Em nossa experiência, ensinar os alunos a escrever programas claros e compreensíveis é de longe o objetivo mais importante para um primeiro
curso de programação. Mas eles querem escrever programas que executam mais rápido, utilizam menos memória, exigem o menor número de
pressionamentos de tecla, ou ousam mais sobre outros aspectos. Os alunos realmente se preocupam com desempenho. Eles querem saber o que
podem fazer para ‘dar uma turbinada’ em seus programas. Portanto, destacamos as oportunidades de melhorar o desempenho do programa —
tornando a execução dos programas mais rápida ou minimizando a quantidade de memória que eles ocupam.
Dicas de portabilidade
Uma das ‘razões para a fama’ do Java é a portabilidade ‘universal’, assim alguns programadores supõem que um aplicativo escrito em Java será
automático e ‘perfeitamente’ portável para todas as plataformas Java. Infelizmente, esse nem sempre é o caso. Incluímos as dicas de
portabilidade para ajudar os alunos a escrever código portável e fornecemos sugestões sobre como o Java alcança seu alto grau de portabilidade.
Observação de engenharia de software
O paradigma de programação orientada a objetos requer uma completa reavaliação da maneira como construímos software. O Java é uma
linguagem eficaz para realizar uma boa engenharia de software. As observações de engenharia de software destacam questões arquitetônicas e de
projeto que afetam a construção de sistemas de software, especialmente sistemas de larga escala. Muito do que o aluno aprende aqui será útil em
cursos de nível superior e na indústria quando ele começar a trabalhar com sistemas grandes e complexos do mundo real.
Seção de resumo
Nova nesta edição, cada capítulo termina com uma breve seção de ‘resumo’ que recapitula os tópicos apresentados. Cada seção também
ajuda o estudante a passar para o próximo capítulo.
Resumo (1.303 itens de resumo)
Cada capítulo termina com dispositivos pedagógicos adicionais. Apresentamos um resumo do capítulo completo, no estilo de lista
itemizada. Em média, há 45 itens de resumo por capítulo. Isso ajuda os alunos a revisar e reforçar os conceitos-chave.
XX
Prefácio
Terminologia (2.388 termos)
Incluímos uma lista em ordem alfabética dos termos importantes definidos em cada capítulo — mais uma vez, para mais reforço. Em
média, há 82 termos por capítulo. Cada termo também aparece no índice e a ocorrência que define cada termo é destacada no índice com
um número de página em negrito e azul para permitir localizar as definições dos termos rapidamente.
701 exercícios e respostas de revisão (a contagem inclui partes separadas)
Extensos exercícios e respostas de revisão são incluídos para aprendizagem. Isso oferece ao estudante uma chance de adquirir confiança
com o material e preparar-se para os exercícios regulares. Encorajamos os alunos a fazer todos os exercícios de revisão e verificar suas
respostas.
874 exercícios (a contagem inclui partes separadas)
Cada capítulo termina com um conjunto de exercícios incluindo chamadas simples de terminologia e conceitos importantes; escrever
instruções individuais do Java; escrever pequenas partes de métodos e classes do Java; escrever métodos completos, classes, aplicativos e
applets Java; e escrever projetos de termos importantes. O grande número de exercícios relacionados com uma ampla variedade de áreas
permite aos instrutores montar seus cursos de acordo com as necessidades específicas de suas aulas e variar as atividades a cada semestre.
Os instrutores podem utilizar esses exercícios para formar deveres de casa, pequenos questionários e/ou exames importantes. As soluções para a
maioria dos exercícios estão incluídas no manual de solução (em inglês) disponível no Companion Website em www.prenhall.com/deitel_br.
Aproximadamente 6.000 entradas de índice
Incluímos um extenso índice no final do livro. Isso ajuda os alunos a encontrar termos ou conceitos por palavra-chave. O índice é útil
para as pessoas que estão lendo o livro pela primeira vez e é especialmente proveitoso para programadores profissionais que utilizam o
livro como uma referência.
‘Dupla indexação’ dos exemplos de Live-Code Java
Este livro tem 256 exemplos de ‘código ativo’ e 874 exercícios (incluindo partes). Fornecemos dupla indexação de cada um dos exemplos
de código ativo e da maioria dos exercícios mais substanciais. Para cada programa de código-fonte neste livro, indexamos a legenda da
figura alfabeticamente e como um item de subíndice em ‘Exemplos’. Isso torna mais fácil localizar o exemplo utilizando recursos
específicos. Os exercícios mais substanciais também são indexados tanto alfabeticamente como itens de subíndice sob ‘Exercícios’.
Passeio pelo livro
Nesta seção, fazemos um passeio pelas muitas capacidades do Java que exploramos neste livro. A Figura 1 ilustra as dependências entre os
capítulos. Recomendamos o estudo desses tópicos na ordem indicada pelas setas, embora outras ordens sejam possíveis. Este livro é
amplamente utilizado em todos os níveis dos cursos de programação Java. Pesquise na Web ‘syllabus,’ ‘Java’ e ‘Deitel’ para encontrar
conteúdos curriculares ( em inglês ) de disciplinas que utilizaram as edições recentes deste livro.
O Capítulo 1 — Introdução aos computadores, à Internet e à World Wide Web — discute o que são computadores, como
funcionam e como são programados. Este capítulo fornece uma breve história do desenvolvimento das linguagens de programação desde
as linguagens de máquina, passando pelas linguagens assembly e indo até as linguagens de alto nível. A origem da linguagem de
programação Java é discutida. O capítulo inclui uma introdução para um típico ambiente de programação Java e apresenta um exame de
um aplicativo Java típico. Este capítulo também introduz os conceitos básicos e a terminologia da tecnologia de objetos e da UML.
O Capítulo 2 — Introdução aos aplicativos Java — fornece uma rápida introdução aos aplicativos de programação na linguagem
de programação Java. O capítulo introduz para os não-programadores os conceitos e as estruturas básicas de programação. Os
programas neste capítulo ilustram como exibir dados na tela e como obter dados do usuário no teclado. Este capítulo introduz a nova
classe Scanner do J2SE 5.0, que simplifica significativamente a obtenção da entrada de usuário. Também introduz algumas novas
capacidades da saída formatada do J2SE 5.0 com o método System.out.printf. O capítulo termina com tratamentos detalhados da
tomada de decisão e operações aritméticas.
O Capítulo 3 — Introdução a classes e objetos — introduz classes, objetos, métodos, construtores e variáveis de instância
utilizando cinco exemplos práticos. Os primeiros quatro exemplos iniciam nosso estudo de caso sobre o desenvolvimento de uma classe
de um livro de notas que os instrutores podem utilizar para manter um placar dos testes dos alunos. O primeiro exemplo apresenta uma
classe GradeBook com um método que simplesmente exibe uma mensagem de boas-vindas quando é chamado. Mostramos como criar um
objeto dessa classe e chamar o método de modo que ele exiba a mensagem de boas-vindas. O segundo exemplo modifica o primeiro
permitindo que o método receba um nome de curso como um argumento e exiba esse nome como parte da mensagem de boas-vindas. O
terceiro exemplo ilustra o armazenamento do nome do curso em um objeto GradeBook. Para essa versão da classe, também mostramos
como configurar e obter o nome do curso utilizando métodos. O quarto exemplo demonstra como os dados em um objeto GradeBook
podem ser inicializados quando o objeto é criado — a inicialização é realizada pelo construtor da classe. O último exemplo introduz
números de pontos flutuantes no contexto de uma classe de conta bancária que mantém o saldo de um cliente. O capítulo descreve como
declarar uma classe e utilizá-la para criar um objeto e então discute como declarar métodos em uma classe para implementar os
comportamentos da classe, como declarar variáveis de instância em uma classe para implementar os atributos da classe e como chamar os
métodos de um objeto para fazer com que eles realizem suas tarefas. O Capítulo 3 explica as diferenças entre variáveis de instância de uma
classe e variáveis locais de um método, como utilizar um construtor para assegurar que os dados de um objeto sejam inicializados quando
o objeto é criado e as diferenças entre tipos por referência e tipos primitivos.
Passeio pelo livro
XXI
Figura 1 Fluxograma ilustrando as dependências entre os capítulos deste livro.
O Capítulo 4 — Instruções de controle: Parte 1 — focaliza o processo de desenvolvimento de programa. Esse capítulo discute como
escolher uma declaração do problema e desenvolver um programa Java funcional a partir dela, incluindo a realização de passos
intermediários em pseudocódigo. O capítulo introduz alguns tipos primitivos e instruções de controle simples para tomada de decisão
(if e if... else) e repetição (while). Examinamos a repetição controlada por contador e controlada por sentinela utilizando a classe
GradeBook do Capítulo 3 e introduzimos os operadores de atribuição, incremento e decremento do Java. O Capítulo inclui duas versões
aprimoradas da classe GradeBook, cada uma baseada na versão final do Capítulo 3. Cada uma dessas versões inclui um método que
utiliza instruções de controle para calcular a média de um conjunto de notas dos estudantes. Na primeira versão, o método utiliza a
repetição controlada por contador para um usuário inserir 10 notas e então determina a média. Na segunda versão, o método utiliza a
repetição controlada por sentinela para o usuário inserir um número arbitrário de notas e então calcula a média das notas que foram
XXII
Prefácio
inseridas. O capítulo utiliza diagramas simples de atividade UML para mostrar o fluxo de controle em cada uma das instruções de
controle.
O Capítulo 5 — Instruções de controle: Parte 2 — continua as discussões sobre as instruções de controle Java com exemplos da
instrução de repetição for, instrução de repetição do...while, instrução de seleção switch, instrução break e instrução continue.
Criamos uma versão aprimorada da classe GradeBook que utiliza uma instrução switch para contar o número de equivalentes de notas
A, B, C, D e F em um conjunto de notas numéricas inseridas pelo usuário. Essa versão utiliza a repetição controlada por sentinela para
inserir as notas. Ao ler as notas inseridas por um usuário, um método modifica as variáveis de instância que monitoram a soma das
notas inseridas e o número das notas inseridas, bem como a contagem das notas em cada categoria de letra de nota. Outros métodos da
classe utilizam então essas variáveis de instância para realizar o cálculo da média e exibir um relatório de resumo com base nas notas
inseridas. Este capítulo também discute os operadores lógicos.
O Capítulo 6 — Métodos: um exame mais profundo — apresenta uma análise mais detalhada dos objetos e seus métodos.
Discutimos os métodos da biblioteca de classes e examinamos mais detalhadamente como os estudantes podem construir seus próprios
métodos. Apresentamos nosso primeiro exemplo de um método com múltiplos parâmetros. Uma parte do capítulo focaliza o
desenvolvimento de um aplicativo de jogo de azar que utiliza a geração de números aleatórios para simular o lançamento de dados. Esse
aplicativo divide seu trabalho exigido em métodos reutilizáveis menores. As técnicas apresentadas no Capítulo 6 são essenciais à
produção de programas adequadamente organizados, em especial os programas maiores que possivelmente os programadores de sistema
e programadores de aplicativos vão desenvolver. O tópico de sobrecarga de métodos (isto é, permitir que múltiplos métodos tenham o
mesmo nome desde que tenham ‘assinaturas’ diferentes) é incentivado e explicado claramente. Introduzimos a pilha de chamadas de
método para explicar como o Java é capaz de monitorar qual método está atualmente em execução, como variáveis locais de métodos são
mantidas na memória e como um método sabe para onde retornar depois de completar a execução. Tópicos adicionais desse capítulo
incluem métodos static, campos static, classe Math, enumerações e escopo das declarações.
O Capítulo 7 — Arrays — explica como processar listas e tabelas de valores. Os arrays em Java são objetos, mais uma evidência do
compromisso Java com quase 100% de orientação a objetos. Discutimos como estruturar os dados em arrays de itens de dados do mesmo
tipo. O capítulo apresenta inúmeros exemplos de arrays de uma dimensão e arrays bidimensionais. Os exemplos investigam manipulações
comuns de array, como a impressão de gráficos de barras, a passagem de arrays para métodos e uma introdução ao campo da análise dos
dados de pesquisa (com estatísticas simples). O capítulo inclui um estudo de caso que simula o embaralhamento e a distribuição de cartas em
um aplicativo de jogo de cartas. Além disso, o capítulo inclui as duas seções finais do estudo de caso GradeBook, em que utilizamos arrays
para armazenar as notas dos estudantes até o final da execução de um programa. Versões anteriores da classe processavam um conjunto de
notas inserido pelo usuário, mas não mantinham os valores das notas individuais em variáveis de instância da classe. Portanto, os cálculos de
repetição exigem que o usuário insira as mesmas notas novamente. Neste capítulo, utilizamos arrays para permitir que um objeto da classe
GradeBook mantenha um conjunto de notas na memória, eliminando assim a necessidade de inserir repetidamente o mesmo conjunto de
notas. A primeira versão da classe neste capítulo armazena as notas em um array dimensional e pode produzir um relatório contendo as notas
médias e as notas mínimas e máximas e um gráfico de barras que representa a distribuição das notas. A segunda versão da classe neste
capítulo (isto é, a versão final no estudo de caso) utiliza um array bidimensional para armazenar as notas de múltiplos exames de alguns
alunos em um semestre. Essa versão pode calcular a média semestral de cada aluno, bem como as notas mínimas e máximas de todas as notas
recebidas no semestre. A classe também produz um gráfico de barras que exibe a distribuição total das notas para o semestre. Este capítulo
introduz a nova instrução for aprimorada do J2SE 5.0 para percorrer os elementos de um array. Listas de argumentos de comprimento
variável (novo na J2SE 5.0) também são demonstradas.
O Capítulo 8 — Classes e objetos: um exame mais profundo — inicia uma discussão mais detalhada sobre objetos e classes. Este
capítulo representa uma oportunidade maravilhosa de ensinar a abstração de dados da ‘maneira correta’ — por meio de uma linguagem
(Java) expressamente dedicada a implementar novos tipos. Aprofundando os conceitos introduzidos nos capítulos 3–7, este capítulo
focaliza a essência e a terminologia das classes e objetos. No contexto do estudo de caso da classe Time, o Capítulo 8 discute a
implementação de classes Java, acesso a membros de classe, imposição do ocultamento de informações com modificadores de acesso,
separação da interface da implementação, utilização de métodos de acesso e métodos utilitários e inicialização de objetos com
construtores. Discutimos a declaração e utilização de constantes, composição, a referência this, membros da classe static e exemplos
de tipos de dados abstratos populares, como pilhas e filas. Introduzimos a instrução package e discutimos como criar pacotes
reutilizáveis e apresentamos as novas capacidades de import static e enum. Os enums do Java são tipos de classe que podem conter
métodos, construtores e campos.
O Capítulo 9 — Programação orientada a objetos: herança — introduz uma das capacidades mais fundamentais das linguagens de
programação orientadas a objetos — a herança — uma forma de reutilização de software em que novas classes são desenvolvidas rápida e
facilmente absorvendo as capacidades das classes existentes e adicionando novas capacidades apropriadas. No contexto de uma hierarquia
Employee, este capítulo, substancialmente revisado, apresenta uma seqüência de cinco exemplos para demonstrar dados private, dados
protected e reutilização de software via herança. Começamos demonstrando uma classe com variáveis de instância private e métodos
public para manipular esses dados. Em seguida, implementamos uma segunda classe com capacidades extras. Para fazer isso, duplicamos
boa parte do primeiro exemplo de código. O terceiro exemplo inicia nossa discussão sobre a herança e reutilização de software — utilizamos
a classe do primeiro exemplo como uma superclasse e herdamos seus dados e funcionalidades para uma nova subclasse. Esse exemplo introduz
o mecanismo de herança e demonstra que uma subclasse não pode acessar diretamente os membros private da sua superclasse. Isso motiva
nosso quarto exemplo, em que introduzimos dados protected na superclasse e demonstramos que a subclasse pode de fato acessar os dados
protected herdados da superclasse. O último exemplo na seqüência demonstra a engenharia de software adequada definindo os dados da
Passeio pelo livro
XXIII
superclasse como private e utilizando os métodos public da superclasse (que foram herdados pela subclasse) a fim de manipular os dados
private da superclasse na subclasse. O capítulo discute as noções de superclasses e subclasses, superclasses diretas e indiretas, utilização de
construtores em superclasses e subclasses e engenharia de software com herança. Esse capítulo também compara a herança (relacionamento é
um) com a composição (relacionamentos tem um).
O Capítulo 10 — Programação orientada a objetos: polimorfismo — lida com outra capacidade fundamental da programação
orientada a objetos: comportamento polimórfico. O Capítulo 10, completamente revisado, fundamenta os conceitos de herança
apresentados no Capítulo 9 e focaliza os relacionamentos entre classes em uma hierarquia de classe e as capacidades poderosas de
processamento que esses relacionamentos permitem. Um recurso deste capítulo são seus dois estudos de caso sobre polimorfismo — um
sistema de folha de pagamentos utilizando uma classe abstrata Employee e um sistema de contas a pagar utilizando uma interface
Payable. Os dois estudos de caso expandem a hierarquia Employee introduzida no Capítulo 9. O primeiro estudo de caso processa um
array de variáveis que contém referências a objetos Employee. Todos os objetos referenciados pelos elementos do array têm uma
superclasse abstrata comum Employee que contém o conjunto de métodos comum a cada classe na hierarquia. O estudo de caso
demonstra que, quando um método é invocado via uma referência de superclasse, a versão específica à subclasse desse método é invocada.
O estudo de caso também mostra como um programa que processa objetos polimorficamente pode realizar processamento específico de
tipo determinando o tipo do objeto atualmente sendo processado via o operador instanceof. Este capítulo faz uma distinção entre
classes abstratas e classes concretas e introduz interfaces — o substituto do Java para o recurso do C++ chamado herança múltipla —
no contexto do segundo estudo de caso de folha de pagamento.
O Capítulo 11 — Componentes GUI: parte 1 — introduz vários componentes Swing do Java para criar programas com interfaces
gráficas amigáveis ao usuário (GUIs — graphical user interfaces). Esses componentes GUI independentes de plataforma são escritos
inteiramente em Java, dando-lhes uma excelente flexibilidade. Os componentes Swing podem ser personalizados para fins de semelhança
com a plataforma de computador em que o programa executa, ou podem utilizar a aparência e o comportamento Java padrão para fornecer
uma interface com o usuário idêntica em todas as plataformas de computador. Desenvolvimento de GUI é um tópico enorme, então o
dividimos em dois capítulos. Estes capítulos abordam o material em profundidade suficiente para permitir que você crie interfaces ricas com
o usuário. Esse capítulo ilustra princípios de GUIs, a hierarquia javax.swing, rótulos, botões, listas, campos de texto, caixas de
combinação, caixas de seleção, botões de opção, painéis, tratamento de eventos de mouse, tratamento de eventos de teclado e gerenciadores
de layout utilizados para posicionar componentes. Apresentamos o conceito poderoso de classes aninhadas que ajuda a ocultar os detalhes
da implementação. Em seguida, o capítulo demonstra nossos primeiros aplicativos baseados em GUI como parte de uma introdução mais
completa ao tratamento de eventos. Nestes exemplos utilizamos classes aninhadas para definir os handlers de evento de vários componentes
GUI.
O Capítulo 12 — Imagens gráficas e Java 2D — apresenta as capacidades gráficas do Java. Discutimos contextos gráficos e
objetos gráficos; desenhamos strings, caracteres e bytes; controlamos cor e fonte; manipulamos os modos de tela e pintura; e desenhamos
linhas, retângulos, retângulos arredondados, retângulos tridimensionais, arcos ovais e polígonos. Introduzimos a API do Java 2D que
fornece poderosas capacidades gráficas bidimensionais. As figuras 12.29 e 12.30 são exemplos de como é fácil utilizar a API do Java 2D
para criar efeitos gráficos complexos como texturas e gradientes.
O Capítulo 13 — Tratamento de exceção — é um dos capítulos mais importantes neste livro do ponto de vista da construção de
aplicativos ‘de missão crítica’ ou ‘de negócios críticos’. Os programadores precisam estar cientes sobre ‘O acontece quando o
componente que chamamos para fazer um trabalho experimenta dificuldades? Como esse componente sinalizará que ocorreu um
problema?’ Para utilizar um componente Java, você precisa saber não apenas como esse componente se comporta quando as ‘coisas vão
bem’, mas também que exceções esse componente ‘lança’ quando as ‘coisas dão errado’. O capítulo distingue entre Exceptions e Errors
bastante sérios de sistema e faz uma distinção mais detalhada entre Exceptions verificadas (as quais o compilador exige que um
aplicativo capture ou declare) e Exceptions não-verificadas (as quais um aplicativo não é exigido que capture ou declare). O capítulo
discute os elementos do tratamento de exceções, incluindo blocos try, blocos catch, blocos finally e a instrução throw. Este capítulo
também introduz o recurso de exceções encadeadas do Java. O material neste capítulo é crucial para muitos dos exemplos no restante
deste livro.
O Capítulo 14 — Arquivos e fluxos — lida com entrada/saída que é realizada por fluxos de dados dirigidos para e a partir de
arquivos. O capítulo começa com uma introdução à hierarquia de dados, de bits a bytes, campos, registros e arquivos. Em seguida, é
apresentada a visão do Java de arquivos e fluxos, e as diferenças entre arquivos de texto e arquivos binários. Mostramos como os
programas passam dados para dispositivos de armazenamento secundários, como os discos, e como os programas recuperam os dados
armazenados nesses dispositivos. Demonstramos a manipulação de arquivos de acesso seqüencial e aleatório. Discutimos a classe File
que os programas utilizam para obter informações sobre arquivos e diretórios. O capítulo explica como pode ser gerada a saída e entrada
de objetos na sua totalidade utilizando a serialização de objetos. Também introduzimos o diálogo JFileChooser que permite aos
usuários de um programa facilmente selecionar arquivos. Muitas das técnicas de processamento de fluxo demonstradas neste capítulo
também podem ser utilizadas para criar aplicativos que se comunicam entre si pelas redes (Capítulo 24), como a Internet.
[Nota: Os cinco capítulos seguintes formam o núcleo de um interessante curso sobre estruturas de dados específicas do Java.]
O Capítulo 15 — Recursão (novo capítulo) — discute os métodos recursivos — isto é, os métodos que chamam a si mesmos. Discutimos
as noções de casos básicos, passos de recursão e recursão infinita. Apresentamos alguns exemplos populares da recursão, incluindo
fatoriais, a série de Fibonacci, permutações de string, as Torres de Hanói e fractais. Explicamos como a recursão funciona ‘sob o capô’,
incluindo a ordem em que os registros de ativação de métodos são colocados ou excluídos da pilha de execução do programa.
Comparamos e contrastamos métodos recursivos e métodos iterativos e explicamos quando escolher cada um deles. Introduzimos a
XXIV
Prefácio
reversão (backtracking) recursiva. Os exercícios deste capítulo incluem abordagens recursivas para: elevar um inteiro a uma potência de
inteiro, visualizar a recursão, máximo divisor comum, palíndromos, o problema das Oito Rainhas (retorno recursivo), imprimir um
array, valor mínimo em um array, fractal em forma de estrela, percorrer um labirinto (retorno recursivo) e gerar labirintos. Os exemplos
e exercícios recursivos dos capítulos 16 e 17 incluem classificação por intercalação, pesquisa linear, pesquisa binária, quicksort, inserção
em árvore binária, percorrer árvores binárias (na pré-ordem, na ordem e na pós-ordem) e várias manipulações em listas vinculadas.
O Capítulo 16 — Pesquisa e classificação (novo capítulo) — discute duas das classes mais importantes de algoritmos na ciência
da computação. Consideramos uma variedade de algoritmos específicos a cada uma e os comparamos com relação ao seu consumo de
memória e consumo de processador (introduzindo a notação ‘Big O’, que indica o grau de dificuldade que um algoritmo pode ter para
resolver um problema). Pesquisar dados envolve determinar se um valor (chamado chave de pesquisa) está presente nos dados e, se
estiver, encontrar a localização do valor. Nos exemplos e exercícios deste capítulo, discutimos vários algoritmos de pesquisa, incluindo:
pesquisa linear, pesquisa binária, pesquisa linear recursiva e pesquisa binária recursiva; o Capítulo 17 discute a pesquisa na lista linear e
a pesquisa em árvore binária; o Capítulo 19 discute o método binarySearch da classe Collections. A classificação coloca os dados em
ordem crescente ou decrescente com base em uma ou mais chaves de classificação. O Capítulo 16 discute por meio de exemplos e exercícios
a classificação por seleção, a classificação por inserção, a classificação por intercalação recursiva, a classificação por borbulhamento
(bubble sort), a classificação por buckets e o quicksort recursivo; o Capítulo 17 discute a classificação de árvore binária, e o Capítulo 19
discute o método sort da classe Collections e a coleção SortedSet. O Capítulo 16 também discute a noção das invariantes de loop.
O Capítulo 17 — Estruturas de dados — discute as técnicas utilizadas para criar e manipular estruturas de dados dinâmicas como
listas vinculadas, pilhas, filas e árvores. Para cada tipo de estrutura de dados, apresentamos exemplos com saídas de exemplo. Embora seja
importante conhecer como essas classes são implementadas, os programadores em Java descobrirão rapidamente que a maioria das
estruturas de dados de que eles precisam está disponível nas bibliotecas de classes, como a java.util do próprio Java que discutimos no
Capítulo 19. Esse capítulo também introduz a capacidade de empacotamento (boxing) do J2SE 5.0 que simplifica a conversão entre valores
de tipos primitivos e objetos empacotadores de tipo (type-wrapper). Este capítulo oferece uma rica seleção de exercícios, incluindo uma seção
especial sobre a construção do seu próprio compilador que permitirá compilar programas de linguagem de alto nível em código de
linguagem de máquina que serão executados no simulador Simpletron nos exercícios do Capítulo 7.
O Capítulo 18 — Genéricos (novo capítulo) — apresenta um dos novos recursos do J2SE 5.0: genéricos. Os exemplos demonstram
métodos e classes genéricas que permitem aos programadores especificar, com uma única declaração de método, um intervalo inteiro
de métodos relacionados ou, com uma única declaração de classe, um intervalo inteiro de tipos relacionados, respectivamente. O
capítulo discute como esse novo recurso alcança a compatibilidade legada de versões anteriores, como por meio de tipos brutos. Este
capítulo também introduz curingas, um conceito genérico poderoso que permite aos programadores representar um ‘tipo
desconhecido’.
O Capítulo 19 — Coleções — discute as classes java.util do Java Collections Framework que fornecem implementações
predefinidas para boa parte das estruturas de dados discutidas no Capítulo 17. As coleções fornecem aos programadores em Java um
conjunto-padrão de estruturas de dados para armazenar e recuperar dados e um conjunto-padrão de algoritmos (isto é, procedimentos,
ou procedures) que permitem aos programadores manipular os dados (como procurar um item de dados particular e classificar os dados
em ordem ascendente ou decrescente). Os exemplos deste capítulo demonstram coleções, como listas vinculadas, árvores, mapas e
conjuntos, e algoritmos para pesquisar, classificar, localizar o valor máximo, localizar o valor mínimo e assim por diante. Também
demonstramos como os genéricos são utilizados na API de coleções.
O Capítulo 20 — Introdução aos applets Java — introduz os applets Java, programas Java projetados para serem transportados
pela Internet e executados em navegadores Web, como o Microsoft Internet Explorer, Netscape, Opera e Mozilla Firefox. O capítulo
demonstra vários applets de demonstração fornecidos no JDK (Java Development Kit). Então escrevemos applets Java que realizam
tarefas similares aos programas do Capítulo 2 e explicamos as semelhanças e diferenças entre applets e aplicativos. Este capítulo pode ser
abordado no início do livro — depois do Capítulo 3. Os applets são GUIs e gráficos, portanto, para entender mais profundamente o
Capítulo 20, examine-o depois dos capítulos 11 e 12 (estes pré-requisitos não são absolutamente necessários). O capítulo seguinte e o
Capítulo 24 apresentam applets adicionais interessantes.
O Capítulo 21 — Multimídia: applets e aplicativos — apresenta algumas capacidades do Java que possibilitam que programas
‘ganhem vida’ por meio de multimídia. O capítulo discute imagens e manipulação de imagens, áudio, animação e vídeo. Apresentamos
um aplicativo de mapa de imagens com os ícones das dicas de programação mostrados anteriormente no Prefácio e que aparecem por
todo o livro. Quando o usuário move o ponteiro do mouse sobre os ícones, o texto da dica é exibido. Depois de ler este capítulo, você
ficará ansioso para experimentar todas essas técnicas, assim incluímos muitos exercícios para desafiar e entretê-lo.
O Capítulo 22 — Componentes GUI: parte 2 — continua a discussão sobre o Swing iniciada no Capítulo 11. Por meio de seus
programas, tabelas e desenhos a traço, o capítulo ilustra os princípios do projeto de GUIs, controles deslizantes, janelas, menus, menus
pop-up, alteração da aparência e comportamento, interfaces com múltiplos documentos, painéis com guias e a utilização de
gerenciadores avançados de layout.
O Capítulo 23 — Multithreading — introduz as capacidades do Java que permitem aos programadores implementar aplicativos
que podem realizar tarefas concorrentemente. Introduzimos threads e apresentamos um diagrama de transição de estado de thread.
Oferecemos uma visão geral sobre prioridades e agendamento de threads. Então, apresentamos um exemplo simples que cria três threads.
Em seguida, introduzimos o relacionamento entre produtor e consumidor em que uma thread de produtor posiciona os dados em um
local compartilhado e uma thread de consumidor então lê esses dados. Neste contexto, utilizamos uma seqüência de exemplos para
ilustrar os problemas que podem surgir quando múltiplas threads manipulam dados compartilhados. O primeiro exemplo demonstra
Passeio pelo livro
XXV
esses problemas. Introduzimos então os recursos da nova API de concorrência do J2SE 5.0 e os utilizamos para ‘sincronizar’ o acesso aos
dados compartilhados a fim de assegurar uma operação correta. Em seguida, aprimoramos o exemplo para utilizar um buffer circular
compartilhado em que o produtor pode adicionar até três valores antes de o consumidor tentar ler um valor. O último exemplo na
seqüência reimplementa o exemplo de buffer circular utilizando a classe ArrayBlockingQueue do J2SE 5.0 que sincroniza
automaticamente o acesso ao seu conteúdo. Isso é significativo, porque programar aplicativos concorrentes é uma tarefa difícil e
propensa a erros. O último exemplo no capítulo demonstra o relacionamento entre produtor e consumidor utilizando as técnicas de
sincronização anteriores ao J2SE 5.0. Embora apresentemos vários recursos de sincronização de nível mais baixo do J2SE 5.0 neste
capítulo para aqueles que têm interesse, a maioria dos programadores deve utilizar as classes predefinidas como ArrayBlockingQueue
para fornecer acesso sincronizado a dados em aplicativos com multithread.
[Nota: Os quatro capítulos seguintes formam o núcleo de uma introdução interessante à computação distribuída em Java.]
O Capítulo 24 — Redes — focaliza programas Java que se comunicam por uma rede de computadores. Este capítulo apresenta as
capacidades de rede de mais baixo nível do Java. Os exemplos do capítulo ilustram um applet que interage com o navegador em que ele
executa, criação de um mininavegador Web, comunicação entre dois programas Java utilizando soquetes baseados em fluxos e
comunicação entre dois programas Java utilizando pacotes de dados. Um recurso chave deste capítulo é a implementação de um jogo
cliente/servidor Tic-Tac-Toe (jogo da velha) colaborativo em que dois clientes jogam Tic-Tac-Toe entre eles arbitrados por um servidor
multiencadeado — ótimo material! O principal exemplo no capítulo é o estudo de caso DeitelMessenger, que simula muitos dos atuais
e populares aplicativos de troca de mensagens instantâneas, os quais permitem aos usuários de computadores comunicar-se com amigos,
parentes e colaboradores pela Internet. Esse estudo de caso cliente/servidor, de múltiplos threads, com 788 linhas, utiliza a maioria das
técnicas de programação apresentadas até este momento no livro.
O Capítulo 25 — Acesso a bancos de dados com JDBC™ — discute a API do JDBC que permite aos aplicativos acessar dados nos
bancos de dados. Os atuais sistemas de banco de dados mais populares são os bancos de dados relacionais. Os exemplos neste capítulo
utilizam o sistema de gerenciamento de bancos de dados (DBMS — Database Management System) MySQL, incluído no CD que
acompanha este livro. No contexto de um banco de dados que contém informações sobre boa parte das nossas publicações, este capítulo
introduz o JDBC e utiliza-o para se conectar a um banco de dados MySQL para então manipular seu conteúdo. Discutimos a SQL
(Structured Query Language) e como ela pode ser utilizada para extrair informações, inserir informações e atualizar dados em um banco
de dados. Os exemplos permitem obter os dados no banco de dados com consultas SQL e exibem estes dados em um componente da GUI
JTable. Além disso, discutimos os RowSet do J2SE 5.0 que simplificam a conexão a um banco de dados e o acesso aos seus dados. Nos
dois capítulos seguintes, utilizamos as técnicas do JDBC no Capítulo 25 para construir aplicativos Web de três camadas baseados em
dados.
O Capítulo 26 — Servlets — discute os servlets — programas Java que estendem a funcionalidade dos servidores Web. Os servlets
são eficazes para desenvolver soluções baseadas na Web que interagem com bancos de dados em favor dos clientes, geram dinamicamente
conteúdo personalizado a ser exibido pelos navegadores e mantêm informações únicas de sessão para cada cliente. A API do Java Servlet
permite aos desenvolvedores adicionar funcionalidade aos servidores Web para tratar solicitações do cliente. Os servlets também são
reutilizáveis em diferentes servidores Web e plataformas. Este capítulo demonstra o mecanismo de solicitação/resposta da Web
(principalmente com solicitações get e post em HTTP), que redireciona solicitações a outros recursos e interage com os bancos de dados
por meio do JDBC. O capítulo apresenta um aplicativo cliente/servidor triestratificado que monitora as respostas dos usuários a uma
pesquisa. Para leitores não familiarizados com o desenvolvimento de páginas da Web, o CD inclui os PDFs de três capítulos (em inglês)
do nosso livro Internet & World Wide Web How to Program, Third Edition — Introduction to XHTML: Part 1, Introduction to XHTML:
Part 2 and Cascading Style Sheets (CSS). Estes capítulos são também úteis no Capítulo 27.
O Capítulo 27 — JavaServer Pages (JSP) — introduz uma extensão da tecnologia de servlet chamada JavaServer Pages (JSP). As
JSPs permitem entrega de conteúdo Web dinamicamente gerado e são freqüentemente utilizadas por projetistas da Web e outros que não
conhecem a programação Java. As JSPs podem conter código Java na forma de scriptlets. Cada JSP é compilada em um servlet Java —
isso normalmente ocorre na primeira vez que uma JSP é solicitada por um cliente. Solicitações subseqüentes do cliente são cumpridas
pelo servlet compilado. Este capítulo apresenta um aplicativo do tipo livro de visitas de cliente/servidor triestratificado que armazena
informações sobre visitantes em um banco de dados.
O Capítulo 28 — Saída formatada (novo capítulo) — apresenta as poderosas capacidades de formatação do printf, que é novo
no J2SE 5.0. Discutimos as capacidades do printf, como arredondar valores de pontos flutuantes para um dado número de casas
decimais, alinhar colunas de números, justificar à direita e à esquerda, inserir informações literais, forçar um sinal de adição, imprimir
zeros à esquerda, utilizar notação exponencial, utilizar números octais e hexadecimais, controlar largura e precisão de campos e exibir
datas e horas em vários formatos. Também demonstramos a formatação de saída com a classe Formatter.
O Capítulo 29 — Strings, caracteres e expressões regulares — lida com o processamento de palavras, frases, caracteres e grupos
de caracteres. Apresentamos as classes String, StringBuffer, Character e StringTokenizer. Este capítulo explora a API do Java
para expressões regulares, que permite aos programas pesquisar em strings, seqüências de caracteres que correspondem a padrões
especificados.
O Apêndice A — Tabela de precedência de operadores — lista cada um dos operadores Java e indica sua precedência relativa e
associatividade.
O Apêndice B — Conjunto de caracteres ASCII — lista os caracteres do conjunto de caracteres ASCII (American Standard Code
for Information Interchange) e indica o valor de código de caractere para cada um. O Java utiliza o conjunto de caracteres Unicode com
XXVI
Prefácio
caracteres de 16 bits para representar todos os caracteres nos idiomas mais ‘comercialmente significativos’ do mundo. Unicode inclui
ASCII como um subconjunto.
O Apêndice C — Palavras-chave e palavras reservadas — lista todas as palavras-chave e palavras reservadas definidas na Java
Programming Language Specification.
O Apêndice D — Tipos primitivos — lista todos os tipos primitivos definidos na Java Programming Language Specification.
O Apêndice E (no CD) — Sistemas de numeração — discute os sistemas de número binário (base 2), decimal (base 10), octal (base
8) e hexadecimal (base 16).
O Apêndice F (no CD) — Unicode® — discute o conjunto de caracteres Unicode, que permite ao Java exibir informações em vários
idiomas. Este apêndice fornece um programa Java de exemplo que exibe uma mensagem ‘Welcome to Unicode’ em vários idiomas —
inglês, chinês, cirílico, francês, alemão, japonês, português e espanhol.
O Apêndice G — Utilizando a documentação da API do Java — introduz a documentação da API do Java, que fornece informações
fáceis de usar sobre os pacotes predefinidos do Java. Este apêndice é importante para iniciantes em Java. Você deve pesquisar a documentação
da API do Java regularmente a fim de aprender mais sobre as classes da API do Java utilizadas neste livro e as classes predefinidas adicionais — o
Java fornece milhares delas que realizam todos os tipos de tarefas úteis. A reutilização dessas classes permite que você desenvolva aplicativos mais
rapidamente. O apêndice discute as informações que você pode encontrar, como essas informações são organizadas e como navegar pela
documentação on-line da API do Java, incluindo visualizar um pacote, uma classe e um método. Esse apêndice também demonstra como
localizar um pacote, classe ou método particular a partir da página de índice.
O Apêndice H (no CD) — Criando documentação com o javadoc — introduz a ferramenta javadoc de geração de documentação. A
Sun Microsystems utiliza a ferramenta javadoc para produzir a documentação da API do Java apresentada no Apêndice G. O exemplo
guia o leitor pelo processo da documentação javadoc. Primeiro, introduzimos o estilo de comentário e tags que o javadoc reconhece e
utiliza para criar documentação. Em seguida, discutimos os comandos e opções utilizados para executar o utilitário. Por fim,
examinamos o arquivo-fonte que o javadoc utiliza e os arquivos HTML que o javadoc cria.
O Apêndice I (no CD) — Manipulação de bit — discute os operadores de manipulação de bits e a classe Bitset do Java. Também inclui
uma extensa discussão sobre os operadores de manipulação de bits, como E sobre bits, OU inclusivo sobre bits, OU exclusivo sobre bits,
deslocamento para a esquerda, deslocamento para a direita com sinal, deslocamento para a direita sem sinal e complemento. O apêndice discute
ainda a classe BitSet, que permite a criação de objetos do tipo array de bits para configurar e obter valores de bits individuais.
O Apêndice J (no CD) — Código para o estudo de caso do ATM — contém a implementação do nosso estudo de caso sobre o
projeto orientado a objetos com a UML. Esse apêndice é discutido na visão geral do estudo de caso (apresentado a seguir).
O Apêndice K (no CD) — Instruções break e continue rotuladas — introduz versões especializadas das instruções break e
continue apresentadas no Capítulo 5. Estas versões são utilizadas com instruções de repetição aninhadas.
O Apêndice L (no CD) — UML 2: Tipos de diagramas adicionais — apresenta os tipos de diagramas da UML 2 que não são
encontrados no estudo de caso em OOD/UML.
O Apêndice M (no CD) — Padrões de projeto. No livro Design Patterns, Elements of Reusable Object-Oriented Software, a ‘Gang of
Four’ (E. Gamma, R. Helm, eu e J. Vlissides) descreveu 23 padrões de projeto que fornecem arquiteturas testadas para construir sistemas
de softwares orientados a objetos. Discutimos brevemente 18 desses padrões — os padrões criacionais resolvem questões relacionadas à
criação de objetos; os padrões estruturais organizam classes e objetos em um sistema; e os padrões comportamentais oferecem estratégias
para modelar como os objetos colaboram reciprocamente. Também discutimos os padrões de concorrência, que são úteis em sistemas de
múltiplos threads, e os padrões arquitetônicos, que ajudam os projetistas a atribuir funcionalidades a subsistemas. Mencionamos como
os pacotes da API do Java tiram proveito dos padrões de projeto e explicamos como certos programas neste livro utilizam padrões de
projeto. Os padrões de projeto são utilizados principalmente pela comunidade do J2EE (Java 2 Platform, Enterprise Edition), em que os
sistemas tendem a ser grandes e complexos.
O Apêndice N (no CD) — Utilizando o depurador — Demonstra os recursos-chave do depurador predefinido da versão 5.0 do
J2SE Development Kit (JDK), que permite a um programador monitorar a execução de aplicativos para localizar e remover erros de
lógica. Esse apêndice apresenta instruções passo a passo para os estudantes aprenderem a utilizar o depurador de uma maneira prática.
Um passeio pelo estudo de caso opcional sobre projeto orientado a objetos com UML
Nesta seção faremos um passeio pelo estudo de caso opcional deste livro do projeto orientado a objetos com UML. Esse passeio mostra o
conteúdo das nove seções ‘Estudos de casos sobre a engenharia de software’ (nos capítulos 1–8 e 10). Depois de completar esse estudo de
caso, o leitor ficará completamente familiarizado com um projeto e implementação orientada a objetos para um aplicativo Java
significativo.
O projeto apresentado no estudo de caso ATM foi desenvolvido na Deitel & Associates, Inc. e escrutinado por profissionais da
indústria. Elaboramos esse projeto para atender aos requisitos de seqüências de cursos introdutórios. Certamente, os sistemas ATM reais
utilizados pelos bancos no mundo todo estão baseados em projetos mais sofisticados que levam em consideração várias outras questões além
daquelas que abordamos aqui. Entretanto, nosso principal objetivo por todo o processo foi criar um projeto simples que fosse claro para os
iniciantes em OOD e UML e, ao mesmo tempo, demonstrar conceitos-chave do OOD e técnicas de modelagem relacionadas à UML.
A Seção 1.16 — Estudo de caso de engenharia de software: Introdução à tecnologia de objetos e UML (obrigatório) —
introduz o estudo de caso do projeto orientado a objetos com a UML. A seção apresenta os conceitos básicos e a terminologia da
tecnologia de objetos, incluindo classes, objetos, encapsulamento, herança e polimorfismo. Discutimos a história da UML. Essa é a
única seção obrigatória do estudo de caso.
Um passeio pelo estudo de caso opcional sobre projeto orientado a objetos com UML
XXVII
A Seção 2.9 — (Opcional) Estudo de caso de engenharia de software: Examinando o documento de requisitos — discute um
documento de requisitos que especifica os requisitos para um sistema que projetaremos e implementaremos — o software para um caixa
eletrônico simples (ATM — Automated Teller Machine). Investigamos de maneira geral a estrutura e o comportamento dos sistemas
orientados a objetos. Discutimos como a UML facilitará o processo de projeto nas seções ‘Estudo de caso de engenharia de software’
subseqüentes fornecendo vários tipos de diagramas adicionais para modelar nosso sistema. Incluímos uma lista de URLs e referências
bibliográficas sobre projetos orientados a objetos com a UML. Discutimos a interação entre o sistema ATM especificado pelo
documento de requisitos e seu usuário. Especificamente, investigamos os cenários que podem ocorrer entre o usuário e o próprio sistema
— estes são chamados casos de uso. Modelamos essas interações, utilizando diagramas de caso uso da UML.
A Seção 3.10 — (Opcional) Estudo de caso de engenharia de software: Identificando as classes em um documento de
requisitos — começa a projetar o sistema ATM. Identificamos suas classes, ou ‘blocos de construção’, extraindo os substantivos simples
e compostos do documento de requisitos. Organizamos essas classes em um diagrama de classes UML que descreve a estrutura de classes
da nossa simulação. O diagrama de classes também descreve relacionamentos, conhecidos como associações, entre classes.
A Seção 4.15 — (Opcional) Estudo de caso de engenharia de software: Identificando atributos de classe — focaliza os
atributos das classes discutidas na Seção 3.9. Uma classe contém atributos (dados) e operações (comportamentos). Como veremos nas
seções a seguir, alterações nos atributos do objeto freqüentemente afetam o comportamento do objeto. Para determinar os atributos
para as classes no nosso estudo de caso, extraímos os adjetivos que descrevem os substantivos simples e os substantivos compostos (que
definiram nossas classes) do documento de requisitos, então colocamos os atributos no diagrama de classe que criamos na Seção 3.9.
A Seção 5.11 — (Opcional) Estudo de caso de engenharia de software: Identificando estados e atividades dos objetos — discute
como um objeto, em qualquer momento, ocupa uma condição específica chamada estado. Uma transição de estado ocorre quando esse objeto
recebe uma mensagem para alterar o estado. A UML fornece o diagrama de estados de máquina, que identifica o conjunto de possíveis estados
que um objeto pode ocupar e modela as transições de estado desse objeto. Um objeto também tem uma atividade — o trabalho que ele realiza no
seu tempo de vida. A UML fornece o diagrama de atividades — um fluxograma que modela a atividade de um objeto. Nesta seção, utilizamos os
dois tipos de diagramas para começar a modelar os aspectos comportamentais específicos do nosso sistema ATM, como o ATM executa uma
transação de retirada e como o ATM responde quando o usuário é autenticado.
A Seção 6.14 — (Opcional) Estudo de caso de engenharia de software: Identificando operações de classe — identifica as operações,
ou serviços, das nossas classes. Extraímos do documento de requisitos os verbos e frases com verbos que especificam as operações para cada
classe. Modificamos então o diagrama de classe da Seção 3.9 a fim de incluir cada operação com sua classe associada. Nesse ponto, no
estudo de caso, teremos coletado todas as possíveis informações do documento de requisitos. Entretanto, à medida que os capítulos
seguintes introduzirem tópicos, como herança, modificaremos nossas classes e diagramas.
A Seção 7.14 — (Opcional) Estudo de caso de engenharia de software: Colaboração entre objetos — fornece um ‘esboço’ do
modelo para nosso sistema ATM. Nesta seção vemos como ele funciona. Investigamos o comportamento da simulação discutindo
colaborações — mensagens que objetos enviam uns para os outros para se comunicar. As operações de classe que descobrimos na Seção
6.13 se tornam as colaborações entre os objetos no nosso sistema. Determinamos as colaborações e então as reunimos em um diagrama de
comunicação — o diagrama da UML para modelar colaborações. Esse diagrama revela quais objetos colaboram e quando.
Apresentamos um diagrama de comunicação das colaborações entre objetos para realizar uma consulta de saldo no ATM. Apresentamos
então um diagrama de seqüência da UML para modelar interações em um sistema. Esse diagrama enfatiza a ordem cronológica das
mensagens. Um diagrama de seqüência modela como objetos no sistema interagem para executar transações de retirada e de depósito.
A Seção 8.19 — (Opcional) Estudo de caso de engenharia de software: Começando a programar as classes do sistema ATM —
faz uma pausa no projeto do comportamento de nosso sistema. Começamos a processo de implementação para enfatizar o material discutido
no Capítulo 8. Utilizando o diagrama de classes da UML da Seção 3.9 e os atributos e as operações discutidas nas seções 4.14 e 6.13,
mostramos como implementar uma classe em Java a partir de um projeto. Não implementamos todas as classes — porque ainda não
completamos o processo de projeto. Trabalhando a partir de nossos diagramas da UML, criamos o código para a classe Withdrawal.
A Seção 10.9 — (Opcional) Estudo de caso de engenharia de software: Incorporando herança ao sistema ATM — continua
nossa discussão sobre programação orientada a objetos. Examinamos a herança — classes que compartilham características comuns
podem herdar atributos e operações de uma classe ‘base’. Nesta seção investigamos como nosso sistema ATM pode se beneficiar da
utilização de herança. Documentamos nossas descobertas em um diagrama de classes que modela relacionamentos de herança — aos
quais a UML denomina generalizações. Modificamos o diagrama de classes da Seção 3.9 utilizando a herança para agrupar classes com
características semelhantes. Esta seção conclui o projeto da parte de modelagem da nossa simulação. Implementamos esse modelo com código
Java no Apêndice J.
Apêndice J (no CD) — Código para o estudo de caso do ATM — a maior parte do estudo de caso envolveu projetar o modelo (isto
é, os dados e a lógica) do sistema ATM. Neste apêndice, implementamos esse modelo em Java. Utilizando todos os diagramas UML que
criamos, apresentamos as classes Java necessárias para implementar o modelo. Aplicamos os conceitos do projeto orientado a objetos
com a UML e programação orientada a objetos em Java que você aprendeu nos capítulos. Ao final deste apêndice, os estudantes terão
completado o projeto e a implementação de um sistema prático e agora devem estar confiantes para abordar sistemas maiores, como
aqueles que engenheiros de softwares constroem.
O Apêndice L (no CD) — UML2: Tipos de diagramas adicionais — apresenta tipos de diagramas da UML 2 não encontrados no
estudo de caso com OOD/UML.
XXVIII
Prefácio
Um passeio pelo estudo de caso opcional sobre GUIs e imagens gráficas
Nesta seção, passeamos pelas 10 seções do livro sobre o estudo de caso opcional de criação de imagens gráficas e interfaces gráficas com o usuário
(GUIs) em Java. O objetivo desse estudo de caso é criar um aplicativo de desenho polimórfico em que o usuário possa selecionar uma forma a
desenhar, selecionar as características dessa forma (como a cor da forma e se é ou não preenchida com uma cor) e utilizar o mouse para desenhar a
forma. Esse estudo de caso integrado fundamenta gradualmente esse objetivo com o leitor implementando um desenho polimórfico no Capítulo
10, adicionando uma GUI baseada em eventos no Capítulo 11 e aprimorando as capacidades do desenho no Capítulo 12 com o Java 2D. Esse
passeio fornece uma amostra dos tópicos cobertos em cada seção do estudo de caso. Depois de completar esse estudo de caso, os estudantes serão
capazes de criar seus próprios aplicativos gráficos simples.
Seção 3.9 — Utilizando caixas de diálogo — introduz interfaces gráficas com o usuário e demonstra o tratamento de entrada e
saída com caixas de diálogo. Utilizamos os diálogos JOptionPane predefinidos para exibir informações e ler texto em um aplicativo.
Seção 4.14 — Criando desenhos simples — introduz as capacidades gráficas do Java. Primeiro, descrevemos o sistema de
coordenadas do Java e então abordamos o desenho de linhas e a criação de uma janela que exibe os desenhos.
Seção 5.10 — Desenhando retângulos e ovais — explica como utilizar os métodos gráficos para desenhar retângulos e ovais.
Seção 6.13 — Cores e formas preenchidas — discute como computadores representam cores, como utilizar cores em imagens
gráficas e como preencher regiões ovais ou retangulares com uma cor sólida.
Seção 7.13 — Desenhando arcos — descreve como o Java especifica ângulos; em seguida, demonstramos como desenhar arcos
(isto é, seções de uma oval) definindo uma oval e posições angulares ao longo da oval.
Seção 8.18 — Utilizando objetos com imagens gráficas — descreve como utilizar objetos para representar formas. Criamos
classes para representar cada tipo de forma, armazenamos esses objetos em arrays e recuperamos as formas sempre que precisamos
desenhá-las.
Seção 9.8 — Exibindo texto e imagens utilizando rótulos — explora a criação de rótulos e como anexá-los à janela do aplicativo.
Os aplicativos utilizam rótulos a fim de exibir as informações para o usuário. Os rótulos em Java podem exibir texto, imagem ou ambos.
Seção 10.8 — Desenhando com polimorfismo — focaliza as características comuns das classes criadas na Seção 8.18. Nessa seção,
examinamos essas semelhanças e reprojetamos as classes das formas individuais de modo que elas herdem suas funcionalidades comuns de
uma classe de ‘base’ e possam ser processadas polimorficamente.
Exercício 11.18 — Expandindo a interface — pede ao leitor aplicar as técnicas de programação GUI baseada em eventos que
aprenderam no Capítulo 11. O leitor cria uma GUI que permite aos usuários selecionar a forma a desenhar e suas cores e então desenhar a
forma com o mouse. O aplicativo armazena e manipula as formas com as classes criadas na Seção 10.8.
Exercício 12.31 — Adicionando Java 2D — pede ao leitor utilizar as capacidades bidimensionais de desenho mais elaboradas do
Java 2D para criar um aplicativo robusto de desenho em que os usuários selecionam uma espessura de linha e opções de preenchimento da
forma (cores sólidas ou dégradés entre diferentes cores). Para fazer isso, o leitor aprimora as classes da forma no Exercício 11.18 para
armazenar informações sobre os recursos Java 2D de cada forma.
Software incluído neste livro
Há varias ferramentas Java de desenvolvimento disponíveis à venda, mas você não precisa de nenhuma para começar a trabalhar com o
Java. Escrevemos este livro utilizando somente o novo Java 2 Standard Edition Development Kit (JDK), versão 5.0. O download da
versão atual do JDK pode ser feito a partir do site da Web sobre Java da Sun java.sun.com/j2se/downloads/index.html. Esse site
também contém o download da documentação do JDK.
O CD que acompanha este livro, contém vários editores Java, incluindo a versão 1.3.5 do BlueJ Version, a versão 3.10 do JCreator
Lite (somente Windows), a versão 4.1 do jEdit e a versão 1.7.0 do jGRASP. O CD também contém o NetBeans™ Version 3.6 Integrated
Development Environment (IDE). Versões Windows e Linux do MySQL® 4.0.20 e a versão 3.0.14 do MySQL® Connector/J são
fornecidas para o processamento de banco de dados realizado nos capítulos 25–27. Por fim, a versão 5.0.25 do Apache Tomcat é fornecida
para utilização com os servlets e as JavaServer Pages nos capítulos 26–27. Se você tiver dúvidas sobre o uso desse software, consulte a
documentação no CD. O CD também contém os exemplos do livro e os links a uma página Web em HTML dos sites da Web da Deitel &
Associates, Inc. e da Prentice Hall. Essa página Web pode ser carregada em um navegador Web para acesso rápido a todos os recursos.
Companion Web site
O livro também possui um site em www.prenhall.com/deitel_br, contendo para os professores: transparências em PowerPoint (em
português), manual do professor e manual de solução (em inglês); para estudantes: código-fonte dos exemplos do livro (em inglês).
Newsletter Deitel® Buzz Online via correio eletrônico
Nosso boletim gratuito via correio eletrônico, o Deitel® Buzz Online, inclui comentários sobre tendências e desenvolvimentos na
indústria, links para artigos e recursos gratuitos dos nossos livros publicados e publicações futuras, agenda de lançamentos de produtos,
erratas, desafios, curiosidades e informações sobre nossos cursos de treinamento corporativos direcionados a instrutores e outros.
Também é como notificamos nossos leitores preventivamente sobre questões relacionadas a este livro. Todos esses recursos estão
disponíveis em inglês. Para inscrever-se, visite
www.deitel.com/newsletter/subscribe.html
Agradecimentos
XXIX
Agradecimentos
Um dos grandes prazeres de escrever um livro é o reconhecimento dos esforços de muitas pessoas cujos nomes não podem aparecer na
capa, mas cujo trabalho duro, cooperação, amizade e compreensão foram cruciais à produção do livro. Muitas pessoas na Deitel &
Associates, Inc. dedicaram longas horas a esse projeto.
• Andrew B. Goldberg é recém-graduado em ciência da computação pelo Amherst College. Andrew é um dos co-autores do Internet
and World Wide Web How to Program, 3/e e contribuiu para o Operating Systems, Third Edition. As contribuições do Andrew para
este livro incluíram as atualizações dos capítulos 3–10 com base na nova didática que introduz classes e objetos mais cedo no
currículo e outras revisões de conteúdo. Ele co-projetou e co-escreveu o novo estudo de caso opcional do sistema ATM com
OOD/UML. Ele atualizou o Apêndice M, Padrões de projeto, e foi co-autor do Apêndice L, UML 2: Tipos de diagramas
adicionais e do Apêndice N, Utilizando o depurador.
• Jeff Listfield é graduado em ciência da computação pelo Harvard College. Jeff foi co-autor de C# How to Program, C# A
Programmer’s Introduction, C# for Experienced Programmers e Simply Java Programming. Também contribuiu para o Perl How
to Program e Operating Systems, Third Edition. Jeff contribuiu no Capítulo 11, GUI: Parte 1; nos capítulos 16, Pesquisa e
classificação e 22, GUI: Parte 2; e nos capítulos 23, 24 e 29.
• Su Zhang é bacharel e doutora em ciência da computação pela McGill University. É co-autora de Java Web Services for
Experienced Programmers e Simply Java Programming. Também contribuiu para outras publicações da Deitel, incluindo
Advanced Java 2 Platform How to Program, Python How to Program e Operating Systems, Third Edition. Su contribuiu para as
seções sobre os novos recursos do J2SE 5.0 nos capítulos 7 e 8. Também participou do Capítulo 18, Genéricos; do 19, Coleções;
do 25, Manipulando bancos de dados com JDBC; do 26, Servlets; do 27, JavaServer Pages (JSP); do 28, Saída formatada; do
Apêndice F, Unicode®; do Apêndice G, Utilizando a documentação da API do Java; do Apêndice H, Criando documentação com
javadoc; e do Apêndice I, Manipulação de bit. Su também converteu boa parte dos códigos do Java How to Program, 5/e em J2SE 5.0.
• Cheryl Yaeger graduou-se em três anos pela Boston University em ciência da computação. Foi co-autora de várias publicações da
Deitel & Associates, Inc., incluindo C# How to Program, C#: A Programmer’s Introduction, C# for Experienced Programmers,
Visual Basic .NET for Experienced Programmers, Simply Visual Basic .NET 2003 e Simply C#. Cheryl também contribuiu para
outras publicações da Deitel & Associates incluindo Perl How to Program, Wireless Internet and Mobile Business How to Program,
Internet and World Wide Web How to Program, 3/e, Visual Basic .NET How to Program, 2/e e Simply Java Programming. Cheryl
contribuiu para o Capítulo 12, Imagens gráficas e Java 2DTM; Capítulo 13, Tratamento de exceção; Capítulo 14, Arquivos e
fluxos; Capítulo 15, Recursão; e Capítulo 21, Multimídia: applets e aplicativos.
• Jing Hu, participante do Summer Internship Program da Deitel & Associates Inc. é estudante de ciência da computação na
Cornell University. Ele contribuiu para o novo estudo de caso opcional sobre GUI e imagens gráficas e para o manual do
instrutor nos capítulos 3–8. Também contribuiu para as seções sobre pré-condições e pós-condições, assertivas, invariantes e a
discussão sobre vídeo no Capítulo 21.
• Sin Han Lo, participante em 2003 do Summer Internship Program da Deitel & Associates Inc. é recém-graduado em economia e
ciência da computação pelo Wellesley College. Ele contribuiu para o Capítulo 15 e projetou o exemplo de fractal deste capítulo.
• John Paul Casiello, participante em 2003 do Summer Internship Program da Deitel & Associates Inc. é aluno de ciência da
computação na Northeastern University. Ele contribuiu para o Capítulo 16, Pesquisa e classificação.
• Barbara Deitel, diretora financeira na Deitel & Associates Inc. pesquisou as citações no começo de cada capítulo e fez o
copidesque deste livro da versão original.
• Abbey Deitel, presidente da Deitel & Associates, Inc. é graduada em administração industrial pela Carnegie Mellon University.
Ela foi co-autora do Prefácio. Também sugeriu o tema e os nomes das personagens na capa do livro.
• Christi Kelsey, graduada em sistemas de informações gerenciais pela Purdue University, contribuiu para o Capítulo 1, o Prefácio
e o Apêndice N, Utilizando o depurador. Ela editou o Índice e paginou o livro inteiro.
Tivemos a felicidade de trabalhar neste projeto com uma equipe talentosa e dedicada de profissionais de publicação da Prentice Hall.
Apreciamos especialmente os esforços extraordinários de nossa editora de ciência da computação, Kate Hargett, e de sua chefe e nossa
mentora em publicações — Marcia Horton, editora-chefe da divisão de engenharia e de ciência da computação da Prentice Hall. Jennifer
Cappello realizou um trabalho extraordinário de recrutamento da equipe de revisão e de gerenciamento do processo de revisão. Vince
O’Brien, Tom Manshreck e John Lovelln fizeram um trabalho formidável como gerentes de produção deste livro. Os talentos de Carole
Anson, Paul Belfanti e Geoffrey Cassar ficam evidentes no novo projeto interno do livro e na nova arte da capa e Sarah Parker gerenciou a
publicação do extenso pacote auxiliar deste livro (da edição em inglês).
Somos muito gratos pelos esforços de nossos revisores de pós-publicação da quinta edição e aos nossos revisores da sexta edição:
Revisores acadêmicos (da edição em inglês)
Karen Arlien, Bismarck State College
Ben Blake, Cleveland State University
Walt Bunch, Chapman University
Marita Ellixson, Eglin AFB/University of Arkansas
Ephrem Eyob, Virginia State University
XXX
Prefácio
Bjorn Foss, Florida Metropolitan University
Bill Freitas, The Lawrenceville School
Joe Kasprzyk, Salem State College
Brian Larson, Modesto Junior College
Roberto Lopez-Herrejon, University of Texas at Austin
Dean Mellas, Cerritos College
David Messier, Eastern University
Andy Novobilski, University of Tennessee, Chattanooga
Richard Ord, University of California, San Diego
Gavin Osborne, Saskatchewan Institute of Applied Science & Technology
Donna Reese, Mississippi State University
Craig Slinkman, University of Texas at Arlington
Sreedhar Thota, Western Iowa Tech Community College
Mahendran Velauthapillai, Georgetown University
Loran Walker, Lawrence Technological University
Stephen Weiss, University of North Carolina at Chapel Hill
Revisores da indústria (da edição em inglês)
Butch Anton, Wi-Tech Consulting
Jonathan Bruce, Sun Microsystems, Inc. (JCP Specification Lead for JDBC)
Gilad Bracha, Sun Microsystems, Inc. (JCP Specification Lead for Generics)
Michael Develle, Consultor independente
Jonathan Gadzik, Consultor independente
Brian Goetz, Quiotix Corporation (JCP Concurrency Utilities Specification Expert Group Member)
Anne Horton, AT&T Bell Laboratories
James Huddleston, Consultor independente
Peter Jones, Sun Microsystems, Inc.
Brandon Taylor, Sun Microsystems, Inc.
Earl LaBatt, Altaworks Corp./ University of New Hampshire
Paul Monday, Sun Microsystems, Inc.
Bill O’Farrell, IBM
Cameron Skinner, Embarcadero Technologies, Inc.
Brandon Taylor, Sun Microsystems, Inc.
Karen Tegtmeyer, Consultor independente
Revisores de estudos de caso opcionais em OOD/UML (da edição em inglês)
Sinan Si Alhir, Consultor independente
Gene Ames, Star HRG
Jan Bergandy, University of Massachusetts at Dartmouth
Marita Ellixson, Eglin AFB/University of Arkansas
Jonathan Gadzik, Consultor independente
Thomas Harder, ITT ESI, Inc.
James Huddleston, Consultor independente
Terrell Hull, Consultor independente
Kenneth Hussey, IBM
Joe Kasprzyk, Salem State College
Dan McCracken, City College of New York
Paul Monday, Sun Microsystems, Inc.
Davyd Norris, Rational Software
Cameron Skinner, Embarcadero Technologies, Inc.
Craig Slinkman, University of Texas at Arlington
Steve Tockey, Construx Software
Sob uma agenda estreita, eles examinaram minuciosamente cada aspecto do texto e fizeram incontáveis sugestões para aprimorar a
exatidão e inteireza da apresentação.
Bem, aí está! O Java é uma linguagem de programação poderosa que ajuda a escrever programas de maneira rápida e eficiente. O
Java é particularmente adequado ao desenvolvimento de sistemas corporativos para ajudar as empresas a construir seus sistemas de
informações críticos. À medida que você ler este livro, apreciaríamos sinceramente seus comentários, críticas, correções e sugestões para
melhorar o texto. Envie correspondência para:
[email protected]
Sobre os autores
XXXI
Responderemos prontamente e publicaremos as correções e esclarecimentos em nosso site da Web:
www.pearson.com.br.
Esperamos que você se divirta aprendendo com este livro tanto quanto nós nos divertimos escrevendo-o!
Dr. Harvey M. Deitel
Paul J. Deitel
Sobre os autores
Dr. Harvey M. Deitel, executivo-chefe da Deitel & Associates Inc., tem 43 anos de experiência no campo de computação, incluindo extensa
experiência acadêmica e empresarial. O Dr. Deitel obteve os graus de B.S e M.S. do Massachusetts Institute of Technology e um Ph.D. da
Boston University. Ele é um dos pioneiros nos projetos dos sistemas operacionais de memória virtual na IBM e no MIT que desenvolveram as
técnicas amplamente implementadas hoje em dia em sistemas como UNIX, Linux e Windows XP. Ele tem 20 anos de experiência em ensino
universitário, incluindo nomeação definitiva e servindo como o chefe do Departamento de Ciência da Computação no Boston College antes de
fundar a Deitel & Associates, Inc. com seu filho Paul J. Deitel. Ambos são os co-autores de várias dezenas de livros e pacotes de multimídia e
atualmente estão escrevendo vários outros. Com traduções publicadas em japonês, alemão, russo, espanhol, chinês tradicional, chinês
simplificado, coreano, francês, polonês, italiano, português, grego, urdu e turco, os textos da Deitel ganharam reconhecimento internacional.
O Dr. Deitel proferiu centenas de seminários profissionais para importantes corporações, instituições acadêmicas, organizações governamentais e
órgãos militares.
Paul J. Deitel, executivo-chefe de tecnologia da Deitel & Associates, Inc., é graduado pela Sloan School of Management do MIT,
onde estudou Tecnologia da Informação. Por meio da Deitel & Associates, ministrou cursos sobre a World Wide Web, Internet, C e C++
para clientes da indústria, incluindo IBM, Sun Microsystems, Dell, Lucent Technologies, Fidelity, NASA no Kennedy Space Center,
National Severe Storm Laboratory, Compaq, White Sands Missile Range, Rogue Wave Software, Boeing, Stratus, Cambridge
Technology Partners, Open Environment Corporation, One Wave, Hyperion Software, Adra Systems, Entergy, CableData Systems e
várias outras organizações. Paul é um dos professores corporativos de Java mais experientes, tendo ministrado cerca de 100 cursos sobre
treinamento Java profissional. Deu palestras sobre C++ e Java para o Boston Chapter da Association for Computing Machinery. Ele e
seu pai, Dr. Harvey M. Deitel, são os autores de livros-texto sobre a ciência da computação líderes de vendas no mundo todo.
Sobre a Deitel & Associates, Inc.
A Deitel & Associates, Inc. é uma organização internacionalmente reconhecida de treinamento corporativo e criação de conteúdo
especializada em linguagens de programação de computadores, tecnologia de software para a World Wide Web e a Internet e ensino da
tecnologia de objetos. A empresa oferece cursos direcionados a instrutores sobre as principais linguagens de programação e plataformas,
como Java, Advanced Java, C, C++, linguagens de programação .NET, XML, Perl, Python; tecnologia de objetos; e programação para
a Internet e a World Wide Web. Os fundadores da Deitel & Associates, Inc. são o Dr. Harvey M. Deitel e Paul J. Deitel. Os clientes da
empresa incluem muitas das maiores empresas de computador do mundo, agências governamentais, áreas do serviço militar e
organizações comerciais. Ao longo dos seus 28 anos de parceria editorial com a Prentice Hall, a Deitel & Associates, Inc. publica
livros-texto de programação de ponta, livros profissionais, cursos interativos e multimídia como os Cyber Classrooms e os Complete
Training Courses, cursos de treinamento baseados na Web e conteúdo eletrônico de sistemas de gerenciamento de cursos (CMS — course
management systems) para CMSs populares como o WebCT, o Blackboard e o CourseCompass da Pearson. A Deitel & Associates e os
autores podem ser contatados via correio eletrônico (em inglês) em:
[email protected]
Para saber mais sobre a Deitel & Associates, suas publicações e o currículo do seu Dive Into™ Series Corporate Training mundial, ou
visite:
www.deitel.com
®
e inscreva-se para receber o boletim Deitel Buzz Online gratuito via correio eletrônico (em inglês) em:
www.deitel.com/newsletter/subscribe.html
Aqueles que desejam comprar livros da Deitel, Cyber Classrooms, Complete Training Courses e cursos de treinamento baseados na
Web podem fazer isso via:
www.deitel.com/books/index.html