Programação de Computadores

Programação de
Computadores
Prof. Marcio Poffo
Indaial – 2020
1a Edição
Copyright © UNIASSELVI 2020
Elaboração:
Prof. Marcio Poffo
Revisão, Diagramação e Produção:

Centro Universitário Leonardo da Vinci – UNIASSELVI
Ficha catalográfica elaborada na fonte pela Biblioteca Dante Alighieri

UNIASSELVI – Indaial.
P745p
Poffo, Marcio
Programação de computadores. / Marcio Poffo. – Indaial:

UNIASSELVI, 2020.
272 p.; il.
ISBN 978-65-5663-085-4
1. Programação (Computadores). - Brasil. 2. Linguagem de

programação. – Brasil. Centro Universitário Leonardo Da Vinci.
CDD 005.1
Impresso por:
Apresentação
As primeiras linguagens de programação não possuíam muitos
recursos como as atuais, sendo utilizadas mais exclusivamente para rotinas
batch ou, ainda, para desenvolvimento de simples telas de cadastros. Com
o passar do tempo, novos recursos surgiram com as novas linguagens de
programação, como a possibilidade de desenvolvimento de telas mais
amigáveis para o usuário, com vários recursos interativos, assim como a
comunicação dos programas via internet.
Com isso, a linguagem de programação Java permite o

desenvolvimento de aplicações desktop, mais amigáveis para o usuário e
com vários recursos interativos, assim como aplicações web (sistemas web
ou sites), aplicativos para smartphones, além de software para muitos outros
dispositivos. Neste sentido, muitos serviços on-line foram implementados
utilizando essa tecnologia, pois com o Java é possível o desenvolvimento
de qualquer aplicação, tanto desktop quanto web, desde serviços até
webservices.
Para isso, o desenvolvimento de software utilizando a tecnologia

Java tornou-se mais facilitado e, em certos casos, até menos trabalhoso,
devido ao surgimento de metodologias de desenvolvimento e padrões para
reusabilidade de código. Nesse contexto, a linguagem de programação Java
foi projetada para abranger várias melhorias, facilidades de desenvolvimento
e manutenção através de padronização de código-fonte, além de permitir
aplicações robustas com vários recursos avançados. Dentre estes benefícios,
segue a orientação a objetos, a portabilidade, a qual permite a execução de
programas em qualquer ambiente, vários recursos de redes, através das mais
variadas bibliotecas que auxiliam o desenvolvimento de aplicações em rede,
segurança e muitos outros.
Contudo, não é possível apresentarmos todos os recursos da

linguagem de programação Java, pois tornaria o livro muito extenso, porém
são apresentados desde os conceitos básicos, implementando pequenos
programas até chegar ao desenvolvimento web. Isso permite a compreensão
básica dessa linguagem, facilitando seu ingresso em outras metodologias e
frameworks de desenvolvimento que o Java oferece. Você aprenderá também
a desenvolver aplicações web que realizam persistência em banco de dados,
consultando, inserindo, atualizando e excluindo registros de tabelas.
Nesse sentido, com o objetivo de apresentarmos algumas das

tecnologias do Java, este livro aborda seus conceitos, permitindo a você
compreendê-las e entender qual delas utilizar para cada tipo de software,
isto é, qual tecnologia utilizar para um software desktop e qual tecnologia
III
utilizar para uma aplicação web, por exemplo. Para o desenvolvimento
web, você aprenderá apenas uma das tecnologias do Java que permite o
desenvolvimento desse tipo de aplicação, conceitualmente e na prática,
aplicando recursos no desenvolvimento de uma aplicação, que servirá de
início para seu sucesso nessa linguagem.
Outra grande vantagem ao desenvolver softwares utilizando a

tecnologia Java, além de permitir o desenvolvimento de qualquer aplicação,
simples ou robusta, é a colaboração de comunidades de desenvolvedores, o
que facilita ao desenvolvedor tirar dúvidas em algum determinado problema
que surgir durante a implementação. Além disso, aplicações desenvolvidas
com a linguagem de programação Java são multiplataforma, isto é, é possível
executar a mesma aplicação em qualquer sistema operacional, assim como
em vários hardwares diferentes, desde que o interpretador do Java esteja
instalado. Assim, softwares desenvolvidos em Java são emulados pela JVM
(Java Virtual Machine), a qual realiza a conversão do código-fonte em bytecodes,
e deste em linguagem de máquina, a qual o computador compreende.
Por fim, no contexto deste livro são apresentados alguns dos recursos
disponibilizados pela plataforma Java, na qual você aprenderá e compreenderá
desde a criação dos tipos de variáveis e constantes, assim como utilizá-los,
seguido da configuração completa do ambiente de desenvolvimento Java,
para que você consiga praticar todos os exemplos apresentados. Logo após são
apresentados os comandos básicos da linguagem de programação Java, isto
é, os operadores lógicos, aritméticos, relacionais, os quais são essenciais para
o desenvolvimento de qualquer software, implementando regras de negócios
e auxiliando o fluxo dos programas através dos comandos de controle de
fluxos e laços de repetição. Você também aprenderá o conceito da orientação
a objetos, assim como a implementação prática de exemplos, e no decorrer
dos tópicos, a utilização de algumas tecnologias de desenvolvimento.
Para compreender todos os conteúdos deste livro, você precisará ter

muita determinação e força de vontade, desenvolvendo todos os exemplos
na prática, facilitando seu entendimento da tecnologia Java, sendo fornecido
um material com o passo a passo para sua fácil compreensão. Nesse sentido,
realize este período de estudos com o máximo de dedicação possível,
pois através deste livro você terá conhecimentos sólidos da linguagem de
programação Java, além de aprimorar os seus conhecimentos de lógica.
Lembre-se de que neste livro você aprenderá desde o básico da

plataforma Java até o desenvolvimento de algumas tecnologias que o Java
oferece, permitindo que você, no futuro, busque conhecimentos de novas
tecnologias que essa linguagem de programação oferece.
Bons estudos e boa programação!
Prof. Me. Marcio Poffo
IV
NOTA
Você já me conhece das outras disciplinas? Não? É calouro? Enfim, tanto para
você que está chegando agora à UNIASSELVI quanto para você que já é veterano, há
novidades em nosso material.
Na Educação a Distância, o livro impresso, entregue a todos os acadêmicos desde 2005, é

o material base da disciplina. A partir de 2017, nossos livros estão de visual novo, com um
formato mais prático, que cabe na bolsa e facilita a leitura.
O conteúdo continua na íntegra, mas a estrutura interna foi aperfeiçoada com nova
diagramação no texto, aproveitando ao máximo o espaço da página, o que também
contribui para diminuir a extração de árvores para produção de folhas de papel, por exemplo.
Assim, a UNIASSELVI, preocupando-se com o impacto de nossas ações sobre o ambiente,

apresenta também este livro no formato digital. Assim, você, acadêmico, tem a possibilidade
de estudá-lo com versatilidade nas telas do celular, tablet ou computador.

Eu mesmo, UNI, ganhei um novo layout, você me verá frequentemente e surgirei para
apresentar dicas de vídeos e outras fontes de conhecimento que complementam o assunto
em questão.
Todos esses ajustes foram pensados a partir de relatos que recebemos nas pesquisas
institucionais sobre os materiais impressos, para que você, nossa maior prioridade, possa
continuar seus estudos com um material de qualidade.
Aproveito o momento para convidá-lo para um bate-papo sobre o Exame Nacional de

Desempenho de Estudantes – ENADE.

Bons estudos!
LEMBRETE
Olá, acadêmico! Iniciamos agora mais uma disciplina e com ela

um novo conhecimento.
Com o objetivo de enriquecer seu conhecimento, construímos, além do livro

que está em suas mãos, uma rica trilha de aprendizagem, por meio dela você terá
contato com o vídeo da disciplina, o objeto de aprendizagem, materiais complementares,
entre outros, todos pensados e construídos na intenção de auxiliar seu crescimento.
Acesse o QR Code, que levará ao AVA, e veja as novidades que preparamos para seu estudo.
Conte conosco, estaremos juntos nesta caminhada!
V
VI
Sumário
UNIDADE 1 – LINGUAGEM DE PROGRAMAÇÃO JAVA.............................................................1
TÓPICO 1 – APRESENTAÇÃO DA LINGUAGEM DE PROGRAMAÇÃO JAVA.......................3

1 INTRODUÇÃO........................................................................................................................................3
2 HISTÓRIA DO JAVA..............................................................................................................................3
3 MÁQUINA VIRTUAL DO JAVA (JAVA VIRTUAL MACHINE – JVM).........................................4
4 JIT (JUST-IN-TIME COMPILER) E O CLASS LOADER.................................................................7
5 VERSÕES DO JAVA................................................................................................................................8
6 JVM, JRE E JDK........................................................................................................................................8
7 DESENVOLVENDO E COMPILANDO EM JAVA...........................................................................8
8 EXECUTANDO O PROGRAMA EM JAVA......................................................................................13
9 ERROS DE COMPILAÇÃO COMUNS.............................................................................................14
10 VARIÁVEIS PRIMITIVAS, CONSTANTES E CONVERSÕES.................................................15
10.1 VARIÁVEIS PRIMITIVAS............................................................................................................15
10.2 CONSTANTES...............................................................................................................................18
10.3 CRIANDO UMA APLICAÇÃO COM VARIÁVEIS.................................................................18
10.4 DECLARAÇÃO E UTILIZAÇÃO DE VARIÁVEIS DE TIPOS DE DADOS PRIMITIVOS..... 20
11 COMENTÁRIO DE LINHAS DE CÓDIGO-FONTE...................................................................21
12 OPERADORES DA LINGUAGEM..................................................................................................23
12.1 OPERADOR DE ATRIBUIÇÃO..................................................................................................23
12.2 OPERADORES ARITMÉTICOS..................................................................................................24
12.3 OPERADORES DE IGUALDADE..............................................................................................24
12.4 OPERADORES RELACIONAIS.................................................................................................25
12.5 OPERADORES LÓGICOS...........................................................................................................25
12.6 OPERADORES DE INCREMENTO E DECREMENTO..........................................................26
RESUMO DO TÓPICO 1........................................................................................................................27
AUTOATIVIDADE..................................................................................................................................28
TÓPICO 2 – INSTALAÇÃO E CONFIGURAÇÃO DO AMBIENTE DE

DESENVOLVIMENTO.....................................................................................................31
1 INTRODUÇÃO......................................................................................................................................31
2 INSTALAÇÃO DO JAVA DEVELOPMENT KIT (JDK)................................................................32
3 INSTALAÇÃO DO SISTEMA GERENCIADOR DE BANCO DE DADOS MYSQL..............37
3.1 CONHECENDO O MYSQL............................................................................................................37
3.2 INSTALAÇÃO DE CONFIGURAÇÃO DO MYSQL...................................................................39
4 AMBIENTE DE DESENVOLVIMENTO ECLIPSE.........................................................................44
4.1 INSTALAÇÃO E CONFIGURAÇÃO DO ECLIPSE....................................................................45
4.2 CONHECENDO O ECLIPSE..........................................................................................................47
4.2.1 Janelas/Visualizações (Views).................................................................................................49
4.2.2 Editor.........................................................................................................................................50
4.2.3 Barra de Menus (Menu Bar)...................................................................................................51
4.2.4 Barra de Ferramentas (Toolbar)..............................................................................................51
VII
5 INSTALAÇÃO E CONFIGURAÇÃO DO SERVIDOR DE APLICAÇÃO TOMCAT
NO ECLIPSE...........................................................................................................................................51
5.1 APPLICATION SERVER E SERVLET CONTAINER.....................................................................52
5.2 CONHECENDO MELHOR O TOMCAT......................................................................................52
5.3 BAIXANDO O TOMCAT.................................................................................................................53
5.4 CONFIGURAÇÃO DO TOMCAT NO ECLIPSE.........................................................................53
6 CRIANDO UMA APLICAÇÃO PARA EXECUTAR NO TOMCAT............................................57
7 AMBIENTE DE DESENVOLVIMENTO NETBEANS...................................................................60
7.1 INSTALAÇÃO E CONFIGURAÇÃO DO NETBEANS..............................................................61
7.2 CONFIGURAÇÃO DO NETBEANS..............................................................................................62
7.3 JANELAS PARA VISUALIZAÇÕES NO NETBEANS................................................................65
RESUMO DO TÓPICO 2........................................................................................................................66
AUTOATIVIDADE..................................................................................................................................67
TÓPICO 3 – CASTING, CONTROLE DE FLUXO E LAÇOS DE REPETIÇÃO...........................69

1 INTRODUÇÃO......................................................................................................................................69
2 CASTING: CONVERSÕES ENTRE VARIÁVEIS DE TIPOS DE DADOS DIFERENTES.....69
2.1 TIPOS DE DADOS QUE SÃO OBJETOS.......................................................................................72
3 COMANDOS DE CONTROLE DE FLUXO E LAÇOS DE REPETIÇÃO...................................72
3.1 COMANDO CONDICIONAL IF...................................................................................................73
3.2 COMANDO SWITCH......................................................................................................................75
3.3 LAÇO DE REPETIÇÃO WHILE.....................................................................................................75
3.4 LAÇO DE REPETIÇÃO FOR..........................................................................................................77
3.5 CONTROLE BREAK E CONTINUE EM LAÇOS DE REPETIÇÃO..........................................77
3.6 ESCOPO DE VARIÁVEIS................................................................................................................79
4 DESENVOLVIMENTO PRÁTICO DE PROGRAMAS EM JAVA...............................................80
4.1 EXEMPLO PRÁTICO 1....................................................................................................................81
4.2 EXEMPLO PRÁTICO 2....................................................................................................................82
4.3 EXEMPLO PRÁTICO 3....................................................................................................................84
LEITURA COMPLEMENTAR................................................................................................................85
RESUMO DO TÓPICO 3........................................................................................................................88
AUTOATIVIDADE..................................................................................................................................89
UNIDADE 2 – CONCEITOS DE ORIENTAÇÃO A OBJETOS, PACOTES JAVA.LANG

E JAVA.IO, VETORES UNIDIMENSIONAIS E MULTIDIMENSIONAIS........91
TÓPICO 1 – CONCEITOS DE ORIENTAÇÃO A OBJETOS...........................................................93

1 INTRODUÇÃO......................................................................................................................................93
2 CRIANDO UM TIPO: CLASSE EM JAVA........................................................................................95
3 INSTÂNCIA DE UMA CLASSE: UTILIZANDO UM OBJETO...................................................97
4 ATRIBUTOS E MÉTODOS DE UMA CLASSE...............................................................................99
5 ENCAPSULAMENTO........................................................................................................................103
6 MODIFICADORES DE ACESSO.....................................................................................................104
7 HERANÇA............................................................................................................................................106
RESUMO DO TÓPICO 1......................................................................................................................108
AUTOATIVIDADE................................................................................................................................110
TÓPICO 2 – EXCEÇÕES E CONTROLE DE ERROS......................................................................113

1 INTRODUÇÃO....................................................................................................................................113
2 EXEMPLIFICANDO O TRATAMENTO DE EXCEÇÕES............................................................114
3 TRATAMENTO DE EXCEÇÕES EM JAVA....................................................................................116
VIII
4 TRATAMENTO DE EXCEÇÕES EM JAVA DO TIPO CHECKED............................................122
5 CLASSE THROWABLE......................................................................................................................126
6 REALIZANDO O LANÇAMENTO DE EXCEÇÕES....................................................................127
7 CRIANDO AS PRÓPRIAS EXCEÇÕES..........................................................................................131
8 CLÁUSULA FINALLY.........................................................................................................................132
RESUMO DO TÓPICO 2......................................................................................................................134
AUTOATIVIDADE................................................................................................................................135
TÓPICO 3 – PACOTES JAVA.LANG, JAVA.IO E VETORES........................................................137

1 INTRODUÇÃO....................................................................................................................................137
2 PACOTE JAVA.LANG.........................................................................................................................137
3 O PACOTE JAVA.IO............................................................................................................................143
4 CLASSE FILE........................................................................................................................................144
5 CLASSE FILEINPUTSTREAM..........................................................................................................146
6 CLASSE FILEOUTPUTSTREAM.....................................................................................................149
7 ARRAYS..................................................................................................................................................152
8 ARRAYS MULTIDIMENSIONAIS..................................................................................................157
LEITURA COMPLEMENTAR..............................................................................................................161
RESUMO DO TÓPICO 3......................................................................................................................166
AUTOATIVIDADE................................................................................................................................167
UNIDADE 3 – TECNOLOGIAS DE DESENVOLVIMENTO JAVA.............................................169
TÓPICO 1 – INTERFACES GRÁFICAS.............................................................................................171

1 INTRODUÇÃO....................................................................................................................................171
2 INTERFACES GUI NO JAVA............................................................................................................171
3 CLASSE JFRAME.................................................................................................................................173
4 CLASSE JLABEL..................................................................................................................................173
5 CLASSE JTEXTFIELD.........................................................................................................................174
6 CLASSE JPASSWORDFIELD............................................................................................................174
7 CLASSE JBUTTON.............................................................................................................................175
8 CRIAÇÃO DO FRAME PARA ACESSO DO USUÁRIO (LOGIN)...........................................175
9 CLASSES JMENUBAR, JMENU E JMENUITEM.........................................................................179
10 CLASSE JPANEL................................................................................................................................183
11 CLASSE JCHECKBOX......................................................................................................................185
12 CLASSE JRADIOBUTTON.............................................................................................................190
13 CLASSES JLIST..................................................................................................................................193
14 CLASSES JCOMBOBOX..................................................................................................................196
RESUMO DO TÓPICO 1......................................................................................................................200
AUTOATIVIDADE................................................................................................................................202
TÓPICO 2 – MANIPULAÇÃO DE DADOS: UTILIZANDO JDBC PARA DESKTOP............205

1 INTRODUÇÃO....................................................................................................................................205
2 JDBC: MANIPULAÇÃO DE DADOS.............................................................................................205
3 CRIAÇÃO DE CLASSE DE CONEXÃO.........................................................................................208
4 PADRÃO DAO.....................................................................................................................................215
5 APLICAÇÃO DESKTOP (SWING) COM BANCO DE DADOS...............................................223
RESUMO DO TÓPICO 2......................................................................................................................233
AUTOATIVIDADE................................................................................................................................235
IX
TÓPICO 3 – DESENVOLVIMENTO DE APLICAÇÃO WEB: JSP E SERVLET.........................239
1 INTRODUÇÃO....................................................................................................................................239
2 JSP (JAVA SERVER PAGES)..............................................................................................................239
3 APLICAÇÃO CLIENTE COM JSP...................................................................................................244
4 TECNOLOGIA SERVLET..................................................................................................................247
5 EXEMPLO DE APLICAÇÃO UTILIZANDO SERVLET E JSP...................................................248
LEITURA COMPLEMENTAR..............................................................................................................264
RESUMO DO TÓPICO 3......................................................................................................................266
AUTOATIVIDADE................................................................................................................................268
REFERÊNCIAS........................................................................................................................................270
X
UNIDADE 1
LINGUAGEM DE PROGRAMAÇÃO JAVA
OBJETIVOS DE APRENDIZAGEM
A partir do estudo desta unidade, você deverá ser capaz de:
• conhecer a linguagem de programação Java;
• compreender os componentes básicos da linguagem;
• aprender a configurar o ambiente de desenvolvimento do Java, incluindo

o sistema gerenciador de banco de dados MySQL;
• aprender a desenvolver pequenos algoritmos nesta linguagem.
PLANO DE ESTUDOS
Esta unidade está dividida em três tópicos. No decorrer da unidade
você encontrará autoatividades com o objetivo de reforçar o conteúdo
apresentado.
TÓPICO 1 – APRESENTAÇÃO DA LINGUAGEM DE PROGRAMAÇÃO

JAVA
TÓPICO 2 – INSTALAÇÃO E CONFIGURAÇÃO DO AMBIENTE DE

DESENVOLVIMENTO
TÓPICO 3 – CASTING, CONTROLE DE FLUXO E LAÇOS DE

REPETIÇÃO
CHAMADA
Preparado para ampliar seus conhecimentos? Respire e vamos

em frente! Procure um ambiente que facilite a concentração, assim absorverá
melhor as informações.
1
2
UNIDADE 1
TÓPICO 1
APRESENTAÇÃO DA LINGUAGEM DE PROGRAMAÇÃO JAVA
1 INTRODUÇÃO
Antes de ingressar na atividade de programação propriamente dita, é
interessante compreender um pouco da história da plataforma Java, o que facilita
o entendimento do porquê esta linguagem de programação obter sucesso, e,
atualmente, a maioria das organizações a utilizam, direta ou indiretamente.
Na época do desenvolvimento de software com linguagens antigas havia

muitos problemas recorrentes da atividade de desenvolvimento de sistemas,
por exemplo, o gerenciamento de memória, a organização de códigos-fonte,
bibliotecas, reescrita de código-fonte ao ter que rodar a aplicação em outro
sistema operacional a que este não foi projetado, assim como o custo financeiro
de se utilizar uma tecnologia.
Neste sentido, a linguagem de programação Java resolve todos esses

problemas, pois essa linguagem possui um bom gerenciamento de memória, o
código-fonte pode ser dividido em classes, conceito que você aprenderá neste
livro. Além disso, a importação de bibliotecas para o projeto é bem simples, e
todas, senão a maioria, são gratuitas, assim como a própria tecnologia Java, a
qual não possui custo, e a aplicação desenvolvida com essa tecnologia pode ser
executada em qualquer sistema operacional.
Com o tempo, o Java passou a ser a tecnologia utilizada para

desenvolvimento de aplicações voltadas a dispositivos de comunicação, assim
como para internet e intranet. Segundo Deitel e Deitel (2003), são muitos os
dispositivos que utilizam a plataforma Java, por exemplo, os celulares, hoje mais
avançados e conhecidos por smartphones, permitindo realização de comunicação
por internet.
2 HISTÓRIA DO JAVA
A SUN Microsystems foi criada em 1985 por quatro estudantes da
universidade de Stanford, devido a isso tem o nome SUN (Stanford University
Network), a qual iniciou no mercado de desktops utilizando processadores
Motorola, logo depois começou a desenvolver os processadores utilizados
(CAMPOS; CAMPOS, 2018). Para Campos e Campos (2018), a SUN passou a
trabalhar com equipamentos para servidores e comprou o MySQL em 2008.
3
UNIDADE 1 | LINGUAGEM DE PROGRAMAÇÃO JAVA
Uma das criações da SUN foi o Java, em 1991, o qual possuía a finalidade de
ser compatível com diversas plataformas que rodavam em diversos dispositivos,
assim, o Java foi criado para utilização em dispositivos eletrônicos e não para
computadores (CAMPOS; CAMPOS, 2018).
Com o surgimento da internet em 1990, a qual começou a aparecer aos

poucos e ser utilizada, mais comercialmente, muitos computadores com diferentes
sistemas operacionais e plataformas diferentes passaram a utilizar a internet.
Nesse sentido, a partir de 1995, a SUN percebeu que poderia utilizar a ideia
criada em 1992, Java, para rodar pequenas aplicações applets (aplicação em Java
que roda em navegador) dentro do browser Netscape, um dos mais utilizados
na época (CAMPOS; CAMPOS, 2018). Ainda segundo Campos e Campos (2018),
como havia uma grande quantidade de sistemas operacionais e navegadores
(browsers) de internet, essa foi uma enorme vantagem em permitir implementar
uma aplicação em uma única linguagem, independentemente da plataforma. Foi
com essa transformação do navegador de internet na possibilidade de realizar
operações mais avançadas que o Java passou a ser muito utilizado, inclusive por
grandes organizações, fazendo com que navegadores de internet realizassem
algo mais do que apenas renderizar html.
Com o passar dos anos, novas tecnologias do Java para web surgiram,
como Servlets e JSPs, os quais serão estudados neste livro, JSF, Java FX, entre
outros, e consequentemente os applets deixaram de serem utilizados.
3 MÁQUINA VIRTUAL DO JAVA (JAVA VIRTUAL MACHINE –

JVM)
Iniciemos nosso estudo sobre máquina virtual em Java compreendendo
como funciona a interpretação pelo Sistema Operacional de programas escritos
em outras linguagens de programação de alto nível, como em Pascal, para
a qual o código-fonte escrito nesta linguagem de programação é compilado,
com isso, gerando um código binário, o qual é lido pelo Sistema Operacional
(RICARTE, 2008).
FIGURA 1 – COMPILAÇÃO DE CÓDIGO-FONTE
Código-Fonte em Pascal Código Binário Gerado
FONTE: O autor
4
TÓPICO 1 | APRESENTAÇÃO DA LINGUAGEM DE PROGRAMAÇÃO JAVA
O compilador pode ser entendido como um programa que realiza

a tradução da linguagem de alto nível, linguagens de programação, para a
linguagem de máquina, para que o processador entenda os comandos que devem
ser executados (RICARTE, 2008). Ainda segundo Ricarte (2008), um programa de
sistema é um programa que permite que outros softwares funcionem, sendo o
compilador um programa de sistema, assim como um sistema operacional.
Neste sentido, com o código-fonte compilado é gerado um código de

máquina, binário (zeros e uns) para uma determinada plataforma e Sistema
Operacional, ou seja, um programa escrito em Pascal, ao ser compilado, é
específico para ser compreendido por um sistema operacional (RICARTE, 2008).
Então, neste caso, muitas das linguagens de programação funcionam para

apenas um sistema operacional, como o Delphi, por exemplo, o qual possui outra
distribuição exclusiva para o Linux, neste caso, se for necessário que a mesma
aplicação rode nos dois sistemas operacionais, temos um código-fonte para o
Windows e outro para o Linux.
Os arquivos binários do Java são independentes de plataforma, o que

pode ser entendido por permitir alternar entre diferentes sistemas operacionais
(SOMERA, 2006).
Segundo Somera (2006, p. 7), “bytecodes são um conjunto de instruções

muito parecidas com a linguagem de máquina, mas que não são específicas com
relação a algum processador. Não há necessidade de levar o código-fonte e fazer
sua compilação em um sistema no qual será executado”.
Ainda de acordo com Somera (2006), o ambiente de desenvolvimento do

Java é constituído de:
• Compilador: não gera código-fonte de máquina, mas sim um bytecode.

• Interpretador: serve para interpretar o código gerado.
FIGURA 2 – PROCESSO DE COMPILAÇÃO
FONTE: Somera (2006, p. 8)
5
A Máquina Virtual Java (Java Virtual Machine), abreviada por JVM, executa
aplicações escritas na linguagem de programação Java, neste caso, possuindo
todos os recursos necessários para proteger aplicações distribuídas com
segurança através do framework java.security, o qual possui diversas bibliotecas
para garantir requisições seguras, por exemplo (SOMERA, 2006).
Além disso, quando o código-fonte desenvolvido na linguagem de

programação Java é compilado é gerado o bytecode, o qual é utilizado na Máquina
Virtual Java, que possui um interpretador para esse tipo de codificação (COOPER,
2014). Ainda de acordo com Cooper (2014), a máquina virtual pode ser descrita
como sendo uma espécie de simulador, o qual interpreta os comandos para um
processador ou sistema operacional.
Outro exemplo da importância da JVM, a fim de evitar desenvolver um

código-fonte para um Sistema Operacional e outro código para outro Sistema
Operacional é para a interface gráfica, isto é, desenvolvimento de telas, em que as
bibliotecas usadas para desenvolvimento para o Sistema Operacional Windows
são diferentes das utilizadas para o Linux.
Neste sentido, o Java utiliza o conceito de máquina virtual, conforme já

descrito, em que existe entre o sistema operacional e o software uma camada extra
que realiza o trabalho de tradução dos bytecodes para que o sistema operacional
compreenda os comandos implementados no software.
FIGURA 3 – PROCESSO DE EXECUÇÃO DE APLICAÇÃO JAVA
FONTE: Nartovich et al. (2008, p. 4)
6
Conforme a Figura 3, não é possível executar os bytecodes gerados,

isso porque o sistema entende apenas linguagem de máquina, as quais são
únicas para cada processador e Sistema Operacional, problema que é resolvido
com a intermediação entre a aplicação desenvolvida e o sistema operacional
(NARTOVICH et al., 2008).
Em síntese, com a utilização da JVM, obtém-se a independência de

sistema operacional, não importando se a aplicação está sendo executada no
Windows, Linux ou outro sistema operacional, porém a instalação da JVM no
seu computador deve ser a versão correta para o sistema operacional instalado
no computador.
4 JIT (JUST-IN-TIME COMPILER) E O CLASS LOADER

Outro conceito interessante que você deve conhecer é o JTI (Just-In-Time
Compiler), o qual, assim que a JVM perceber a necessidade, realiza a compilação de
códigos-fonte de instruções nativas da plataforma, fundamentado em melhorar a
performance da aplicação desenvolvida em Java (NARTOVICH et al., 2008).
DICAS
Acesse o vídeo https://www.youtube.com/watch?v=sR_OXvuJIyA para entender

melhor este conceito.
Ainda de acordo com Nartovich et al. (2008), antes de o interpretador do

Java realizar a conversão de códigos-fonte para bytecodes, arquivos com classes
Java devem ser carregados, trabalho realizado pelo class loader, o qual possui as
seguintes finalidades:
• Facilitar o carregamento de códigos.

• Resolver problemas de definições de classes, pois a linguagem Java permite
a definição de duas ou mais classes com mesmo nome, desde que estejam em
pacotes (packages) diferentes.
• Verificar se os bytecodes estão com a linguagem escrita corretamente.
• Inicializar carregamento de classes, alocando memória.
7
5 VERSÕES DO JAVA
O Java 1.0 e 1.1 são as primeiras versões do Java, muito antigas, as quais
possuíam algumas bibliotecas muito utilizadas, como o JDBC e o java.io. Através
de melhorias do Java, a partir da versão 1.2, o tamanho da API tornou-se muito
grande, devido a isso foi trocada a nomenclatura para Java2, com o objetivo de
diminuir confusões entre Java e Javascript.
Após melhorias através de novas implementações, com novas

funcionalidades disponibilizadas pela API, houve a liberação das versões Java2
1.3 e 1.4, consequentemente o Java 1.5, o qual passou a ser denominado por Java
5, desaparecendo o número 2 da nomenclatura Java.
A versão atual do Java liberada para ser baixada e instalada é o Java 9,

porém, para as atividades deste livro, é possível ter instalado apenas o Java 7, de
preferência o 8.
6 JVM, JRE E JDK

O que significam essas abreviações? É interessante saber a diferença entre:
• JVM (Java Virtual Machine): é a Máquina Virtual Java, conforme descrita

anteriormente.
• JRE (Java Runtime Environment): é o ambiente que executa aplicações
desenvolvidas na linguagem Java, o qual é constituído da JVM e bibliotecas.
Ele é normalmente instalado por usuários de aplicações.
• JDK (Java Development Kit): é formado pela JRE e todas as bibliotecas necessárias
para o desenvolvimento de aplicações, a qual é detalhada no Subtópico
2 – Instalação do Java Development Kit (JDK) do Tópico 2 – Instalação e
configuração do ambiente de desenvolvimento.
7 DESENVOLVENDO E COMPILANDO EM JAVA

Primeiramente, falaremos sobre o objeto System.out, muito utilizado no
desenvolvimento de aplicações Java, pois permite imprimir Strings no console da
IDE ou do terminal, normalmente utilizado para acompanhamento de processos,
apresentando saídas de uma determinada operação ou mesmo para verificar
onde o cursor está trafegando pelo código.
8
NOTA
String pode ser entendida como sendo uma sequência de caracteres

alfanuméricos. Na linguagem Java, string não é um tipo de dado, mas sim uma classe, neste
sentido, suas variáveis são objetos do tipo dessa classe, recebendo qualquer caractere.
O objeto System.out possui três métodos parecidos que servem para

imprimir Strings, sendo eles:
• System.out.print: método que apenas realiza a impressão (saída) da String no

console ou terminal.
• System.out.println: método que realiza a impressão (saída) da String no console
ou terminal, porém, pulando uma linha.
• System.out.printf: método que realiza a impressão (saída) da String no console
ou terminal, porém, com um parâmetro a mais de formatação, isto é, pode ser
incluída a formatação de números para uma String, por exemplo.
Para testarmos a compilação de um programa escrito na linguagem Java,

no bloco de notas do seu sistema operacional digite a seguinte linha de comando,
a qual, conforme conhecemos o método “println” do objeto System.out, imprimirá
o conteúdo passado por parâmetro em uma nova linha. Exemplo de Comando de
impressão de String:
System.out.println("Olá mundo!");
Como somente o comando apresentado não será compilado, pois na

linguagem de programação Java devemos trabalhar com classes, conceito
que veremos mais adiante, ocorrerá um erro na compilação. Neste sentido,
para conseguirmos compilar a linha de comando apresentada anteriormente,
precisamos criar o comando dentro do método de execução de uma classe,
conforme apresentado na Figura 4.
9
FIGURA 4 – CLASSE PARA TESTAR EXECUÇÃO DE COMANDO
FONTE: O autor
Após implementado o código-fonte, conforme a Figura 4, você deve

salvar o código-fonte implementado no bloco de notas em algum diretório de
seu computador, porém, você deve salvá-lo com a extensão .java, conforme
apresentado na Figura 2. De preferência, tente utilizar o mesmo nome de arquivo
sendo salvo na Figura 5, isto é, “TesteOla.java”, pois utilizaremos esse mesmo
nome para os demais procedimentos de compilação. No entanto, caso você
utilizar outra nomenclatura para o arquivo, você deverá lembrar do nome do
arquivo utilizado para os comandos que serão efetuados a seguir.
FIGURA 5 – SALVAR CÓDIGO NA EXTENSÃO .JAVA
FONTE: O autor
10
Agora, abra o prompt de comando CMD no sistema operacional

Windows e acesse, através do comando “CD”, o diretório de instalação do JDK,
incluindo o subdiretório “bin”, conforme ilustrado na Figura 6.
E
IMPORTANT
Prompt de comando é um terminal análogo ao MS-DOS, que serve para

escrever comandos para o sistema operacional. Para acessá-lo, no Windows, basta pesquisar
por “CMD.EXE” e abrir este programa clicando nele.
FIGURA 6 – ACESSO AO DIRETÓRIO BIN DO JDK PELO CMD
FONTE: O autor
Lembrando que a máquina virtual não compreende o código java, mas sim
um código de máquina específico, sendo este código gerado por um compilador
Java, como o javac, utilizado no comando a seguir.
Após o acesso ao subdiretório “bin”, digite o comando "javac

CAMINHOARQUIVO\TesteOla.java”, sendo que o termo “CAMINHOARQUIVO”
deve ser substituído pelo caminho em que você salvou o arquivo “TesteOla.
java”. Neste sentido, se você salvou o arquivo em c:\ TesteOla.java, então basta
substituir o termo “CAMINHOARQUIVO” por “c:\”, conforme apresentado o
comando completo na Figura 7.
FIGURA 7 – COMANDO PARA COMPILAR A CLASSE JAVA CRIADA
FONTE: O autor
11
Em seguida, após a execução do comando de compilação de nossa classe,

conforme Figura 4, acesse o diretório onde o arquivo da classe, TesteOla.java, foi
salvo; neste você pode observar que foi criado um outro arquivo, cuja extensão é
.CLASS, o qual está ilustrado na Figura 8. Caso houvesse algum erro no código-
fonte da classe TesteOla, no momento da compilação ocorreria o erro.
FIGURA 8 – ARQUIVO .CLASS CRIADO APÓS COMPILAÇÃO
FONTE: O autor
A Figura 9 ilustra a abertura do arquivo .class gerado, o qual não é

legível para seres humanos, porém é este código que a Máquina Virtual Java
compreende, para então requisitar ao sistema operacional as operações. É
possível, através de alguns programas, a conversão de um bytecode para o .java
original, podendo ser perdidos os comentários e nomes de variáveis locais.
FIGURA 9 – ABERTURA DE ARQUIVO .CLASS
FONTE: O autor
12
8 EXECUTANDO O PROGRAMA EM JAVA

Como a compilação da classe foi bem-sucedida, isto é, foi gerado o
bytecode no arquivo “.Class”, basta testarmos a execução de nossa classe. Para
isso, novamente, no prompt de comando (CMD) do Windows, entre no diretório
onde está salvo o arquivo da classe, que em nosso caso tivemos de executar o
comando “cd..” algumas vezes para sair do diretório do JDK, até selecionar o
diretório “C:\” raiz, onde salvamos o arquivo. Caso você abrir um novo prompt
de comando, então você deve acessar o diretório através do comando “cd c:\
DIRETORIO_ARQUIVO”, sendo que DIRETORIO_ARQUIVO deve ser o
diretório exato onde o arquivo está gravado. Conforme apresentado na Figura
10, execute o comando “java TesteOla”, o qual realiza a execução da classe, isto é,
executa os comandos implementados na classe.
FIGURA 10 – EXECUÇÃO DA CLASSE
FONTE: O autor
Conforme Figura 11, após a execução do comando “java” mais o nome

da classe, é retornado o resultado da execução da classe, que nesse caso é a
impressão da String “Olá mundo!” no console.
FIGURA 11 – CLASSE EXECUTADA
FONTE: O autor
13
Neste contexto, a parte interna da classe é o comando que foi executado

quando invocamos a JVM, assim, essa é a parte que importa para você até este
momento, e você não precisa se preocupar com a declaração da classe e do método
main. No entanto, é importante salientar que todas as aplicações desenvolvidas
em Java iniciam por um ponto de entrada, sendo este, o método main. Este é um
código-fonte muito simples, principalmente para quem já possui experiência em
desenvolvimento de software, pois apenas foi utilizando o comando System.out.
println para realizar a impressão de um simples texto no console, ou no terminal
de comandos do sistema operacional, nesse caso. Você poderia ter utilizado
outro editor de texto com mais recursos, que possua, por exemplo, a facilidade de
visualização da endentação do código-fonte, mas para facilitar o entendimento
utilizamos o bloco de notas, o qual é bem simples de utilizar.
9 ERROS DE COMPILAÇÃO COMUNS

Um dos erros mais comuns, não somente na linguagem de programação
Java, mas em muitas delas, é a falta do sinal de ponto e vírgula ao terminar um
comando. Um exemplo é apresentado na Figura 12, em que podemos analisar
que ao final da linha “System.out.println” falta uma vírgula.
FIGURA 12 – VÍRGULA FALTANDO
FONTE: O autor
Após a compilação do código-fonte apresentado na Figura 12, como

está faltando uma vírgula ocorrerá o erro “expected”, conforme apresentado na
Figura 13.
14
FIGURA 13 – ERRO INDICANDO QUE FALTA PONTO E VÍRGULA
FONTE: O autor
Analise o erro apresentado na Figura 13, o qual informa que na linha 4

está faltando uma vírgula, sendo este um dos erros mais comuns.
10 VARIÁVEIS PRIMITIVAS, CONSTANTES E CONVERSÕES

Uma aplicação desenvolvida na linguagem de programação Java é
constituída por classes e objetos, e estes são compostos por métodos (operações) e
variáveis (CADENHEAD; LEMAY, 2005).
Neste subtópico serão apresentadas as variáveis primitivas, constantes e

suas conversões, assim como a aplicação desses conceitos em programas, visando:
• À declaração e atribuição de valores, realização do casting e a comparação de

variáveis.
• Entender e praticar a implementação de condições (controle de fluxo) com os
comandos if e else.
• Entender e praticar a implementação de instruções com laços de repetição for e
while, incluindo condições (controle de fluxo) com comando break e continue.
10.1 VARIÁVEIS PRIMITIVAS

Uma variável pode ser entendida por ser o local onde é armazenada
alguma informação utilizada na execução de um programa (CADENHEAD;
LEMAY, 2005). O valor de uma variável pode ser alterado em qualquer parte do
programa que ela for visível, isto é, se a variável estiver declarada em um método,
então ela é acessível somente nesse método.
Neste sentido, as variáveis primitivas podem ser compreendidas por

serem um conjunto de tipos de dados, sendo a base para armazenamento de
dados em um programa, sendo que a linguagem de programação Java possui oito
15
tipos de variáveis primitivas (FINEGAN; LIGUORI, 2018). É bom você lembrar

do tipo de dado aceito para armazenamento em cada tipo de dado primitivo,
facilitando o desenvolvimento de aplicações, sendo que alguns deles são mais
utilizados que outros.
De acordo com Finegan e Liguori (2018), o tipo de dado primitivo é o

formato de dado mais básico que um programa pode ter, e quando uma variável
de um tipo de dado primitivo é declarada, automaticamente ocorre a reserva de
um determinado número de bits na memória. Ainda segundo Finegan e Liguori
(2018), os oito tipos de dados primitivos são:
• boolean (booleano);
• char (caractere);
• byte (byte);
• short (inteiro curto);
• int (inteiro);
• long (inteiro longo);
• float (ponto flutuante);
• double (ponto flutuante de dupla precisão).
Dentre os tipos de dados primitivos, a Tabela 1 apresenta a quantidade de

memória utilizada por cada tipo numérico, assim como o valor mínimo e máximo
aceito por cada tipo.
TABELA 1 – TIPOS DE DADOS PRIMITIVOS
Tipo de Memória
Valor Mínimo Valor Máximo
Dado Consumida
byte 1 byte -128 127
short 2 bytes -32.768 32.767
int 4 bytes -2.147.483.648 2.147.483.647
long 8 bytes -9.223.372.036.854.775.808 9.223.372.036.854.775.807
float (6-7 dígitos) 4 bytes -3,4028E + 38 3,4028E + 38
double (15 dígitos 8 bytes -1,7976E + 308 1,7976E + 308
FONTE: O autor
Conforme você for analisando as atividades práticas deste livro, você vai
se familiarizando com os tipos primitivos de dados, anteriormente citados.
É importante ressaltar que quando uma variável for declarada do tipo

Integer (objeto do tipo inteiro), esta é diferente de uma variável do tipo int,
sendo que a variável do tipo Integer é um objeto que possui métodos, com isso
consome mais memória e seu uso é um pouco mais lento que pela utilização
de uma variável do tipo primitivo int. Analise a Figura 14, a qual apresenta as
propriedades de uma variável do tipo Integer.
16
FIGURA 14 – OBJETO INTEGER
FONTE: O autor
Além disso, quando se possui uma variável do tipo Integer e se quer

comparar com uma variável do tipo int, é necessário invocar o método “intValue()”
da variável do tipo Integer, conforme apresentado na Figura 15.
FIGURA 15 – VARIÁVEL DO TIPO INTEGER
FONTE: O autor
Variáveis podem ser declaradas dentro de um bloco de código-fonte,

porém, na linguagem de programação Java não é possível alterar o tipo de uma
variável (MATTOS, 2007). Se você criar uma variável do tipo int, por exemplo,
essa variável será desse tipo até o final da execução do bloco, neste sentido,
apenas pode receber valores numéricos do tipo inteiro, isto é, números inteiros.
Uma variável do tipo String pode receber caracteres alfanuméricos.
Para implementar a declaração de variáveis de tipos primitivos

na linguagem de programação Java, inicialmente é necessário declarar a
variável, isto é, definir seu tipo e nome, conforme apresentado na Figura
18, ou seja, int quantidadeComprada, por exemplo. Nesse caso, a variável
“quantidadeComprada” apenas pode armazenar dados do tipo inteiro, não
podendo receber numéricos decimais e nem alfanuméricos.
Conforme descrito anteriormente, variáveis primitivas não possuem

métodos para serem invocados, diferente de uma variável do tipo Integer, String,
Double, Boolean, entre outros tipos de classes, em que as variáveis se tornam
objetos.
17
10.2 CONSTANTES
Após você entender o que é uma variável e seus tipos primitivos, temos
o conceito chamado constante, que também é uma área de memória para
armazenar um dado, porém seu conteúdo, o dado armazenado nela, não é
permitido alterar durante a execução do programa (CADENHEAD; LEMAY,
2005). Para declarar uma constante, é utilizada a palavra reservada final para
indicar que a variável é inicializada uma única vez durante a execução da
aplicação, e após a palavra final é informado o tipo de dado, por último, o nome
da constante. Exemplo de declaração de constante:
final double valorPI = 3.1416F;
10.3 CRIANDO UMA APLICAÇÃO COM VARIÁVEIS

Antes de iniciarmos o estudo das variáveis primitivas, é importante você
conhecer a classe JoptionPane, a qual serve para apresentar caixas de diálogos
visuais. Para importar a biblioteca desta classe, basta utilizar o comando “import
javax.swing.JOptionPane” no início da classe, conforme exemplo apresentado na
Figura 16. A realização de importação de bibliotecas em Java está descrita mais
adiante, mas o importante é você saber que quando precisa de alguma biblioteca,
basta utilizar o comando import.
FIGURA 16 – CLASSE TESTE CRIADA PARA UTILIZAR BIBLIOTECA JOPTIONPANE
FONTE: O autor
A Figura 17 apresenta todos os passos que você aprendeu anteriormente

para compilar e depois executar uma classe em Java, utilizando o prompt de
comando do sistema operacional. Analise a tela “Mensagem”, apresentada
visualmente mais amigável.
18
FIGURA 17 – COMPILAÇÃO E EXECUÇÃO DE CLASSE TESTE UTILIZANDO JOPTIONPANE
FONTE: O autor
DICAS
Para saber mais sobre o JoptionPane, acesse o link https://www.tutorialspoint.

com/swing/swing_joptionpane.htm.
Agora que você já conheceu como utilizar a biblioteca JOptionPane,

criaremos uma classe utilizando variáveis de tipos primitivos, realizaremos
um cálculo simples e então apresentaremos na tela. Analise as linhas em que as
variáveis “quantidadeComprada”, “quantidadereservada” e “totalQuantidade”
estão declaradas, as quais já recebem valores fixos nas duas primeiras, e a terceira
variável primitiva recebe o resultado do cálculo das duas primeiras.
Não se preocupe com o cálculo realizado, o qual serve apenas para

demonstração da utilização das variáveis primitivas, pois os operadores serão
estudados a seguir. O importante nesse ponto é você compreender como declarar
variáveis.
FIGURA 18 – SOMA REALIZADA COM VARIÁVEIS PRIMITIVAS DO TIPO INT
FONTE: O autor
19
Após compilar e executar a classe apresentada na Figura 18, você pode

notar que foi apresentada a caixa de diálogo, apresentada à direita da Figura 19, em
que é apresentado o total da soma realizada, que nesse caso é 13, pois foi efetuada
a soma do valor das variáveis “quantidadeComprada” e “quantidadereservada”.
FIGURA 19 – EXECUÇÃO DE CLASSE COM SOMA DE VARIÁVEIS DO TIPO INT
FONTE: O autor
10.4 DECLARAÇÃO E UTILIZAÇÃO DE VARIÁVEIS DE

TIPOS DE DADOS PRIMITIVOS
Toda a variável na linguagem de programação Java precisa possuir um
tipo definido, o qual não pode ser alterado em tempo de execução. Além disso,
variáveis com tipos de dados primitivos possuem valores simples, e seus dados,
conforme o Subtópico 10.1, podem ser lógicos, numéricos e caracteres.
Assim, o tipo boolean é o tipo de dado primitivo que possui um valor

lógico, recebendo um único bit de informação, isto é, recebe os valores false
(falso) ou true (verdadeiro). O tipo de dado byte pode armazenar 8 bits de
informação, sendo um número inteiro entre -128 até 127. O tipo de dado short
pode armazenar inteiros de até 16 bits. O tipo de dado int, um dos mais utilizados,
pode armazenar inteiros de até 32 bits. O tipo de dado long, também muito
utilizado, pode armazenar até 64 bits de informação, e seu uso deve ser quando se
precisa armazenar números maiores ou menores do que os suportados pelo int. O
tipo de dado float, também é utilizado para números reais com precisão simples,
sendo que este tipo pode armazenar até 32 bits de informação de número real.
O tipo de dado double, utilizado para números reais com precisão dupla, pode
armazenar até 64 bits de informação de número real. Por último, o tipo de dado
char, utilizado para armazenar 16 bits de caracteres em formato UTF-16. Todos os
tipos primitivos possuem um exemplo de implementação na Figura 20.
20
FIGURA 20 – EXEMPLO DE USO DE VARIÁVEIS DE TIPOS PRIMITIVOS
FONTE: O autor
Na Figura 20 estão sendo apresentados simples exemplos de utilização

de variáveis de tipos primitivos, para que você compreenda como declarar ou
até utilizar esses tipos na linguagem de programação Java. Note que acima da
declaração de cada variável existe um comentário, utilizando as duas barras, o
que é explicado neste subtópico.
11 COMENTÁRIO DE LINHAS DE CÓDIGO-FONTE

Antes de prosseguirmos com pequenas implementações em Java, é
importante você conhecer como realizar comentários em código-fonte. Comentário
pode servir como uma descrição para que serve um determinado bloco ou linha
de código, isto é, podendo ser uma documentação do código. Muitas vezes,
comentários servem para desativar um determinado comando, uma linha de
código ou ainda um bloco inteiro (várias linhas) de um código-fonte, e ao invés
de excluir as linhas de código, se mantêm comentadas para se ter um histórico,
ou ainda para que o código possa ser habilitado novamente em um determinado
período.
21
Podemos comentar várias linhas de um código-fonte incluindo /* no início

do código, e então incluir */ no ponto final que se deseja comentar o código-fonte.
Para sua melhor compreensão, a Figura 21 apresenta um exemplo da utilização
do método de comentário único de várias linhas de um código-fonte, isto é,
utilizando /* código fonte */. No código-fonte desta figura, note que no início da
linha 6 foram incluídos os caracteres /* para iniciar o comentário de várias linhas,
e na linha 9 foram incluídos os caracteres */ que finaliza o comentário de várias
linhas.
FIGURA 21 – COMENTÁRIO ÚNICO DE VÁRIAS LINHAS
FONTE: O autor
Note que no exemplo da Figura 21 foi utilizada a aplicação de edição

de texto simples chamada Notepad++, equivalente ao bloco de notas, para
tornar mais visíveis as linhas comentadas. Você pode continuar utilizando o
bloco de notas padrão do sistema operacional, ou então utilizar um outro editor
aprimorado como este.
ATENCAO
Caso ainda não tenha instalado o editor Notepad++, você pode baixá-lo em
https://notepad-plus-plus.org/downloads/.
22
Outra forma de realizar um comentário na linguagem de programação

Java é através do comando // na frente de uma linha de comando, o qual indica que
todos os comandos, escritos depois de // desta linha estão comentados. Conforme
você pode analisar na linha 7 da Figura 22, apenas os comandos escritos após o //
estão comentados.
FIGURA 22 – COMENTÁRIO DE UMA ÚNICA LINHA
FONTE: O autor
Outra forma de realizar um comentário na linguagem de programação

Java é através do comando // na frente de uma linha de comando, o qual indica que
todos os comandos, escritos depois de // desta linha estão comentados. Conforme
você pôde analisar na linha 7 da Figura 22, apenas os comandos escritos após o //
estão comentados.
No entanto, se você quiser comentar a linha inteira, isto é, todos os

comandos escritos em uma determinada linha do código-fonte, basta incluir o //
no início da linha, conforme apresentado no início da linha 7 da Figura 23.
FIGURA 23 – COMENTÁRIO DE UMA ÚNICA LINHA
FONTE: O autor
12 OPERADORES DA LINGUAGEM
Na linguagem de programação Java, assim como em outras, existem os
operadores de atribuição, aritméticos, relacionais e lógicos, os quais permitem
o desenvolvimento de lógicas para atendimento de necessidades do software,
através de comparação entre valores de variáveis, por exemplo, ou cálculos
matemáticos.
12.1 OPERADOR DE ATRIBUIÇÃO

Esse tipo de operador serve para atribuir ou sobrescrever o valor de
uma variável ou atributo de uma classe. Na Figura 24, por exemplo, você pode
perceber que temos, na linha 8 do código, o recebimento (atribuição) do valor
de uma soma para a variável “totalQuantidade”. Neste sentido, o operador de
atribuição é o sinal = que indica a atribuição (recebimento de valor).
23
FIGURA 24 – OPERADOR DE ATRIBUIÇÃO
FONTE: O autor
12.2 OPERADORES ARITMÉTICOS

Os operadores aritméticos servem para a implementação de operações
matemáticas entre duas ou mais variáveis, desse modo retorna o resultado obtido no
cálculo. O Quadro 1 apresenta todos os operadores aritméticos da linguagem Java.
QUADRO 1 – OPERADORES ARITMÉTICOS
Descrição Operador
Operador de adição +
Operador de subtração -
Operador de multiplicação *
Operador de divisão /
Operador que retorna resto da divisão (módulo) %
FONTE: O autor
12.3 OPERADORES DE IGUALDADE

Operador de igualdade == verifica se o valor de uma variável ou expressão
à direita é igual ao valor de uma variável ou expressão à esquerda. Já o operador
!= verifica se uma variável ou expressão à direita é diferente do valor de uma
variável ou expressão a sua esquerda. Se a verificação for verdadeira, esses
operadores retornam o valor true.
FIGURA 25 – EXEMPLO DE UTILIZAÇÃO DE OPERADORES DE IGUALDADE
FONTE: O autor
24
12.4 OPERADORES RELACIONAIS

Os operadores relacionais analisam dois operandos (variáveis),
retornando se a condição do operador é verdadeira. Por exemplo, se temos uma
variável “variavelA” que possui valor 10 e outra variável “variavelB” que possui
valor 5, e implementamos a condição “variavelA > variavelB”, o retorno será true
(verdadeiro), pois estamos verificando se o valor da “variavelA” é maior que
valor da “variavelB”.
QUADRO 2 – OPERADORES RELACIONAIS
Maior que (utilizado para saber se um valor à esquerda é maior
>
que o outro à direita)
Maior ou igual que (utilizado para saber se um valor à esquerda é
>=
maior ou igual que o outro à direita)
Menor que (utilizado para saber se um valor à esquerda é menor
<
que o outro à direita)
Menor ou igual que (utilizado para saber se um valor à esquerda é
<=
menor ou igual que o outro à direita)
Diferente (utilizado para verificar se um valor à esquerda é
!=
diferente do valor à direita)
FONTE: O autor
Um exemplo para o uso de operadores relacionais é apresentado na

Figura 26, em que você pode notar na linha 9 a condição realizada, que no caso
do valor da variável “quantidadeComprada” ser menor que o valor da variável
“quantidadereservada”, então será impressa a mensagem no console.
FIGURA 26 – EXEMPLO DE UTILIZAÇÃO DE OPERADORES RELACIONAIS
FONTE: O autor
12.5 OPERADORES LÓGICOS

Os operadores lógicos permitem a criação de expressões lógicas
compostas, isto é, junta mais de uma expressão para realizar validações. Neste
caso, utilizamos as operações lógicas E, representadas pelo operador lógico && e
a operação lógica OU, representada pelo operador lógico ||.
25
QUADRO 3 – OPERADORES LÓGICOS
Utilizado quando a condição necessita que as duas expressões
&&
testadas sejam verdadeiras
Utilizado quando a condição necessita que uma das expressões
||
testadas sejam verdadeiras
FONTE: O autor
Na linha 9 do código-fonte apresentado na Figura 27 você pode notar

que foi utilizada a operação E através do operador lógico &&. Nesse código-
fonte o fluxo do programa executará a linha 10 somente se a primeira expressão
“quantidadeComprada == 10” for verdadeira e se a segunda expressão
“quantidadereservada == 5” também for verdadeira.
FIGURA 27 – EXEMPLO DE UTILIZAÇÃO DO OPERADOR LÓGICO &&
FONTE: O autor
12.6 OPERADORES DE INCREMENTO E DECREMENTO

Operador de incremento ++ serve para atribuir 1 (um) a uma variável,
não necessitando realizar o cálculo “variavel = variavel + 1”, por exemplo. Já o
operador de decremento -- é o contrário, servindo para reduzir 1 do valor de uma
variável.
FIGURA 28 – EXEMPLOS DE INCREMENTO E DECREMENTO
FONTE: O autor
26
RESUMO DO TÓPICO 1
Neste tópico, você aprendeu que:
• A linguagem de programação Java surgiu para resolver muitos problemas,

como gerenciamento de memória e facilidade de manutenção quebrando
código-fonte em classes, além da maioria das bibliotecas serem gratuitas.
• Uma das vantagens do Java é a possibilidade de rodar as aplicações

desenvolvidas com esta linguagem em diversos dispositivos de diferentes
sistemas operacionais.
• A JVM (Java Virtual Machine) realiza a execução de aplicações escritas na

linguagem de programação Java, interpretando o código-fonte compilado,
bytecode, transformando em um código de máquina compreendido pelo
sistema operacional.
• A JVM é a Máquina Virtual Java que interpreta o bytecode e apresenta ao sistema

operacional como linguagem de máquina para que ele entenda os comandos,
já a JRE é uma espécie de ambiente que executa aplicações desenvolvidas na
linguagem Java, possuindo uma JVM própria e bibliotecas necessárias.
• As variáveis primitivas em Java são um conjunto de tipos de dados, com mesmo

tipo de dado, por exemplo, somente números inteiros, sendo que o Java possui
oito tipos de variáveis primitivas.
• Os operadores de atribuição, aritméticos, de igualdade, relacionais, lógicos

e de incremento e decremento permitem o desenvolvimento de lógicas,
comparação entre valores, realização de cálculos matemáticos, atribuição de
valor para variáveis ou atributos, entre outras funcionalidades.
27
AUTOATIVIDADE
1 Desde as primeiras linguagens de programação até as linguagens atuais,

muitos conceitos básicos de programação permanecem, como controle de
fluxo, laços de repetição, apesar da sintaxe de uma linguagem para outra
ser diferente. Além disso, dependendo da linguagem de programação, o
sistema operacional não compreende o código-fonte escrito na linguagem.
Neste sentido, assinale a alternativa CORRETA referente à interpretação de
código pelo sistema operacional:
a) ( ) Código-fonte de um programa escrito em linguagem de programação

Java, após compilado, é gerado o código de máquina, sendo
compreendido pelo sistema operacional.
b) ( ) Após compilado o código-fonte de um programa escrito em Pascal, é
gerado o código de máquina que pode ser compreendido por qualquer
sistema operacional.
c) ( ) No caso da linguagem de programação Delphi, um único código-fonte
é escrito para rodar aplicações no sistema operacional Windows e no
Linux.
d) ( ) Código-fonte de um programa escrito em linguagem de programação
Java, após compilado, é gerado o bytecode e não código de máquina.
2 Nas linguagens de programação atuais, o sistema operacional não

compreende diretamente o código-fonte escrito na linguagem, pois nas
linguagens de alto nível, o código é escrito em uma linguagem compreendida
por humanos, que após compilação é gerado o código de máquina, binário
(zeros e uns). Neste sentido, assinale a alternativa CORRETA referente ao
entendimento de código-fonte Java pelo sistema operacional:
a) ( ) Bytecode é o código gerado compreendido diretamente pelo sistema

operacional Windows e Linux.
b) ( ) Bytecode é o código gerado compreendido pela JVM, gerado após
compilação de um código-fonte da linguagem de programação Java.
c) ( ) A JVM interpreta códigos-fonte binários gerados pela compilação de
programas escritos na linguagem de programação Java.
d) ( ) O JDK possui a finalidade de interpretar códigos-fonte binários gerados
pela linguagem de programação Java.
3 Assim como outras linguagens de programação, a linguagem Java possui

sua própria sintaxe, diferenciando-se das demais. Neste sentido, a maioria
das linguagens de alto nível possui comandos parecidos, isto é, comandos
similares, com mesma funcionalidade, porém com sintaxe diferente, como
o System.out.print, por exemplo, do Java. Referente ao objeto System.out,
assinale a alternativa CORRETA:
28
a) ( ) O método System.out.print permite imprimir String no terminal
pulando uma linha em cada impressão.
b) ( ) O método System.out.printf permite imprimir String no terminal
pulando uma linha em cada impressão.
c) ( ) Os métodos de impressão de Strings do objeto System.out podem ser
utilizados apenas no terminal do prompt de comando, mas na IDE
Eclipse não funciona.
d) ( ) Este objeto permite a impressão de Strings no console da IDE ou no
terminal.
4 Em linguagens de alto nível, no desenvolvimento de software, no contexto

da implementação de código-fonte, quando está sendo desenvolvido algum
cálculo normalmente são utilizadas variáveis para facilitar o trabalho de
desenvolvimento. Referente às variáveis nas linguagens de programação
Java, assinale a alternativa CORRETA:
a) ( ) Uma variável declarada com o tipo int pode receber um valor do tipo
char, desde que seu conteúdo seja um inteiro válido.
b) ( ) Uma variável declarada no início de uma classe apenas pode ter valor
atribuído neste ponto do código-fonte, sendo que nos demais locais seu
valor pode ser apenas utilizado.
c) ( ) Uma variável declarada com o tipo char pode receber um valor do tipo
char ou então do tipo int, pois seu tamanho é equivalente.
d) ( ) Uma variável declarada com o tipo int não pode receber um valor do
tipo double.
5 Assim como em outras linguagens de programação de alto nível, na

linguagem Java existem alguns operadores que auxiliam o desenvolvimento
de software, permitindo, por exemplo, a atribuição de valores a variáveis, ou
ainda de realizar comparações entre variáveis ou expressões, dentre outras
funcionalidades. Referente aos operadores na linguagem Java, assinale a
alternativa CORRETA:
a) ( ) É utilizado operador relacional quando se deseja implementar uma

condição em um programa para verificar se uma variável possui valor
maior que uma segunda variável.
b) ( ) É utilizado operador lógico quando se deseja implementar uma
condição em um programa para verificar se uma variável possui valor
maior que uma segunda variável.
c) ( ) Para incrementar o valor em uma variável do tipo int é obrigatória a
utilização do operador de incremento ++.
d) ( ) O sinal “/” indica a realização de um cálculo matemático conhecido por
multiplicação.
29
30
UNIDADE 1
TÓPICO 2
INSTALAÇÃO E CONFIGURAÇÃO DO AMBIENTE DE

DESENVOLVIMENTO
1 INTRODUÇÃO
Como vimos no Tópico 1, o Java pode ser entendido por ser uma
linguagem de programação, além de ser uma plataforma que roda aplicações
nesta linguagem, lançada pela Sun Microsystems na década de 1990. Atualmente,
existem muitas aplicações e sites, incluindo aplicativos de celular, que rodam
em diversos dispositivos diferentes, os quais necessitam do Java instalado no
dispositivo. Neste contexto, o Java é utilizado tanto em notebooks como em
datacenters, consoles de jogos, supercomputadores, smartphones e muitos outros
dispositivos, sendo utilizado em muitas aplicações de pequenos como de grande
porte.
Vimos também que em algumas linguagens de programação, como C e

Pascal, é necessário reescrever uma parte do código para executar em sistemas
operacionais diferentes, ou compilar de modo que o código-fonte gerado seja
diferente para a aplicação rodar em Linux e no Windows. Já em aplicações
desenvolvidas na linguagem de programação Java, isso não ocorre, pois nesta
existe a máquina virtual, a qual está dentro do JRE (Java Runtime Environment),
que além da máquina virtual possui bibliotecas (APIs). Neste sentido, a máquina
virtual do Java realiza a tradução entre o sistema operacional e a aplicação,
fazendo com que o sistema operacional entenda a aplicação.
Neste contexto, o JRE está incluso na instalação do JDK, sendo este o que
precisamos para desenvolvimento de aplicações por possuir todas as bibliotecas
necessárias, o qual está apresentado no Subtópico 2 deste tópico. Além do JDK,
este tópico apresenta os passos para baixar e configurar a IDE Eclipse, sistema
gerenciador de banco de dados MySQL, assim como o servlet container Tomcat
e, por último, a IDE NetBeans, a qual utilizaremos neste livro apenas para
desenvolvimento desktop.
31
NOTA
Neste tópico você compreenderá melhor o que se refere ao servlet container,

mas o importante é você saber que este é um minisservidor de aplicação.
Neste tópico também será apresentada a IDE NetBeans com detalhes.
Neste livro, a IDE Eclipse será mais utilizada para desenvolvimento dos
exercícios práticos, embora será possível também utilizar a IDE NetBeans, a qual
também é apresentada neste tópico. Uma IDE (Integrated Development Environment)
pode ser entendida por ser um ambiente integrado de desenvolvimento, com
várias ferramentas que auxiliam o desenvolvedor, como a facilidade de configurar
um banco de dados, por exemplo (FURGERI, 2015). Além disso, uma IDE de
desenvolvimento permite a alteração segura de nomes de classes, métodos,
variáveis, realizando refactoring, além de geração de código automaticamente,
buscar por referências a um determinado elemento selecionado, debug passo
a passo a um determinado código-fonte, entre outras facilidades. Todas essas
vantagens em utilizar uma IDE faz com que o desenvolvedor aproveite seu tempo
nas implementações de lógicas para funcionamento das aplicações, motivando seu
uso em projetos de pequeno, médio e grande porte, auxiliando a produtividade.
E
IMPORTANT
O termo refactoring de código-fonte pode ser entendido por alterar o código-

fonte sem afetar as funcionalidades, quando necessário, por exemplo, alterar o nome de
um método e consequentemente em todos os locais que o invocam.
2 INSTALAÇÃO DO JAVA DEVELOPMENT KIT (JDK)

Para desenvolver as aplicações Java apresentadas e estudadas neste livro,
você precisará instalar o JDK (Java Development Kit) em seu computador, assim
todas as ferramentas utilizadas funcionarão adequadamente.
O JRE (Java Runtime Environment) torna possível a execução de

programas desenvolvidos na linguagem de programação Java, porém, para o
desenvolvimento de aplicações Java, é necessário ter instalado no computador
32
TÓPICO 2 | INSTALAÇÃO E CONFIGURAÇÃO DO AMBIENTE DE DESENVOLVIMENTO
o JDK (Java Development Kit), o qual possui ferramentas de desenvolvimento,

como o compilador Java, além de um privado JRE, isto é, um JRE somente para o
desenvolvimento (FRIESEN, 2010).
O JDK é disponibilizado pela Oracle, sendo um conjunto de bibliotecas

(APIs) que permitem a criação de jogos e programas na linguagem de programação
Java. Ao ser instalado o JDK, caso não existir no computador, a JVM (Máquina
Virtual Java) é também instalada.
Para a instalação, basta baixar o executável instalador. Para isso, em uma

ferramenta de busca, como o Google, procure por “java JDK 8 download”, ou
então procure direto no site da Oracle em https://www.oracle.com/. Optamos por
baixar a versão 8, pois utilizaremos apenas alguns recursos deste, embora você
possa baixar a versão mais recente, se desejar.
Ao selecionar o link de download será aberta a página de download do

site da Oracle, conforme a Figura 29.
FIGURA 29 – PÁGINA DE DOWNLOAD DO JDK
FONTE: O autor
Para uma melhor eficiência, selecione a versão correta, 32 bits ou 64 bits,

de acordo com o sistema operacional instalado em seu computador. Caso tenha
Sistema Operacional 64 bits, você também pode instalar a versão 32 bits, porém
não é o melhor para a eficiência.
Rolando a tela mais para baixo, você deve selecionar a opção para aceitar a
licença do Java, que neste caso, em inglês, é a opção “Accept License Agreement”,
conforme ilustrado na Figura 30.
33
FIGURA 30 – OPÇÕES PARA DOWNLOAD DO JDK
FONTE: O autor
Ao clicar na opção correta para download, você precisará realizar acesso

com login e senha, e caso não o possua, bastará realizar um breve cadastro e
gratuito, selecionando a opção “Criar Conta”. Após o cadastro, você deve realizar
a confirmação do e-mail, clicando no link enviado para ele. A partir daqui, você
está apto a realizar o download, bastando acessar novamente a tela de download
e efetuar o login, que automaticamente o download do JDK será iniciado.
Após ter realizado o download, basta executar o arquivo de instalação,

confirmando sua execução, caso seja solicitado.
FIGURA 31 – ARQUIVO INSTALADOR DO JDK BAIXADO
FONTE: O autor
Ao executar o instalador, uma tela será apresentada, na qual basta

pressionar o botão “Next”, conforme Figura 32:
34
FIGURA 32 – INSTALADOR DO JDK EXECUTADO
FONTE: O autor
O mesmo será para as demais telas que forem apresentadas, bastando

prosseguir com a instalação selecionando sempre o botão “Next”.
Se preferir, você pode alterar a pasta de destino da instalação do JDK,

conforme apresenta a Figura 33, bastando pressionar o botão “Change”, porém
o ideal é deixar o diretório padrão, pois este será instalado no diretório “Java”,
junto ao JRE, instalado a seguir, assim como outras versões do Java, se estiverem
instaladas.
FIGURA 33 – INSTALADOR DO JDK EXECUTADO
FONTE: O autor
35
Ao prosseguir com a instalação, na tela ilustrada na Figura 33 será

exibido o progresso, o que pode demorar alguns minutos, dependendo da
configuração de seu computador. Durante a instalação, várias telas serão
apresentadas, bastando confirmar e pressionar o botão “Next”, sendo que na
última tela será apresentada a barra de progresso para acompanhamento do
percentual de instalação, passo que pode demorar alguns minutos.
Após a conclusão da instalação será apresentada a tela de finalização,

bastando selecionar a opção “Close”, significando que seu computador está
quase pronto para o desenvolvimento de sistemas utilizando a linguagem de
programação Java.
Se você observar o diretório “home” do JDK, ilustrado na Figura 34, neste

existem vários arquivos importantes, e existem três subdiretórios principais,
sendo um deles o diretório “bin”, o qual possui ferramentas do JDK, como o
compilador Java chamado “javac”, por exemplo (FRIESEN, 2010). Ainda segundo
Friesen (2010), o subdiretório “jre”, dentro do JDK, possui um JRE privado para
que aplicações rodando com o JDK o utilizem, por último existe o subdiretório
“lib”, no qual são encontrados vários arquivos (bibliotecas) que são utilizados
pelas ferramentas do JDK.
FIGURA 34 – DIRETÓRIO DA INSTALAÇÃO DO JDK
FONTE: O autor
Os subtópicos seguintes apresentam a instalação e a configuração do

sistema gerenciador de banco de dados Mysql, o qual utilizaremos na Unidade
3 deste livro, assim como o ambiente de desenvolvimento Eclipse NetBeans e o
servlet container Tomcat.
36
3 INSTALAÇÃO DO SISTEMA GERENCIADOR DE BANCO DE

DADOS MYSQL
Atualmente, existem vários sistemas gerenciadores de bancos de dados

disponíveis para serem utilizados, mas os mais utilizados são os baseados na
linguagem SQL (Structured Query Language), como o MySQL, o Oracle e o SQL
Server (JOBSTRAIBIZER, 2010).
DICAS
Embora utilizaremos neste livro apenas alguns comandos básicos de banco de

dados, os quais serão explicados, acesse o seguinte link para conhecer conceitos básicos
sobre bancos de dados: https://www.devmedia.com.br/conceitos-fundamentais-de-banco
-de-dados/1649.
3.1 CONHECENDO O MYSQL
TUROS
ESTUDOS FU
Neste contexto, utilizaremos o sistema gerenciador de banco de dados MySQL

na Unidade 3 deste livro, porém o ideal é deixarmos o computador com ele instalado
e configurado. Desenvolveremos, também na Unidade 3, aplicações que realizarão
persistência em banco de dados, neste sentido, será apresentada neste livro a configuração
de projetos para acessar o MySQL.
O MySQL é um sistema gerenciador de banco de dados (SGBD) relacional

que possui licença open source e pode ser utilizado para trabalhar com aplicações
de pequeno, médio e grande porte (MILANI, 2006). Ainda de acordo com Milani
(2006), esse sistema gerenciador de banco de dados possui as características
importantíssimas que um grande sistema gerenciador de banco de dados possui,
podendo concorrer com seus concorrentes, como o Oracle, por exemplo.
37
Na década de 1990, David Axmark, Allan Larson e Michael “Monty”

Widenius tentaram utilizar a API mSQL para as aplicações e tabelas de dados que
estavam utilizando, porém devido à lentidão do acesso acabaram desenvolvendo
uma nova API nas linguagens C e C++, resultando no MySQL (MILANI, 2006).
Ainda segundo Milani (2006), após a utilização desta nova API chamada MySQL,
os três desenvolvedores e criadores desta fundaram a empresa MySQLAB com o
objetivo de realizar manutenção nesta API.
Em 2008, a Sun Microsystems comprou o MySQLAB e seus códigos-fonte,

logo depois iniciaram-se as negociações para a compra da Sun Microsystems,
incluindo o MySQL e todos os seus códigos-fonte, pela empresa Oracle, fabricante
de um dos maiores Sistemas Gerenciadores de Banco de Dados, o Oracle (MILANI,
2006).
O MySQL surgiu como um simples sistema para armazenar dados brutos,

sendo aperfeiçoado, o que o tornou um dos SGBDs (Sistemas Gerenciadores de
Banco de Dados) mais utilizados do mundo (JOBSTRAIBIZER, 2010). Atualmente,
o MySQL possui funcionalidades comparáveis com a do SGBD Oracle, como
procedures, pesquisas por textos em qualquer tipo de campo, triggers, entre
outros (JOBSTRAIBIZER, 2010).
Todas essas funcionalidades, além de gerenciar a estrutura de registros,

gerenciar espaço para novos registros a serem criados, são conceitos vinculados a
sistemas gerenciadores de banco de dados ou SGBDs (CARVALHO, 2015).
O MySQL é um banco de dados relacional, assim como o Oracle e outros

concorrentes, os quais são constituídos de campos, colunas, linhas (tuplas) e
tabelas. Ainda nas palavras de Carvalho (2015), podemos definir esses elementos
por:
• Campo: é o espaço para armazenamento de um dado.

• Coluna: são os registros de um determinado campo (todos com mesmo tipo de
dado).
• Linha ou tupla: é a linha de um registro que possui um conjunto de campos.
• Tabela: pode ser descrito por ser o conjunto de linhas, campos e colunas.
38
FIGURA 35 – EXEMPLO DE TABELA
FONTE: Carvalho (2015, s.p.)
Por fim, banco de dados relacional pode ser entendido por um conjunto
de tabelas relacionadas (CARVALHO, 2015).
DICAS
Você pode entender melhor o banco de dados relacionais através do acesso

ao artigo: https://www.devmedia.com.br/bancos-de-dados-relacionais/20401.
3.2 INSTALAÇÃO DE CONFIGURAÇÃO DO MYSQL

Para realizar o download do instalador do MySQL, você deve acessar
o site https://dev.mysql.com/downloads, conforme ilustra a Figura 36, e nesta
página selecione o link “MySQL Community Server”.
39
FIGURA 36 – SITE PARA DOWNLOAD DO MYSQL
FONTE: O autor
Ao ser direcionado para a página de download do instalador, você deve

selecionar o banner que possui a descrição “Mysql Installer”, o qual efetua o
download do arquivo instalador e não apenas o executável.
FIGURA 37 – BANNER PARA REALIZAR O DOWNLOAD DO MYSQL
FONTE: O autor
Com o mesmo usuário criado para baixar o JDK é possível utilizá-lo para
realizar o download do MySQL. Após acesso com o usuário, uma tela parecida
com a da figura a seguir é apresentada, bastando você selecionar uma das opções
desejadas, podendo ser a mais completa do instalador, a qual possui alguns
recursos e aplicações utilitárias a mais, ou a versão com tamanho menor, que
possui unicamente o instalador do MySQL.
40
FIGURA 38 – VERSÕES DO MYSQL PARA SEREM BAIXADOS
FONTE: O autor
Após o arquivo de instalação ter sido baixado, conforme ilustrado na

Figura 39, basta executá-lo.
FIGURA 39 – INSTALADOR DO MYSQL BAIXADO
FONTE: O autor
Após sua execução, basta seguir com a instalação sempre pressionando o

botão “Next” ou “Próximo”. Inicialmente, dependendo da configuração de seu
computador, pode ser apresentada uma tela com uma barra de progresso, o que
pode demorar alguns minutos. Após pressionada a opção “Next”, será carregada
uma tela na qual você pode deixar selecionada a opção “Developer Default”, o
que significa que é a configuração de desenvolvedor, e então novamente pressione
a opção “Next”.
Se você optou por baixar a versão mais completa, será apresentada uma
tela em que pode ser selecionada a opção MySQL apenas, assim como outros
aplicativos que o complementam. Após a instalação do MySQL concluída,
será apresentada uma tela, ilustrada na Figura 40, em que é possível alterar as
configurações de execução do Mysql, como a porta que ele utilizará, por exemplo.
O ideal é deixar a configuração padrão, mas caso a porta 3306 já esteja sendo
utilizada por outra aplicação, então você pode alterar para uma de sua preferência,
lembrando que quando for configurada a conexão do banco de dados no projeto
Java, você deverá utilizar essa mesma porta.
41
FIGURA 40 – CONFIGURAÇÃO DO MYSQL
FONTE: O autor
Após pressionado o botão “Next” na tela da Figura 40, será apresentada a

tela ilustrada na Figura 41, na qual é realizada a definição da senha a ser utilizada
na conexão com o MySQL. Nessa tela, informe o valor “root” para os campos
senha e confirmação de senha. Utilizaremos essa senha mais adiante, embora você
possa criar a senha de sua preferência, mas que neste caso você deverá lembrar
para configuração da aplicação que desenvolveremos.
FIGURA 41 – CONFIGURAÇÃO DA SENHA DE ACESSO AO MYSQL
FONTE: O autor
42
Após pressionar o botão “Next” da tela ilustrada na Figura 41, basta

finalizar a configuração na tela seguinte que o MySQL estará configurado e
pronto para utilização. Após os passos citados, basta realizar um teste de conexão
com o MySQL, abrindo a aplicação “Mysql Command Line Client”, conforme
apresentado na Figura 42.
FIGURA 42 – ACESSO AO MYSQL
FONTE: O autor
Ao selecionar a opção “Mysql Command Line Client”, será aberta

uma tela, ilustrada na Figura 43, bastando informar a senha que configuramos
anteriormente, isto é, a senha “root”, e pressione a tecla ENTER.
FIGURA 43 – ACESSO AO MYSQL
FONTE: O autor
Após informada a senha e pressionado o botão “ENTER” do teclado, será

apresentada a tela ilustrada na Figura 44, na qual o usuário já está conectado no
MySQL, bastando realizar os comandos SQL conforme desejado.
FIGURA 44 – ACESSO AO MYSQL EFETUADO
FONTE: O autor
43
Neste caso, digite a linha de código “CREATE DATABASE UNIASSELVI;”

para criarmos o banco de dados “Uniasselvi”, o qual utilizaremos na Unidade 3
deste livro para desenvolvimento de aplicações com persistência no banco de
dados e, ao final, pressione a tecla “ENTER”.
FIGURA 45 – CRIANDO BANCO DE DADOS NO MYSQL
FONTE: O autor
Com o comando executado, nosso banco de dados “Uniasselvi” foi criado

com sucesso, o qual está pronto para implementarmos aplicações para realização
de persistência neste.
4 AMBIENTE DE DESENVOLVIMENTO ECLIPSE

O Eclipse é um ambiente de desenvolvimento de software que permite
a implementação de software em várias linguagens, não somente na linguagem
Java. A IDE (Integrated Development Environment) Eclipse é controlada por uma
organização chamada Eclipse Foundation, e esta IDE é utilizada por milhares de
desenvolvedores em todo o mundo (BURNETTE, 2005). Neste sentido, o Eclipse
pode ser entendido pode ser uma IDE de desenvolvimento de programas em
Java, assim como para outras linguagens de programação, como C, Cobol, PHP,
entre outras (FRIESEN, 2010).
Segundo Burnette (2005), existe uma configuração mínima recomendada

do computador para que o Eclipse funcione sem problemas, a qual está
apresentada na Figura 46.
44
FIGURA 46 – REQUISITOS DE COMPUTADOR PARA INSTALAÇÃO
FONTE: Burnette (2005, p. 2)
No subtópico Instalação e Configuração do Eclipse, a seguir, são

apresentados os passos para a instalação e configuração deste ambiente de
desenvolvimento. Ressaltando que é essencial já ter sido instalado o JDK versão
8 ou superior, pois essa instalação é necessária para que o Eclipse funcione
adequadamente, e caso você ainda não o instalou, sigas os passos do primeiro
subtópico deste tópico, o qual orienta o processo.
4.1 INSTALAÇÃO E CONFIGURAÇÃO DO ECLIPSE

Para realizar o download do Eclipse, acesse o site https://www.eclipse.
org/ e então selecione a opção “Get Eclipse IDE”, conforme apresentado na Figura
47, ou então procure o link de download. Existem várias opções para realizar o
download do Eclipse, sendo versões para Sistemas Operacionais 32 ou 64 bits,
versões para Sistema Operacional Windows, Linux, entre outros (BURNETTE,
2005). Para Burnette (2005), é possível baixar e instalar ou então apenas um
arquivo compactado, que após baixado, basta descompactar no diretório de sua
preferência.
FIGURA 47 – LOCAL DO SITE COM OPÇÃO DE DOWNLOAD
FONTE: O autor
45
Uma das formas de realizar o download do Eclipse é clicar no link

“Download Packages”, na tela ilustrada na figura anterior. Depois desse passo,
basta selecionar a versão desejada, e caso seu sistema operacional seja 64 bits, o
ideal é baixar a versão 64, pois torna a utilização do ambiente de desenvolvimento
Eclipse mais rápido, evitando travamentos. Vale lembrar que o ideal é realizar
o download da versão mais completa, conforme apresentado a seguir, em que
estão disponíveis vários frameworks e APIs disponíveis. Neste contexto, não é
necessário baixar bibliotecas manualmente para se ter acesso ao desenvolvimento
de alguma funcionalidade específica.
FIGURA 48 – OPÇÕES DE DOWNLOAD DO ECLIPSE
FONTE: O autor
Após o arquivo ter sido baixado, conforme ilustrado na Figura 49, basta
descompactar em seu diretório preferido, para que então possamos configurar o
Eclipse.
FIGURA 49 – ARQUIVO COMPACTADO DO ECLIPSE BAIXADO
FONTE: O autor
46
Após descompactado, clique com o botão direito do mouse sobre o

executável do Eclipse, ícone roxo abaixo apresentado na Figura 50, e então
selecione a opção para criar um ícone na área de trabalho, o que facilita seu acesso
para que você não tenha que acessar o diretório descompactado sempre que for
desenvolver.
FIGURA 50 – DIRETÓRIO DO ECLIPSE DESCOMPACTADO
FONTE: O autor
E
IMPORTANT
Caso você tenha Sistema Operacional Linux instalado em seu computador,

utilize o seguinte artigo, que apresenta passo a passo a instalação do Eclipse, manualmente,
que serve para várias versões do SO: https://www.edivaldobrito.com.br/eclipse-no-linux/.
4.2 CONHECENDO O ECLIPSE

A primeira vez que o Eclipse for iniciado, será solicitado o diretório
desejado para ser criado o workplace (diretório de trabalho), isto é, onde serão
criados os projetos (BURNETTE, 2005). Conforme Burnette (2005), o workspace é o
diretório onde tanto os códigos-fonte de projetos quanto arquivos de configurações
são armazenados. Neste caso, você pode criar uma workspace para cada projeto,
caso desejar, mas para facilitar seu trabalho com as atividades deste livro, utilize
apenas uma. Você pode criar um diretório chamado “work” dentro do diretório
onde foi descompactado o Eclipse, ou em qualquer outro que você desejar.
47
FIGURA 51 – ECLIPSE SOLICITANDO O WORKSPACE
FONTE: O autor
Após pressionado o botão “Launch” é aberta a tela inicial do Eclipse, na

qual, quando aberta pela primeira vez, será exibida uma mensagem de boas-
vindas (BURNETTE, 2005). A Figura 52 ilustra a tela do Eclipse após o fechamento
da mensagem de boas-vindas.
FIGURA 52 – APRESENTAÇÃO DA TELA DO ECLIPSE AO SER INICIADO
FONTE: O autor
48
Agora que você já visualizou a tela inicial do Eclipse, nos aprofundaremos

um pouco nele, entendendo algumas de suas telas que facilitam o trabalho de
desenvolvimento. Para isso, analise a tela apresentada na Figura 53, na qual
foram enumeradas as principais partes da tela para visualizações.
FIGURA 53 – APRESENTAÇÃO BÁSICA DE OPÇÕES DO ECLIPSE
FONTE: Burnette (2005, p. 7)
4.2.1 Janelas/Visualizações (Views)

Essa janela do Eclipse permite analisar uma lista de arquivos de um
projeto que esteja aberto e possui várias formas diferentes de visualizar os
arquivos de um projeto. A lista de janelas mais utilizadas está no menu do
Eclipse Window, selecionando a opção Show View, na qual você pode escolher
várias formas de views, desde o servidor de aplicação, console, entre outros.
Caso selecionada a opção “Other”, conforme ilustrado na Figura 54, será aberta
uma janela para selecionar várias outras views a serem exibidas.
49
FIGURA 54 – OPÇÃO PARA ABRIR NOVAS VIEWS
FONTE: O autor
4.2.2 Editor
Essa janela apresenta o editor de textos, isto é, nesse campo são escritos
os códigos-fonte da aplicação, desde códigos na linguagem de programação Java,
assim como HTML, Javascript e qualquer outra linguagem sendo programada,
ou ainda arquivos XML, XHTML, entre outros (BURNETTE, 2005).
FIGURA 55 – TELA DO EDITOR DE CÓDIGO-FONTE DO ECLIPSE
FONTE: O autor
50
4.2.3 Barra de Menus (Menu Bar)

Os principais menus são os do topo, menu horizontal, conforme
apresentado na Figura 56, nos quais é possível ajustar configurações, como cores,
versões do Java a serem utilizadas para compilar e executar aplicações, abrir
arquivos, entre muitas outras configurações.
FIGURA 56 – TELA COM MENUS HORIZONTAIS DO ECLIPSE
FONTE: O autor
4.2.4 Barra de Ferramentas (Toolbar)

É um conjunto de botões muito utilizados no momento de
desenvolvimento, funcionam como acesso mais fácil a essas funcionalidades,
os quais aparecem normalmente no topo do Eclipse, abaixo da barra de menus
horizontal, anteriormente descrita (BURNETTE, 2005). Esses botões são muito
utilizados no momento de desenvolvimento, pois para subir uma aplicação no
servidor de aplicação, basta clicar no botão de executar ou debugar.
FIGURA 57 – TELA COM TOOLBAR DO ECLIPSE
FONTE: O autor
5 INSTALAÇÃO E CONFIGURAÇÃO DO SERVIDOR DE

APLICAÇÃO TOMCAT NO ECLIPSE
O Apache Tomcat é um servlet container, minisservidor de aplicação que
gerencia e executa aplicações que utilizam a tecnologia Servlet, neste sentido,
o Tomcat pode ser considerado um servidor de aplicações Java EE (Enterprise
Edition), suportando a execução de várias tecnologias web como Servlets, JNDI
Resources, JDBC DataSources e JSP (BRITTAIN; DARWIN, 2008).
51
5.1 APPLICATION SERVER E SERVLET CONTAINER

Um servidor de aplicação (application server) pode ser descrito como
um software que disponibiliza serviços e bibliotecas para servir às aplicações
desenvolvidas, isto é, um sistema web, por exemplo, após ser desenvolvido é
colocado dentro do diretório de um servidor de aplicação, disponibilizando-o
na web (BRITO, 2016). Ainda segundo Brito (2016), o servlet container pode ser
entendido como sendo um minisservidor de aplicação, para aplicações mais
leves e ágeis, porém não possuem todas as funcionalidades disponibilizadas
pelos servidores de aplicação. O Jboss é um exemplo de servidor de aplicação,
enquanto o Tomcat é um servlet container.
5.2 CONHECENDO MELHOR O TOMCAT

Segundo Brittain e Darwin (2008), o primeiro servidor web da Sun
Microsystems foi o Java Web Server (JWS), o qual era comercializado, sendo um
dos servidores web mais acessíveis do que os concorrentes, isso na época em que
os servlets estavam no início de seu desenvolvimento. Ainda segundo Brittain
e Darwin (2008), em 1996 vários servlets containers tornaram-se populares,
sendo que o Apache’s JServ e o CERN foram os dois servlets containers mais
antigos sendo open source. A partir de 1997, a Sun liberou a primeira versão
do servlet container que suportava JSP e que trabalhava em HTTP 1.0, sendo
disponibilizado gratuitamente para testes e experimentos, o que teve sucesso
para o desenvolvimento e melhorias de servlet containers comerciais (BRITTAIN;
DARWIN, 2008).
Em 1998, a Sun anunciou a nova especificação para o JSP, a qual possuía

o build Java Servlet API, que permitia o desenvolvimento de aplicações web
dinâmicas mais rapidamente, sendo este lançamento chamado de Java Servlet
Web Development Kit (JSWDK) (BRITTAIN; DARWIN, 2008). Segundo Brittain
e Darwin (2008), após o lançamento da versão 2.1 do JSWDK, James Duncan, da
Sun, trabalhou para reescrever essa ferramenta, e implementou um novo servlet
container chamado Tomcat, lançamento este com a versão 3.0, sendo desenvolvido
com novo código-fonte e não com o do JWS.
Atualmente, o Tomcat é um dos servlets containers mais utilizados, o

qual é distribuído gratuitamente e é uma referência para implementação do Java
Servlet Spacification (BRITTAIN; DARWIN, 2008).
52
5.3 BAIXANDO O TOMCAT

Para finalizarmos a configuração do ambiente de desenvolvimento
Eclipse, acesse o site http://tomcat.apache.org/ e baixe o instalador ou o arquivo
compactado do servidor de aplicação Tomcat. Na seção download, clique no
link da versão do Tomcat desejada, preferencialmente a versão 9 ou superior,
conforme Figura 58, então bastará descompactar no diretório de sua preferência.
FIGURA 58 – TELA COM ARQUIVO DO TOMCAT
FONTE: O autor
5.4 CONFIGURAÇÃO DO TOMCAT NO ECLIPSE

Após descompactar o Tomcat em algum diretório de sua preferência,
acesse o Eclipse, selecione o menu “Windows” e a opção “Preferences”, conforme
ilustrado à esquerda da Figura 59. Na janela que abrir, imagem direita da Figura
59, selecione o item “Server” na lista, e então a opção “Runtime Envoironment”.
FIGURA 59 – TELA PARA CONFIGURAÇÃO DOTOMCAT NO ECLIPSE
FONTE: O autor
Clique no botão “Add” para que você possa importar o Tomcat no Eclipse
e selecione a versão do Tomcat que você baixou, que no nosso caso é a versão 9,
53
FIGURA 60 – TELA PARA CONFIGURAÇÃO DO TOMCAT NO ECLIPSE
FONTE: O autor
Pressione o botão “Next”, então informe o caminho do Tomcat que você

descompactou em seu computador, conforme ilustrado na Figura 61 e pressione
o botão “Finish”.
FIGURA 61 – TELA PARA CONFIGURAÇÃO DO TOMCAT NO ECLIPSE (2)
FONTE: O autor
54
Após fechar a tela ilustrada na Figura 61, pressione o botão “Apply and
Close” na tela que estiver aberta. Com este passo, o Tomcat está configurado no
Eclipse, bastando adicioná-lo ao clicar com o botão direito do mouse dentro da
guia “Servers”, apresentado na Figura 62, selecionar as opções “New” e então
selecionar a opção “Server”.
FONTE: O autor
Após o passo anterior, será apresentada a tela com a lista de servidores

disponíveis para adicionar ao workspace atual, bastando selecionar o servidor
adicionado, “Tomcat v9.0 Server”, conforme ilustrado na Figura 63.
FONTE: O autor
55
O novo servidor de aplicação será adicionado na guia “Servers”, conforme

FIGURA 64 – SERVIDOR TOMCAT ADICIONADO A GUIA “SERVERS”
FONTE: O autor
Para testar a execução do servidor de aplicação Tomcat, clique sobre o

servidor adicionado com o botão direito do mouse e selecione a opção “Start”,
conforme ilustrado na imagem direita da Figura 64. Em alguns casos, pode ser
apresentada uma mensagem do Firewall solicitando a permissão de execução,
bastando aceitá-lo. Após essa confirmação, se ela for solicitada, teremos a
informação no log de que o serviço está ativo, como pode ser analisada a última
linha do log, apresentado à esquerda da Figura 65.
FIGURA 65 – LOG DE EXECUÇÃO DO TOMCAT
FONTE: O autor
56
No entanto, caso a porta 8080 esteja sendo utilizada em seu computador

por outra aplicação, será apresentada uma mensagem parecida com a que está
sendo ilustrada à direita da Figura 66. Caso ocorrer esse erro, você deve alterar
a porta que o Tomcat utiliza para uma porta disponível, para isso você deve
realizar um duplo clique sobre o servidor Tomcat, que então será aberta uma tela
que possui a imagem ilustrada na Figura 66, bastando alterar a porta utilizada no
campo “Port Name” HTTP/1.1.
FIGURA 66 – ALTERAÇÃO DE PORTA UTILIZADA PELO TOMCAT
FONTE: O autor
6 CRIANDO UMA APLICAÇÃO PARA EXECUTAR NO TOMCAT

Para a criação de um novo projeto web e dinâmico no Eclipse, basta
clicar com o botão direito do mouse dentro da view “Project Explorer” e então
selecionar a opção “New”, por último a opção “Dynamic Web Project”, conforme
apresentado na imagem esquerda da Figura 67. Após esse passo, será aberta a tela
ilustrada na imagem direita da Figura 67, na qual basta informar o nome desejado
para a nova aplicação.
Nessa mesma tela, no campo “Location” é apresentado o diretório onde

o projeto será criado, podendo ser alterado de acordo com sua preferência. Após
informado o nome da aplicação, basta selecionar o botão “Finish” para que a
aplicação seja criada.
57
FIGURA 67 – CRIAÇÃO DE NOVO PROJETO WEB NO ECLIPSE
FONTE: O autor
Após o passo anterior, o projeto é criado no diretório selecionado e

apresentado na view “Project Explorer”, conforme ilustrado na imagem esquerda
da Figura 68. Neste sentido, podemos criar uma página HTML para testar se o
servidor de aplicação está rodando corretamente. Para isso, clique com o botão
direito do mouse sobre a pasta “WebContent” da aplicação criada, conforme
ilustrado na imagem direita da Figura 68, e então selecione a opção “HTML File”.
FIGURA 68 – PROJETO DE APLICAÇÃO WEB CRIADA
FONTE: O autor
58
Informe então o nome do arquivo HTML como sendo “index.html” e

confirme a criação desta página. A Figura 69 apresenta a página criada dentro
da pasta do projeto “WebContent”, podendo ser publicada a aplicação para ser
acessada pelo navegador de internet. Como essa página não possui nenhuma
informação a ser exibida, então entre as tags “body” digite o texto “Olá mundo!”,
FIGURA 69 – PÁGINA HTML CRIADA
FONTE: O autor
Conforme ilustrado na Figura 70, sobre o servidor de aplicação Tomcat,

clique com o botão direito do mouse e selecione a opção “Add and Remove”, e
então arraste a aplicação criada, “MinhaAplicacao”, para a direita. Esse processo
inclui a aplicação criada para ser publicada no Tomcat, e com isso ser acessada
do navegador de internet.
FONTE: O autor
59
Por fim, basta selecionar a opção “Start” do Tomcat, e então no navegador

de internet de sua preferência acessar a aplicação através da URL “localhost:8080/
MinhaAplicacao”, conforme ilustrado na Figura 71. Ressaltando que caso você
tenha alterado a porta de utilização do Tomcat nas configurações dele, você
deve utilizar a porta configurada. Observe que o nosso texto “Olá mundo” é
apresentado na tela, o que indica que o Tomcat está funcionando corretamente, e
como consequência, nossa aplicação está no ar.
FONTE: O autor
7 AMBIENTE DE DESENVOLVIMENTO NETBEANS

Existem diversos ambientes de desenvolvimento para a linguagem de
programação Java, porém as IDEs Eclipse e NetBeans são as mais utilizadas
(FURGERI, 2015). Neste sentido, para os iniciantes na linguagem, iniciar o
desenvolvimento com uma dessas duas ferramentas é aceitável, pois além de
serem gratuitas, existem vários artigos e blogs com dicas sobre sua utilização, o
que pode facilitar o desenvolvimento.
No Subtópico 4 (Instalação e configuração do ambiente de desenvolvimento

Eclipse) deste tópico foi apresentada a IDE Eclipse, desde sua instalação até a
definição das principais telas e funcionalidades. Neste subtópico são apresentados
alguns detalhes importantes para você conhecer um pouco a IDE NetBeans.
NetBeans é o primeiro e um dos ambientes de desenvolvimento Java mais

famosos e populares, gratuito e fácil de utilizar, o qual, assim como outros, possui
um ambiente moderno e fácil de utilizar (BONDREAU et al., 2003).
Para Bondreau et al. (2003), o NetBeans é uma ferramenta de código aberto,

permitindo que qualquer pessoa possa alterar algum módulo para desenvolver
alguma funcionalidade nova e melhorá-la. Ainda de acordo com os autores, o
NetBeans permite a geração automática de JavaBeans de forma fácil, e oferece,
dentre outras, as seguintes características:
60
• permite configurar cores para códigos-fonte Java, XML, HTML e para outras
linguagens;
• componente para verificar o código-fonte;
• componente para navegação da aplicação;
• ferramenta de Debbug;
• integração com controlador de versão, como o CVS;
• diálogos que auxiliam o desenvolvedor em seu trabalho.
Ainda segundo Bondreau et al. (2003), o NetBeans é uma ferramenta

completa, porém possui os requisitos mínimos de hardware para que funcione
adequadamente sem travamentos, os quais são apresentados na Figura 72.
FIGURA 72 – REQUISITOS MÍNIMOS PARA RODAR O NETBEANS
FONTE: Bondreau et al. (2003, p. 1-2)
No próximo subtópico são apresentados os passos para instalar e

configurar o ambiente NetBeans, porém é pré-requisito já estar instalado o JDK,
conforme apresentado no Subtópico 2 – Instalação do Java Development Kit
(JDK).
7.1 INSTALAÇÃO E CONFIGURAÇÃO DO NETBEANS

Para realizar o download do NetBeans, acesse o site https://netbeans.org/
e então selecione a opção “Download”. Após a abertura da página de download,
conforme apresentado na Figura 73, selecione o botão “Download” da opção
“Apache NetBeans 11 feature update 1 (NB 11.1)”, ou uma versão completa para
Java mais recente disponibilizada.
61
FIGURA 73 – OPÇÃO PARA DOWNLOAD DO NETBEANS
FONTE: O autor
Após o passo anterior, será aberta a página para selecionar o link para
download, na qual é possível selecionar a opção “netbeans-11.1-bin.zip”, que
possui o executável, ou “netbeans-11.1-source.zip”, que possui também os
códigos-fonte. Para a utilização deste livro, você pode selecionar a opção “bin”,
apenas para executarmos o NetBeans.
FIGURA 74 – ARQUIVO BAIXADO DO NETBEANS
FONTE: O autor
Após descompactar o arquivo, dentro do diretório raiz do NetBeans

acesse o diretório “bin”, no qual existem dois arquivos executáveis, um para
Sistema Operacional 32 bits e outro para 64 bits, neste caso, execute conforme
o Sistema Operacional de seu computador. Assim, é aceitável que você crie
um atalho para o executável desejado na área de trabalho de seu computador,
facilitando o acesso ao NetBeans.
7.2 CONFIGURAÇÃO DO NETBEANS

O NetBeans apresenta várias configurações para adequar ao estilo do
desenvolvedor ou, ainda, para configurar ferramentas externas como browser,
por exemplo (MYATT, 2007). Para chegar a essas configurações, no menu superior
horizontal selecione “Tools” e então a opção “Options”, conforme ilustrado na
Figura 75.
62
FIGURA 75 – MENU PARA ACESSO ÀS OPÇÕES DO NETBEANS
FONTE: O autor
Ao ser selecionada a opção “Options”, ilustrada na Figura 75, será aberta

a tela ilustrada na Figura 76, na qual, após selecionada a aba “General”, é possível
alterar o navegador de internet padrão que executa aplicações web desenvolvidas
no NetBeans. Neste sentido, para selecionar outro navegador de internet, como
Firefox ou Chrome, basta selecionar a opção desejada no campo “Web Browser”.
FIGURA 76 – ALTERAÇÃO DE NAVEGADOR PADRÃO DO NETBEANS
FONTE: O autor
63
Outra configuração do NetBeans muito utilizada pelos desenvolvedores

é a alteração de cores e fontes padrões, pois há quem prefira desenvolver código-
fonte com o fundo da tela preto e a fonte em branco, por exemplo, enquanto
outras pessoas preferem o fundo branco e a fonte em preto. Para acessar essa
configuração, basta selecionar a aba “Fonts & Colors”, conforme ilustrada na
Figura 77.
FIGURA 77 – ALTERAÇÃO DE CORES DO NETBEANS
FONTE: O autor
Na mesma tela ilustrada nas Figuras 76 e 77, é possível ainda visualizar as

teclas de atalho, assim como configurá-las, bastando selecionar a aba “Keymap”.
Existem muitas outras configurações que facilitam ou tornam o ambiente mais
agradável ao desenvolvedor, dependendo das preferências de cada um.
64
7.3 JANELAS PARA VISUALIZAÇÕES NO NETBEANS

O NetBeans possui algumas janelas para visualizações, cada uma com sua
funcionalidade específica, isto é, apresentando detalhes específicos que auxiliam
o desenvolvedor (MYATT, 2007). Ainda segundo Myatt (2007), existem várias
janelas com diferentes visualizações, sendo as principais:
• Janela de Projetos (Projects Window): são apresentados todos os projetos

atualmente abertos, separando os arquivos por projetos. Para habilitar essa
forma de visualização, basta pressionar as teclas CTRL mais 1.
• Janela de Arquivos (Files Window): apresenta os arquivos de projetos abertos
de uma forma que possa ser mais familiar. Para habilitar essa forma de
visualização, basta pressionar as teclas CTRL mais 2.
• Janela tempo de Execução (Runtime Window): apresenta os servidores HTTP,
bancos de dados, web services, entre outros. Para habilitar essa forma de
visualização, basta pressionar as teclas CTRL mais 5.
FIGURA 78 – VISUALIZAÇÕES DE ARQUIVOS E PROJETOS NO NETBEANS
FONTE: O autor
DICAS
Para conhecer mais detalhes sobre o NetBeans, acesse o artigo https://www.

devmedia.com.br/explorando-o-netbeans-7-0-artigo-java-magazine-91/21121. Se seu
computador possui o Sistema Operacional Linux instalado, então acesse o artigo http://
www.devfuria.com.br/linux/instalando-netbeans/ para analisar como realizar a instalação
do NetBeans em seu Sistema Operacional.
65
RESUMO DO TÓPICO 2
• Para que o ambiente de desenvolvimento funcione corretamente, deve ser

instalado inicialmente o JDK, o qual possui todos os recursos necessários,
como o JRE e o compilador Java.
• O MySQL foi iniciado como um simples sistema para armazenamento de dados,

foi aperfeiçoado e passou a ser um dos SGBDs mais utilizados no mundo.
• O MySQL é um sistema gerenciador de banco de dados que possui muitos

recursos disponíveis, além de ser open source, o qual serve para utilização por
aplicações de pequeno, médio e grande porte.
• IDE (Integrated Development Environment) é um ambiente de desenvolvimento

de software que possui muitas vantagens em relação a um editor de texto
comum, tais como: permitir alterar códigos-fonte com maior facilidade, realizar
o refactoring, alterar nomes de classes e arquivos de projetos, realizar debbug
de aplicações, entre outras facilidades.
• O Eclipse e o NetBeans são os ambientes de desenvolvimento (IDEs) de software

mais utilizados no mundo, principalmente para a linguagem de programação
Java, embora eles suportem o desenvolvimento de outras linguagens de
programação.
• O Tomcat é um servlet container e não um servidor de aplicação completo, pois

possui apenas alguns recursos de um servidor de aplicação. Seu objetivo é
disponibilizar aplicações na web.
66
AUTOATIVIDADE
1 Através da linguagem de programação Java é possível desenvolver aplicações

de pequeno, médio e grande porte, podendo ser desde aplicativos para
dispositivos móveis, sistemas web e sites, assim como aplicações desktop.
Neste contexto, assinale a alternativa CORRETA que explica os conceitos do
Java:
a) ( ) Para executar aplicações desenvolvidas com a linguagem de

programação Java, é necessário ter somente o JDK instalado.
b) ( ) Para executar aplicações desenvolvidas com a linguagem de
programação Java, é necessário ter apenas o JRE instalado.
c) ( ) O JRE possui as bibliotecas necessárias para o desenvolvimento de
aplicações desenvolvidas na linguagem de programação Java.
d) ( ) Não é possível ter instalados no mesmo computador o JRE e o JDK, pois
ocorrem conflitos na execução de aplicações Java.
2 O desenvolvimento de aplicações na linguagem de programação Java pode

ser realizado em diversos ambientes, e dependendo do tipo de aplicação,
como para aplicativos Android, pode ser utilizado o Android Studio ou
ainda o Eclipse para sistemas web. Neste contexto, classifique V para as
sentenças verdadeiras e F para as falsas:
( ) IDE de desenvolvimento é um ambiente integrado que disponibiliza várias

facilidades para o desenvolvedor, como a funcionalidade de refactoring,
por exemplo.
( ) O Eclipse é um ambiente de desenvolvimento completo, o qual permite
desenvolvimento de aplicações para web, apenas, enquanto o NetBeans
permite apenas o desenvolvimento de aplicações desktop.
( ) Para configurar o ambiente Eclipse em um computador, basta baixar o
pacote que possui um arquivo executável, não sendo necessária sua
instalação.
( ) O Tomcat é um servidor de aplicação completo, o qual pode ser configurado
dentro do Eclipse para rodar aplicações web e com isso disponibilizar a
aplicação na web.
Assinale a alternativa que apresenta a sequência CORRETA:

a) ( ) V – F – V – F.
b) ( ) F – V – V – F.
c) ( ) F – F – V – V.
d) ( ) V – V – F – F.
67
3 Para o desenvolvimento de aplicações utilizando a linguagem de
programação Java podem ser utilizados diferentes ambientes de
desenvolvimento, como o Eclipse e o NetBeans. Além disso, pode ser
utilizado qualquer banco de dados relacional, como o Oracle e MySQL,
e estes são configuráveis na IDE de desenvolvimento para permitir a
persistência dos dados. Neste contexto, assinale a alternativa CORRETA:
a) ( ) O MySQL surgiu, inicialmente, como um sistema gerenciador de banco

de dados, desenvolvido pela Oracle.
b) ( ) O MySQL, diferente do banco de dados Oracle, não possui campos e
colunas, sendo utilizado o SQL para acesso a seus dados.
c) ( ) Para a criação de um novo banco de dados no sistema gerenciador de
banco de dados MySQL, basta executar o comando “CREATE TABLE
NOME_BANCO”.
d) ( ) O MySQL é um sistema gerenciador de banco de dados relacional,
o qual pode ser utilizado para desenvolvimento de aplicações de
pequeno, médio e grande porte, sendo código aberto.
4 Para o desenvolvimento de um novo software, muitos podem ser os

requisitos necessários, tanto funcionais quanto não funcionais. Dentre os
requisitos não funcionais, o sistema gerenciador de banco de dados a ser
utilizado é um deles. Neste contexto, assinale a alternativa CORRETA:
a) ( ) Para o desenvolvimento de software na linguagem de programação Java,

podem ser utilizados sistemas gerenciadores de banco de dados relacionais.
b) ( ) O MySQL não possui campos e colunas, e neste é utilizado apenas o
SQL para acesso a seus dados.
c) ( ) O comando “CREATE TABLE NOME_BANCO” serve para a criação
de um novo banco de dados no MySQL.
d) ( ) O SGBD MySQL é um sistema gerenciador de banco de dados
orientados a objetos, podendo ser utilizado para desenvolvimento de
aplicações de grande porte.
5 São muitos os requisitos funcionais e não funcionais para o

desenvolvimento de um novo software, assim como para a manutenção de
novas funcionalidades para um software já existente, neste sentido, uma
ferramenta que facilite o trabalho de desenvolvimento é muito requisitada.
Dentre as IDEs de desenvolvimento, assinale a alternativa CORRETA:
a) ( ) Para o desenvolvimento de sistemas web na linguagem de programação

Java, é necessária apenas a utilização do NetBeans.
b) ( ) Para o desenvolvimento de sistemas web ou mesmo desktop na
linguagem de programação Java, é possível utilizar tanto o NetBeans
quanto o Eclipse, pois ambos atendem à necessidade.
c) ( ) O Eclipse é a primeira IDE que surgiu para o desenvolvimento de
aplicações Java.
d) ( ) O NetBeans pode ser executado apenas em sistemas operacionais que
utilizam a plataforma 64 bits.
68
UNIDADE 1
TÓPICO 3
CASTING, CONTROLE DE FLUXO E LAÇOS DE REPETIÇÃO
1 INTRODUÇÃO
Nos tópicos anteriores, você aprendeu os conceitos básicos sobre a
linguagem de programação Java, como a sua história, versões, o que é a JVM, JDK
e a JRE. Você aprendeu também o que são variáveis primitivas, como declará-las
e utilizá-las, além dos operadores utilizados nessa linguagem. Outros assuntos
importantes que você aprendeu foi como instalar e configurar o ambiente de
desenvolvimento, baixando a IDE Eclipse e NetBeans, instalar e configurar
o sistema gerenciador de banco de dados MySQL, assim como o servidor de
aplicação Tomcat, os quais utilizaremos nos exercícios práticos deste livro.
No Subtópico 2 deste tópico será estudado o conceito de casting, muitas

vezes utilizado em determinadas situações do desenvolvimento de software. Já
no Subtópico 3 serão apresentados os comandos de controle de fluxo e os laços
de repetição, os quais existem em outras linguagens de programação com sintaxe
parecida.
A partir deste tópico, todos os exemplos e atividades práticas são

desenvolvidas na IDE Eclipse, e o ideal é você também utilizar esta ferramenta,
pois desta forma você aprenderá a manuseá-la. Caso você ainda não tenha
baixado e configurado o Eclipse em seu computador, leia o tópico anterior para
realizar a configuração necessária para o desenvolvimento.
2 CASTING: CONVERSÕES ENTRE VARIÁVEIS DE TIPOS DE

DADOS DIFERENTES
Em determinadas situações é necessário atribuir valores a uma variável
de um determinado tipo, porém o valor é incompatível com o tipo de dados
da variável. Um exemplo é a conversão de um número real, o qual pode ser
representado por uma variável do tipo double e atribuir o valor desta a uma
variável do tipo int, sendo apresentado erro de que não é possível converter de
double para int, conforme ilustrado na Figura 79.
69
FIGURA 79 – ERRO SENDO APRESENTADO NA ATRIBUIÇÃO DE VALOR DE VARIÁVEL

DOUBLE PARA INT
FONTE: O autor
Na implementação de um código-fonte que possui atribuição do valor

de uma variável do tipo int para uma variável do tipo double, o código-fonte
é compilado e executado perfeitamente, sem erros. Isso ocorre porque o tipo
double pode guardar um número com ou sem ponto flutuante, isto é, pode ter
ou não decimal. A Figura 80 apresenta essa situação, em que o valor da variável
“valorInteiro” é atribuído para a variável “valor” do tipo double.
FIGURA 80 – EXEMPLO DE CONVERSÃO DE VARIÁVEL INT PARA DOUBLE
FONTE: O autor
Existem casos em que é necessário que um número real, com decimal,

deve ser arredondado para um número inteiro, e no Java isso é possível, bastando
utilizar o método que torna o número moldado (casted) para um número inteiro,
e esse processo é chamado de casting, conforme apresentado na Figura 81.
FIGURA 81 – PROCESSO DE CASTING DE DOUBLE PARA INTEIRO
FONTE: O autor
70
TÓPICO 3 | CASTING, CONTROLE DE FLUXO E LAÇOS DE REPETIÇÃO
Outra situação normalmente utilizada é a conversão de uma variável

do tipo String, classe que recebe qualquer caractere alfanumérico, para uma
variável do tipo int ou double, por exemplo, porém nesses casos é obrigatório
que o conteúdo da variável do tipo String tenha um número válido. No caso da
conversão do valor “125,99” de uma variável do tipo String para uma variável
do tipo int, por exemplo, ocorrerá erro de conversão, pois o tipo int não suporta
decimal.
FIGURA 82 – CONVERSÃO DE VARIÁVEL DO TIPO STRING PARA INT
FONTE: O autor
Você pode analisar a Figura 82, a qual apresenta a conversão do valor de

uma variável do tipo String para uma variável do tipo int. Perceba que o conteúdo
da variável String não é um número inteiro válido, pois possui decimal, porém o
erro ocorrerá em tempo de execução, conforme apresentado na Figura 83.
FIGURA 83 – ERRO NA CONVERSÃO DE UM CONTEÚDO DO TIPO STRING PARA INT NÃO VÁLIDO
FONTE: O autor
Agora, analise a Figura 84, a qual possui implementada na linha 6

a inicialização da variável do tipo String recebendo um valor inteiro “12599”.
Perceba que este é um valor inteiro válido, assim, ao ser executada a classe, será
impresso o valor da variável do tipo int.
FIGURA 84 – CONVERSÃO DE UM CONTEÚDO STRING PARA INTEIRO VÁLIDO
FONTE: O autor
71
2.1 TIPOS DE DADOS QUE SÃO OBJETOS

Com exceção dos tipos de dados primitivos, todos os demais tipos são
objetos, como o tipo String apresentado na Figura 82, sempre iniciando com
a primeira letra maiúscula. Esses tipos, como a String, por exemplo, é uma
instância da classe java.lang.String, esses objetos devem ser declarados e também
instanciados.
Ressaltando que como são objetos, esses tipos de dados possuem métodos,
os quais podem ser utilizados para resolver muitos problemas, como o método
“Integer.parseint()”, apresentado na Figura 84, por exemplo. Esses tipos serão
tratados mais adiante, mas o importante neste momento é você saber que a
variável String, assim como Integer, Double, Boolean, entre outras, recebem o
mesmo valor das variáveis primitivas, porém são objetos que possuem métodos.
3 COMANDOS DE CONTROLE DE FLUXO E LAÇOS DE

REPETIÇÃO
Os comandos de controle de fluxo são condicionais, isto é, permitem a
inclusão de regras que causam condições em um programa, fazendo com que
o fluxo do programa execute um determinado comando ou outro, tanto na
linguagem de programação Java como em qualquer outra. Os laços de repetição,
por sua vez, permitem que um determinado comando ou trecho de código seja
executado a quantidade de vezes que foi programado para realizar, ou ainda de
acordo com uma condição, ser executado até que a condição não seja mais válida.
Os exemplos práticos desenvolvidos neste tópico utilizam a IDE Eclipse,

e para criar um novo projeto você deve clicar com o botão direito do mouse sobre
a guia “Project Explorer”, selecionar a opção “New” e então a opção “Project”,
conforme apresentado na Figura 85. Na janela que abrir, informe o nome do
projeto e então confirme a sua criação.
FIGURA 85 – EXEMPLO DE CRIAÇÃO DE PROJETO DESKTOP NO ECLIPSE
FONTE: O autor
72
Para a criação de uma classe, sobre a pasta src (source) que está dentro do
projeto criado, clique com o botão direito do mouse sobre esta e selecione a opção
“New”, e então a opção “Class”, informando o nome da classe na tela que abrir.
3.1 COMANDO CONDICIONAL IF

Assim como em qualquer outra linguagem de programação, o comando If
possui a função de verificar se uma determinada condição é verdadeira ou falsa.
Esse comando pode ser utilizado para verificar, por exemplo, se o valor de uma
determinada variável for maior que o de uma segunda variável, ou ainda verificar
se uma variável do tipo String é igual a outra do mesmo tipo, entre outras.
Nesses casos, estamos implementando uma condição booleana, a qual

pode ser entendida por ser qualquer expressão que possua como retorno o valor
true (verdadeiro) ou false (falso), sendo utilizados os operadores <, >, <=, >= além
de outros.
FIGURA 86 – EXEMPLO DE COMANDO IF
FONTE: O autor
Neste sentido, você pode analisar o código-fonte da Figura 86, o qual

apresenta um exemplo desse tipo de comando condicional ou comando de fluxo.
Perceba que no caso desse código-fonte, como o valor da variável “valorProduto”
é maior que o valor da variável “valorDesconto”, então a mensagem não será
impressa na tela. Se fosse o contrário, seria impressa a mensagem na tela, pois a
condição do comando if seria verdadeira.
No caso do comando if, temos apenas uma condição simples, e o fluxo do

programa executará a impressão da mensagem na tela apenas se a condição for
verdadeira, caso contrário, não executará mais nada.
73
FIGURA 87 – EXEMPLO DE VALIDAÇÃO REALIZADA COM VALORES
FONTE: O autor
Analise agora a Figura 87, na qual temos um comando de fluxo um pouco

mais complexo, em que temos o comando else, o qual serve justamente para
apresentar um fluxo secundário caso a primeira condição não for verdadeira.
Neste caso, se o valor da variável “valorProduto” for menor ou igual ao valor
da variável “valorDesconto”, então será executado o comando da linha 11,
imprimindo a segunda mensagem.
Além disso, é possível concatenar expressões booleanas através de

operadores lógicos "&&" assim como o "||", apresentados no Quadro 1. Você
pode analisar o exemplo na Figura 88, em que na linha 8 temos o operador || que
significa OU, isto é, será executado o comando da linha 9 se o valor da variável
“valorDesconto” for maior que a variável “valorProduto” ou se o valor da
variável “valorProduto” for igual a zero. Neste caso, se uma das duas expressões
for verdadeira, então ocorre a execução da linha 9.
FIGURA 88 – EXEMPLO DE EXPRESSÃO BOOLEANA UTILIZANDO OPERADORES LÓGICOS
FONTE: O autor
74
3.2 COMANDO SWITCH

O comando switch é uma estrutura também muito utilizada no
desenvolvimento de software. Essa estrutura de controle de fluxo verifica uma
variável, e de acordo com seu valor, executa um trecho de código conforme o seu
case, isto é, de acordo com o valor da variável de controle é ativado um de seus
cases. Neste sentido, os cases podem ser entendidos por serem possibilidades de
fluxos e resultados obtidos pelo comando switch. A opção “default” do comando
switch é executada quando nenhuma opção anterior foi aceita. Esse comando é
como se fossem vários comandos “if” e “else”.
FIGURA 89 – EXEMPLO DE USO DO COMANDO SWITCH
FONTE: O autor
3.3 LAÇO DE REPETIÇÃO WHILE

O comando while é utilizado para realizar um laço de repetição (loop), ou
seja, executar a repetição algumas vezes de um trecho de código implementado
dentro dele. Neste sentido, o trecho de código subordinado ao comando while é
repetido enquanto uma determinada condição (expressão) for verdadeira, sendo
finalizada a repetição quando a condição for falsa.
Você pode entender melhor como funciona o comando while analisando

a Figura 89, na qual você pode notar na lista 8 a condição do comando while,
que enquanto o valor da variável “valorJuros” for menor que o valor da variável
“valorProduto”, a repetição continua, isto é, a execução dos comandos das linhas
9 e 10 continua.
75
Note ainda, na Figura 90, que na linha 10 é utilizado o comando “+=”, o

qual soma ao valor da variável “valorJuros” o valor do cálculo, isto é, a variável
“valorJuros” recebe seu próprio valor mais o valor do cálculo, o que vai somando
até que seu valor seja maior ou igual ao valor da variável “valorProduto”.
FIGURA 90 – EXEMPLO DE EXECUÇÃO DO COMANDO WHILE
FONTE: O autor
Na parte inferior da Figura 90, você pode notar a saída no console

referente à impressão gerada pela linha 9 do código. Lembre-se de implementar
esses códigos-fonte e testá-los através do modo debug no Eclipse, realizando a
execução passo a passo e em cada linha para você entender melhor a lógica e a
funcionalidade.
76
3.4 LAÇO DE REPETIÇÃO FOR

O comando de repetição for é muito utilizado, seu objetivo é o mesmo
do comando while, sendo a repetição de um trecho de código subordinado a
este comando de acordo com uma condição verdadeira. No entanto, no caso do
comando for, um código é executado um determinado número de vezes, isto
é, a quantidade de vezes é definida. Além disso, o comando for permite que se
declare a variável de controle nele próprio, tornando o código mais legível.
Você pode compreender melhor o comando for analisando a Figura 91, na

qual a linha 7 apresenta a utilização do comando for, sendo declarada a variável
de controle i, e iterada até seu valor ser menor que 8, caindo fora a execução.
Perceba ainda, na linha 8, o comando i++, o qual serve para atribuir 1 (um) ao
valor da variável i, isto é, a cada loop do comando for é incrementado 1 ao valor
da variável i. O comando “i++” é igual ao “i = i + 1”, incrementando mais um.
FIGURA 91 – EXEMPLO DE COMANDO FOR
FONTE: O autor
3.5 CONTROLE BREAK E CONTINUE EM LAÇOS DE

REPETIÇÃO
Conforme você aprendeu com os laços de repetição, temos mais um
detalhe importante para eles, os comandos break e continue.
Neste sentido, o comando break permite forçar o encerramento imediato de

um loop, tanto para o comando while como para o comando for, sendo ignorados
a expressão condicional e qualquer trecho de código após o comando break, não
sendo mais executado o laço de repetição. Ressaltando que essa interrupção
ocorre para o comando for em que o comando break está sendo executado, isto
é, se tivermos dois comandos for, um dentro do outro, e o comando break estiver
dentro do comando for interno, apenas a execução do comando for interno será
abortado.
77
FIGURA 92 – EXEMPLO DE COMANDO BREAK NO LAÇO DE REPETIÇÃO FOR
FONTE: O autor
Analise o código-fonte da Figura 92, o qual possui o comando break na

linha 9, neste caso, quando a variável “i” tiver valor igual a 2, então o laço de
repetição será encerrado. Já na Figura 93, você pode analisar o comando break na
linha 11 do código-fonte, e neste caso, quando a variável “valorJuros” tiver valor
igual a “45.69”, então o laço de repetição será encerrado.
FIGURA 93 – EXEMPLO DE COMANDO BREAK NO LAÇO DE REPETIÇÃO WHILE
FONTE: O autor
78
O comando continue realiza a interrupção de uma iteração em um comando

de repetição (loop), sendo que nesse comando, se uma condição for verdadeira,
o laço de repetição continua, porém com a próxima execução, ignorando o trecho
de código seguinte ao comando continue, realizando o próximo loop.
Conforme apresentado na Figura 94, você pode analisar o comando

continue na linha 9, em que quando o valor da variável “i” tiver valor igual a “3”,
a execução atual é abortada e é realizado o próximo loop.
FIGURA 94 – EXEMPLO DE COMANDO CONTINUE NO LAÇO DE REPETIÇÃO FOR
FONTE: O autor
Para o comando while, o funcionamento do comando continue é o mesmo,

sendo a execução atual abortada e realizado o próximo loop, isto é, a próxima
iteração é realizada normalmente, desde que a condição que execute o comando
continue não seja verdadeira novamente.
3.6 ESCOPO DE VARIÁVEIS

Na linguagem de programação Java, as variáveis podem ser declaradas
em qualquer ponto da aplicação, porém, dependendo de onde elas são criadas,
podem ser utilizadas apenas em um determinado ponto de aplicação, ou então em
todo algoritmo ou classe. Neste sentido, o escopo da variável pode ser entendido
por ser o trecho de código onde a variável foi criada, e neste ponto é possível
utilizá-la.
79
FIGURA 95 – EXEMPLOS DE ESCOPOS DE VARIÁVEIS
FONTE: O autor
Na Figura 95 são apresentados dois tipos de escopos de variáveis, um

deles você pode analisar nas linhas 5 e 6 do código-fonte, que neste caso, as duas
variáveis “valorProduto” e “valorDesconto” são acessíveis em todo o método.
Outro escopo de variável você pode analisar nas linhas 10 e 11, em que as variáveis
“quantidadeEstoque” e “quantidadeComprada” são acessíveis apenas dentro do
próprio bloco de código que elas estão criadas, isto é, a partir da linha 13 até o
fechamento do bloco “}”.
Entenda um bloco de código como sendo o código que está dentro das
chaves, como a abertura de chaves no final da linha 8 do código da Figura 95
que inicia um bloco, sendo fechado na linha 19 com o fechamento das chaves,
antes do comando else. Você pode analisar a Figura 95, na qual entre as linhas 8
e 10 existe um bloco de código do comando if dentro de um bloco de código do
comando for.
4 DESENVOLVIMENTO PRÁTICO DE PROGRAMAS EM JAVA

Neste subtópico são apresentados exemplos práticos para você entender
melhor como desenvolver pequenas aplicações na linguagem de programação
Java utilizando os comandos condicionais e os laços de repetição que você
aprendeu no subtópico anterior. Não esqueça de desenvolver esses exemplos
práticos para melhor compreender os comandos da linguagem, conhecimento
essencial para você prosseguir para a próxima unidade deste livro. Ressaltando
que quando utilizada a biblioteca JoptionPane é necessário realizar a importação
80
através do comando “import javax.swing.JOptionPane;”, conforme você já

aprendeu. Um detalhe importante é que ao utilizar o JoptionPane para entrada
de dados, deve-se ter o cuidado de informar o tipo de dado correto, por exemplo,
quando uma variável do tipo double estiver esperando um valor, terá que ser
informado um número válido, caso contrário, ocorrerão erros, embora esse
problema seja tratável, mas nesses exemplos, para não complicarmos seu estudo,
informe números válidos.
4.1 EXEMPLO PRÁTICO 1

Implemente uma classe na qual seja declarada uma constante do tipo
int, podendo ser definido um valor inteiro qualquer, de preferência no máximo
até 100, para que a execução não demore muito. Com essa constante declarada,
crie um laço de repetição que possua quantidade de iterações limitada ao valor
máximo da constante, imprimindo os números pares no console com a seguinte
mensagem: “Número par: NUMERO”, sendo “NUMERO” o número realizado
na iteração.
FIGURA 96 – EXEMPLO DE LOOP VALIDANDO SE O NÚMERO É PAR
FONTE: O autor
Analisando o código-fonte, você pode notar a constante criada chamada

de “quantidade”, a qual possui o valor 50, sendo este utilizado como limitador
do comando “for” (laço de repetição). Analise o comando condicional “if”, no
qual foi utilizado o comando operador “%”, módulo, que significa que o valor
da variável “i” é dividido por 2, e se o resto da divisão for zero, então o valor da
variável “i” é par, caso contrário, se o resto da divisão for maior que zero, é ímpar.
81

Implemente uma classe na qual seja solicitado o nome de um aluno, sendo
armazenado em uma variável. Logo após, devem ser solicitadas as quatro notas
do aluno, e ao final do programa deve ser realizado o cálculo da média das notas
(soma das quatro notas dividido por 4). No final, o programa deve apresentar
uma mensagem dizendo se o aluno foi aprovado ou reprovado, seguindo a regra
da média 7 para aprovação. Utilize a bilbioteca JoptionPane para solicitar dados
ao usuário e para apresentar a mensagem final de aprovação.
FIGURA 97 – EXEMPLO PRÁTICO DE PROGRAMA COM ENTRADA DE TEXTO E VALIDAÇÃO
FONTE: O autor
82
Analise o código-fonte da resolução do exercício anterior, em que você

pôde perceber que foram criadas quatro variáveis (nota1, nota2, nota3 e nota4) para
receberem as notas informadas pelo usuário. Além disso, note que para realizar a
conversão das notas, tipo String, recebidas pelo usuário, para as variáveis de tipo
double, foi utilizado “Double.parseDouble”, porém como para essa conversão é
necessário que seja utilizada a separação de milhar com “ponto”, foi utilizado o
método “replace”, que serve para sobrescrever o caractere do primeiro parâmetro
com o do segundo. Neste caso, no comando “replace” foi passado por parâmetro
a vírgula para ser sobrescrita por ponto, pois caso o usuário informar um número
com separação de decimal utilizando vírgula, para que não haja erro na conversão
para double, o replace atualiza a vírgula por ponto.
Agora veremos outra forma de desenvolver esse exercício prático sem a

necessidade de criar uma variável para cada nota informada pelo usuário. Analise
o código-fonte a seguir, você pode notar que foi utilizado um laço de repetição
com o comando “for”, em que foi definida a iteração em 4 vezes (variável “i”).
Neste caso, dentro do laço de repetição, para cada iteração é solicitada a nota ao
usuário, sendo esta somada à variável “media”, que após o laço de repetição é
realizado o cálculo da média. Ao final é apresentado o resultado ao usuário.
FIGURA 98 – EXEMPLO PRÁTICO DE PROGRAMA COM ENTRADA DE TEXTO EM

LAÇO DE REPETIÇÃO
FONTE: O autor
83

Implemente uma classe na qual sejam solicitadas ao usuário as notas de
vários alunos, com objetivo de realizar a média da nota de uma turma. Neste
sentido, a requisição das notas deve estar em um laço de repetição, e o programa
apenas pode finalizar a solicitação de notas ao usuário quando for selecionado o
valor 9999, que então calcula a média das notas e apresenta uma mensagem ao
usuário. Utilize a biblioteca JoptionPane para solicitar dados ao usuário e para
apresentar a mensagem com a média das notas.
FIGURA 99 – EXEMPLO PRÁTICO DE PROGRAMA COM ENTRADA DE TEXTO EM

LAÇO DE REPETIÇÃO WHILE
FONTE: O autor
Analise a lógica do comando “while”, o qual funciona da seguinte forma:

enquanto o valor da variável “nota” for zero ou diferente de “9999” continua
solicitando dados ao usuário. Note também que a variável “quantidadeNotas”
apenas é incrementada se o valor de “nota” for diferente de 9999.
84
LEITURA COMPLEMENTAR
ENTENDA A IMPORTÂNCIA DE SE APRENDER JAVA
Em todas as linguagens de programação existentes cada uma se destaca

por suas aplicações, suas utilidades específicas e suas ferramentas, que atendem
aos desenvolvedores da melhor maneira possível. Java se destaca por ser
uma linguagem que serve a diversas demandas do mercado, tem sua solidez
confirmada pelas décadas em que se mantém no topo e não para de evoluir.
Tanto para quem já tem uma base de conhecimento em lógica de

programação e já domina outras linguagens, quanto para quem está iniciando sua
trilha em programação e desenvolvimento, aprender Java é muito importante.
Quer entender o porquê? Acompanhe nosso post que vamos explicar!
Java está em absolutamente tudo
Java é uma linguagem de programação que está em toda parte, seja no seu
PC, no seu smartphone, em veículos, em pequenos robôs de automação residencial
e em máquinas industriais. Em todos os lugares existe um dispositivo rodando
Java. Muitos programadores escolhem aprendê-la justamente porque é comum
que as empresas a prefiram para um desenvolvimento novo em detrimento de
outras linguagens.
A programação é um campo muito grande e não é fácil sobreviver por

muito tempo e continuar se fortalecendo. Podendo ser comparado ao uso da
linguagem C em proporções, o da Java tende ao mesmo futuro, devendo se
manter no topo por muitas décadas.
Todo mundo gosta de coisas grátis, não é mesmo? Como o custo é um fator
importante para pessoas e empresas, quando um programador quer aprender
uma linguagem nova ou uma organização quer passar a usar uma tecnologia, a
escolha por Java é justificada.
Não sendo preciso pagar nada para se criarem aplicativos Java, a gratuidade
se mostra como um dos fatores que mais ajudou a popularizar a linguagem entre
os programadores individuais e grandes organizações.
A grande disponibilidade de programadores Java é outro grande fator

para se pensar, o que leva organizações como a Google a escolherem Java para o
desenvolvimento do Android, por exemplo.
85
Aprender Java é mais fácil
Esta é uma das principais razões que levam as pessoas a aprenderem Java,
ou considerá-la como a melhor linguagem de programação entre todas. Se você
tem uma curva de aprendizagem íngreme, seria difícil obter resultados em um
curto espaço de tempo em outra linguagem.
No caso do aprendizado de Java, sua sintaxe em inglês fluente torna muito

mais fácil ler os programas e aprender rapidamente. Então, conforme você se
familiariza com os obstáculos iniciais com a instalação do JDK e criação de paths,
escrever programas em Java também se torna algo bastante tranquilo.
Java é uma linguagem de programação orientada a objetos
Outra razão para se aprender Java é que é uma linguagem de programação

orientada a objetos. O desenvolvimento orientado a objetos é muito mais fácil e
também ajuda a manter um sistema modular, flexível e extensível.
Depois de ter conhecimento dos conceitos-chave da programação

orientada a objetos, como abstração, encapsulamento, polimorfismo e herança,
você pode implementar todos eles no uso de Java. A própria linguagem incorpora
muitas práticas recomendadas e o padrão de design em sua biblioteca.
Java é uma das poucas linguagens perto de serem 100% orientadas a objetos.
Com ela também são promovidos os princípios de design sólido e orientação a
objeto em forma de projetos de código aberto, como o Spring, que certifica a boa
gestão de um código utilizando o princípio de injeção de dependência.
Interface Rich API
Uma razão a mais que explica o grande sucesso da linguagem Java é a

Rich API – sua interface de programação, que vem junto à instalação. Além disso,
a Java fornece sua API com suporte à rede, utilitários, análise XML, conexão de
banco de dados etc. – praticamente tudo que você precisa. O que restar não deve
ser motivo de preocupação, já que estará coberto por bibliotecas de código aberto,
como Apache Commons, Google Guava, entre outros.
Ótimas ferramentas de desenvolvimento
Ferramentas como Eclipse e Netbeans têm desempenhado um papel

fundamental para fazer da Java uma das melhores linguagens de programação
existentes. A codificação no seu IDE (Integrated Development Environment) é
extremamente prazerosa, especialmente se você já tiver codificado no DOS Editor
ou Bloco de Notas.
86
Essas ferramentas não só ajudam na conclusão de código, como também

fornecem capacidade de depuração, que é algo essencial para o desenvolvimento
do mundo real. Além do seu IDE, a plataforma Java também tem várias outras
ferramentas, como Maven e Ant, para construir aplicações Java, decompilers,
JConsole, Visual VM etc.
Grande coleção de bibliotecas de código aberto
As bibliotecas de código-fonte aberto garantem que o Java possa ser

usado em qualquer lugar. Apache, Google e outras organizações contribuíram e
continuam contribuindo com grandes bibliotecas, tornando o desenvolvimento
em Java mais fácil, rápido e econômico.
Há estruturas excelentes, como Spring, Struts, Maven, que garantem o

desenvolvimento, acompanham as melhores práticas de construção de software,
promovem o uso de padrões de design e são muito eficientes para a rotina de
desenvolvimento de qualquer programador.
É recomendável sempre procurar uma funcionalidade no Google antes

de escrever seu próprio código. Há uma boa chance de que alguém já tenha feito
algo no mínimo parecido e, assim, o que você precisa já esteja codificado, testado
e disponível, pronto para você usar.
Imenso apoio comunitário
Ter uma comunidade sólida é a maior força da Java e de sua plataforma.

Não importaria o quão boa ela fosse, certamente não sobreviveria se não houvesse
uma comunidade de desenvolvedores para apoiar, ajudar e compartilhar o
conhecimento lá. Nesse aspecto, os desenvolvedores nessa linguagem são muito
bem servidos: existem inúmeros fóruns ativos, usuários do Stack Overflow,
organizações open source e vários pequenos grupos de usuários para ajudá-lo
em absolutamente tudo.
Há comunidades para dar suporte para iniciantes, desenvolvedores

avançados e até mesmo para os peritos. A troca de informações é fomentada
como um hábito permanente dos seus usuários.
Também é muito comum ver programadores que usam open source

contribuírem como testadores e programadores especialistas fornecerem
conselhos gratuitos em vários fóruns e no Stack Overflow. Isso, sem sombra de
dúvidas, dá muita confiança para todos os novatos.
Aprender Java é importante para qualquer profissional da área de

desenvolvimento. Estejam familiarizados com outras linguagens ou não, essa é
uma das que mais oferecem oportunidades no mercado e mantém seu potencial
de crescimento para muitos anos no futuro.
FONTE: <https://www.impacta.com.br/blog/2017/04/03/entenda-a-importancia-de-se-
aprender-java/>. Acesso em: 22 out. 2019.
87
RESUMO DO TÓPICO 3
• Casting pode ser entendida por ser a conversão de um determinado tipo de

dado para uma variável de outro tipo, desde que o dado seja compatível com o
tipo de dado da variável que receberá o valor.
• Além dos tipos de dados primitivos, existem tipos que são objetos, por exemplo,
String, o qual recebe qualquer conteúdo alfanumérico.
• Comandos de controle de fluxo servem para direcionar o fluxo da execução de

um programa através de condições, sendo utilizado o comando “if” e “else”.
• Comando switch pode ser utilizado quando existem várias condições para
uma mesma variável, evitando vários comandos if e else.
• Comando while é um laço de repetição, executando o trecho de código abaixo

dele várias vezes enquanto uma condição for verdadeira.
• Comando for também é um laço de repetição, porém executa o trecho de código

abaixo dele pela quantidade de vezes determinada na sua variável de controle.
• Comando “break” encerra o laço de repetição imediatamente, não havendo

uma próxima iteração.
• Comando “continue” encerra a iteração atual do laço de repetição, realizando

a próxima iteração.
• Escopo de uma variável é o local onde a variável é visível e pode ser utilizada.
CHAMADA
Ficou alguma dúvida? Construímos uma trilha de aprendizagem

pensando em facilitar sua compreensão. Acesse o QR Code, que levará ao
AVA, e veja as novidades que preparamos para seu estudo.
88
AUTOATIVIDADE
1 Em qualquer software é necessária a implementação de regras, sendo estas

expressas através de expressões condicionais. Neste sentido, implemente
uma classe na qual seja inicializada uma variável chamada “valorProduto”
com o valor 150,00 e outra variável “percentualJuros” que possui o valor 5.
Crie também uma terceira variável “valorJuros”, a qual deve ser inicializada
com zero, e esta recebe o valor do cálculo dos juros. Deve ser implementada
a condição se o valor dos juros for maior que o valor do produto, então deve
ser impressa a mensagem “Juros é inválido” e, caso contrário, imprimir a
mensagem “Juros é válido”, utilizando os comandos “if” e “else”.
2 Os comandos de fluxo, como o “if” e “else” são essenciais ao desenvolvimento

de qualquer software, pois permitem a inclusão de regras de negócio, por
exemplo. Neste sentido, implemente uma classe qualquer que tenha o
método “main” para execução, no qual o programa deve solicitar ao usuário
que informe sua altura e seu peso, valores que devem ser armazenados em
duas variáveis do tipo double, uma delas nomeada por “altura” e outra por
“peso”. Outro passo do algoritmo é realizar o cálculo do IMC (peso dividido
por altura vezes altura), sendo este valor armazenado em outra variável
chamada “imc” do tipo double. Ao final, o algoritmo deve validar se o valor
da variável “imc” for inferior a 19, então deve ser exibida a mensagem “Peso
abaixo do normal”, senão, apresentar a mensagem “Peso igual ou acima do
normal”. Utilize a biblioteca JOptionPane para solicitação dos valores.
3 Implemente um pequeno programa utilizando a linguagem de programação

Java, no qual seja solicitado ao usuário o nome (variável tipo String) e a
idade (variável tipo int). Após terem sido informados esses valores, deve
ser desenvolvida uma condição para validar se a pessoa possui idade
igual ou superior a 18 anos. Se a pessoa tiver 18 anos ou mais, então deve
ser apresentada a mensagem na tela "Pessoa é maior de idade. Cadastro
válido...", e caso contrário, deve ser apresentada a mensagem "Pessoa menor
de idade, não é possível cadastrar...". Utilize a biblioteca JOptionPane para
solicitar dados ao usuário e também para apresentação da mensagem final.
4 A utilização do comando switch auxilia uma melhor legibilidade do código-

fonte quando se tem uma situação em que podem haver muitas condições,
evitando de serem implementados os comandos if/else várias vezes, um
para cada condição. Neste sentido, implemente um pequeno programa
utilizando a linguagem de programação Java, em que o usuário informe um
número inteiro, de 1 até 12, sendo apresentado ao usuário o mês informado,
por extenso. Para desenvolver essa funcionalidade, utilize o comando switch
e a biblioteca JOptionPane.
89
5 O comando for é um dos laços de repetição da linguagem de programação
Java, o qual permite repetir determinadamente um trecho de código-
fonte. Neste sentido, implemente um programa escrito em Java, em que o
usuário informe um número inteiro, sendo a quantidade de vezes em que
a mensagem no console “Esta é a iteração número x” é executada, através
do objeto System.out. Para o usuário informar a quantidade de vezes de
iterações do loop, utilize a biblioteca JOptionPane.
90
UNIDADE 2
CONCEITOS DE ORIENTAÇÃO A
OBJETOS, PACOTES JAVA.LANG E
JAVA.IO, VETORES UNIDIMENSIONAIS
E MULTIDIMENSIONAIS
• apresentar os principais conceitos do paradigma da Orientação a Objetos;
• apresentar os métodos de reutilização de código-fonte da orientação a

objetos;
• apresentar os pacotes mais utilizados na linguagem de programação Java,

dentre eles o Java Lang e Java IO;
• apresentar vetores unidimensionais e multidimensionais;
PLANO DE ESTUDOS
Esta unidade está dividida em três tópicos. No decorrer da unidade você
encontrará autoatividades com o objetivo de reforçar o conteúdo.
TÓPICO 1 – CONCEITOS DE ORIENTAÇÃO A OBJETOS
TÓPICO 2 – EXCEÇÕES E CONTROLE DE ERROS
TÓPICO 3 – PACOTES JAVA LANG, JAVA IO E VETORES
CHAMADA

91
92
UNIDADE 2
TÓPICO 1
CONCEITOS DE ORIENTAÇÃO A OBJETOS
1 INTRODUÇÃO
Agora que você já conhece os conceitos básicos da linguagem de
programação Java, suas variáveis, constantes, conversões, comandos de controle,
como instalar e configurar o ambiente de desenvolvimento, chegou o momento
de estudarmos um padrão diferente de programação: o paradigma da orientação
a objetos.
De acordo com Santos (2013), “Programação Orientada a Objetos ou,

abreviadamente, POO é um paradigma de programação de computadores onde
se usam classes e objetos para representar e processar dados usando programas
de computadores”.
Esse é o paradigma utilizado pelo Java e foi a solução dos problemas

encontrados no desenvolvimento de software com outros modelos de
programação, por exemplo, paradigmas de programação procedural.
Segundo Brookshear (2013), o paradigma procedural, ou também

chamado de paradigma imperativo, representa a forma de programação voltada
para as funções que um sistema deve ter, o que torna os componentes da aplicação
separados.
Para exemplificar alguns problemas do paradigma procedural, usaremos

um exemplo clássico já utilizado por diversos autores: a validação de um CPF.
Imagine que existe um formulário no qual é recebida a informação de um CPF
e que esta deve ser enviada para uma função que irá validá-lo. Agora, imagine
chamar essa função em centenas de formulários para validar o CPF em cada um
deles. Seria muito fácil esquecer de chamar a função de validação. A situação
pode piorar na entrada de um novo desenvolvedor no projeto, em que ele deve
ser avisado que sempre deve validar o CPF de um formulário, mesmo que não
esteja relacionado a sua parte no desenvolvimento do sistema. Isso nos leva a
outro grande problema da programação procedural, que é quando existe a
necessidade de ler o código desenvolvido por outro programador para descobrir
como ele funciona internamente. Em alguns casos, devido ao tamanho do código,
torna-se maçante e leva muito tempo para ler todo código, gerando perda de
produtividade.
93
UNIDADE 2 | CONCEITOS DE ORIENTAÇÃO A OBJETOS, PACOTES JAVA.LANG E JAVA.IO, VETORES UNIDIMENSIONAIS
E MULTIDIMENSIONAIS
Agora, no paradigma orientado a objetos, é possível concentrar a

responsabilidade de validação em um único lugar, não precisando chamar
funções diversas vezes em todos formulários, eliminando assim as chances de
esquecimento. A orientação a objetos é uma maneira de programar que ajuda
na organização do código e resolve muitos problemas enfrentados em outros
paradigmas de programação. No caso da validação do CPF, utilizando orientação
a objetos, um único programador fica responsável pela edição do código de
validação, sem que outros programadores precisem saber. Isso é possível
porque o paradigma orientado a objetos facilita a conexão entre os dados e as
funcionalidades da linguagem, recurso não disponível no paradigma procedural,
por exemplo.
Antes de analisar as vantagens da utilização do paradigma orientado

a objetos, no decorrer deste livro didático, você aprenderá alguns conceitos
relacionados a ele. Para isso, primeiramente, você deve entender o que são objetos
e o que são classes.
De acordo com Allan (2013), objeto pode ser entendido pela representação
da abstração de algo no contexto do problema da aplicação a ser desenvolvida, o
qual reflete as funcionalidades e recursos da aplicação.
Neste sentido, se você analisar o conceito da orientação a objetos através

de um exemplo, como o de desenvolvimento de uma aplicação para uma agência
bancária, os objetos extraídos podem ser: cliente, endereço, contato, conta
corrente, aplicação financeira e demais recursos que se relacionam.
Na orientação a objetos, objeto pode ser conceituado pela instância de

uma classe, ou seja, é a criação de um objeto do tipo de uma classe, criado em
memória. Uma classe pode ser definida como o modelo ou representação de um
objeto, a qual possui todas as características que o objeto possui (ALLAN, 2013).
Desta forma, uma classe em orientação a objetos descreve os serviços que

seus objetos oferecem e que informações eles podem guardar. Para isso, a classe
utiliza métodos para definir o comportamento dos objetos e atributos para definir
que estados os objetos são capazes de manter.
De uma forma geral, podemos concluir que a orientação a objetos

contribui muito para que seja desenvolvido um código-fonte mais fácil de realizar
manutenção, direcionando as responsabilidades, tornando, assim, a aplicação
mais flexível.
94
TÓPICO 1 | CONCEITOS DE ORIENTAÇÃO A OBJETOS
2 CRIANDO UM TIPO: CLASSE EM JAVA

Você aprendeu um breve conceito de classe na introdução deste tópico.
A partir desse ponto, será realizado um aprofundamento do conceito de classe,
através da criação de uma classe, partindo um pouco para a prática.
Considere que seja necessária a criação de um software que será utilizado

em um banco. Neste sentido, inicialmente é necessário pensar na entidade mais
importante em um sistema bancário, isto é, a conta. Uma conta pode ter as
seguintes características: número de conta, CPF, nome de titular da conta e saldo.
As funcionalidades de uma conta são: realizar saques, depósitos, impressão de
extratos, transferência de uma conta para outra conta etc.
Com todas essas informações, podemos desenvolver um projeto de

uma conta bancária, porém, não podemos ainda acessar o saldo. Neste sentido,
precisamos construir a conta, para acessar seus dados e permitir que sejam
apresentadas as informações desejadas, como saldo, tipo de conta e nome do titular
da conta. No entanto, temos a conta, e para acessar seus dados, precisamos criar
instâncias, as quais são contas dos clientes, onde podemos realizar as operações
que criamos. Apesar de anteriormente ter sido declarado que toda conta tem um
número de conta, nome de titular da conta e saldo, é nas instâncias do projeto que
poderemos armazenar esses valores.
Neste exemplo, a classe é a definição da conta, ou seja, o projeto da conta

que foi criado, mas o que pode ser construído a partir do projeto, ou seja, as
instâncias são os objetos da classe. Para você entender melhor, em uma classe
temos apenas a definição de seus atributos (características em comum do objeto),
mas não existe nenhum número de conta, e quando é instanciada uma classe, o
objeto pode ser atribuído para o atributo do objeto “numeroConta”, por exemplo,
o número de uma conta.
Se você pesquisar o conceito da palavra classe, você terá como retorno a

definição de que se refere a grupos de pessoas, animais ou coisas com atributos
semelhantes, mas não iguais, pois podem variar os valores desses atributos e ter
comportamentos diferentes.
Um outro exemplo pode ser o projeto de um edifício, no qual não é

possível morar, pois é necessário realizar a etapa de construção estrutural, como a
construção de paredes, colocar portas e janelas. Neste sentido, trazendo para nosso
objeto de estudo, é necessário construir as instâncias a partir do projeto. Sendo
assim, um objeto possui o tipo de uma classe, e quando a classe é instanciada, o
objeto possui todos os métodos e atributos da classe, podendo receber dados para
os devidos atributos.
95
E MULTIDIMENSIONAIS
Esses exemplos servem para deixar claro a diferença entre classe e

objeto, uma das dificuldades iniciais de quem inicia a aprendizagem utilizando
o paradigma da orientação a objetos. É comum quem está iniciando nesse
paradigma utilizar as duas palavras como sinônimos, obviamente, de forma
errada. Note que na Unidade 1 deste livro, utilizamos classe apenas para executar
um algoritmo, porém, a partir daqui, classe é a implementação de objetos com
características semelhantes, possuindo atributos e métodos.
Retornando ao exemplo da conta bancária e implementando uma classe

para a linguagem de programação Java, temos o código-fonte apresentado na
Figura 1.
FIGURA 1 – EXEMPLO DE CLASSE
FONTE: O autor
No exemplo apresentado na Figura 1, foram declaradas as características

que a conta de nosso projeto possui, o que é chamado de atributo, sendo atributos
o numeroConta, CPF, nomeTitular e saldoConta. Note que as variáveis foram
declaradas no escopo da classe, ou seja, fora do bloco principal (main). Desse
modo, quando uma variável é declarada fora de um bloco, diretamente no escopo
da classe, é chamada de variável objeto, ou atributo. Ainda nesse exemplo, você
pode notar o tipo de variável String, já utilizada anteriormente. String é uma
classe em Java que armazena uma cadeia de caracteres alfanuméricos, conforme
você já estudou.
O método main é chamado pela Java Virtual Machine (JVM) toda vez que
ela inicia, e este é implementado na classe principal de uma aplicação Java, sendo
público, estático, sem retorno (void), com nome “main” e receber como argumento
um array do tipo String, mas não se preocupe com estas definições neste momento,
pois você aprenderá a seguir cada uma delas.
96
3 INSTÂNCIA DE UMA CLASSE: UTILIZANDO UM OBJETO

Como você já conhece o que é uma classe em Java, assim como a diferença
entre classe e objeto, partimos neste ponto para o conhecimento prático de como
usá-la. Para isso, iniciaremos criando uma classe chamada ProgramaConta, e a
partir desta, será apresentado como utilizar a classe Conta.
Neste sentido, para realizar a instância da classe Conta, é utilizada a

palavra-chave reservada new, seguida de parênteses que receberão os argumentos
do método, se houver parâmetros, o que será estudado mais adiante. Analise o
exemplo da instância da classe Conta na Linha 8 do código-fonte apresentado na
Figura 2.
FIGURA 2 – EXEMPLO DE INSTÂNCIA DA CLASSE CONTA
FONTE: O autor
No código-fonte apresentado na Figura 2, foi criado um objeto do tipo

Conta em memória, porém, é necessário acessá-lo, e, para isso, devemos criar
uma variável do tipo Conta, a qual será nosso objeto, conforme ilustrado na Linha
9 da Figura 3.
FIGURA 3 – EXEMPLO DE INSTÂNCIA DA CLASSE CONTA
FONTE: O autor
Através da variável criada “objetoConta”, é possível acessar o objeto e

alterar o valor de seus atributos, conforme apresentado na Figura 4.
97
E MULTIDIMENSIONAIS
Você pode implementar este código-fonte na IDE Eclipse, ou em outra de

sua preferência, mas o ideal é você ir implementando todos os exemplos, o que
melhorará seu aprendizado. Através da implementação deste código, quando
for executar a classe “ProgramaConta”, tente utilizar o modo debug, assim você
entenderá o que acontece em cada linha.
FIGURA 4 – EXEMPLO DE ATRIBUIÇÃO DE VALOR PARA ATRIBUTOS DE UMA CLASSE
FONTE: O autor
Neste sentido, no código-fonte da Figura 4, note que na linha 8, é

utilizado o ponto (objetoConta.nomeTitular), e isso significa que é acessado algo
de “objetoConta”. Neste caso, o objeto “objetoConta” pertence à “Marcio” e tem
saldo de um mil reais. Note que após a execução da classe “ProgramaConta”, foi
impressa a mensagem através do objeto System.out, com o valor dos atributos
“nomeTitular” e “saldoConta” concatenados à String.
98
4 ATRIBUTOS E MÉTODOS DE UMA CLASSE

Em uma classe, os métodos são utilizados para definir o comportamento
dos objetos, enquanto que os atributos são utilizados para definir os estados que
um o objeto é capaz de manter em memória; com isso, pode ser definido o que é
um método e um atributo de um objeto.
Existem ainda os métodos e atributos de uma classe, os quais são

chamados de métodos e atributos estáticos, por possuírem o mesmo valor para
todos os objetos da classe. Atributos de uma classe são as características físicas
dessa classe. Por exemplo, se for criada uma classe chamada Carro, seus atributos
serão suas características físicas, como codigo, nomeModelo, anoFabricacao e
anoModelo, conforme apresentado na Figura 5.
FIGURA 5 – EXEMPLO CLASSE CARRO
FONTE: O autor
Métodos são as características comportamentais de uma classe, isto é,

apresenta a operação que uma classe pode executar. Neste sentido, voltemos ao
exemplo da conta bancária, em que podemos exemplificar método pela maneira de
fazer uma operação com o objeto do tipo Conta, como sacar dinheiro, por exemplo,
sendo a operação implementada em um método dentro na própria classe.
No exemplo apresentado no código-fonte da Figura 6, foi criado um método

que retira o valor informado pelo parâmetro “valorSaque” do saldo da conta. Ao ser
invocado o método “sacarDinheiro”, nem uma informação é retornada para quem
invocou a execução desta operação, o que é chamado de void.
FIGURA 6 – EXEMPLO DE MÉTODO “SACARDINHEIRO”
FONTE: O autor
99
E MULTIDIMENSIONAIS
No código-fonte da Figura 6, ao ser solicitado o saque de algum valor

da conta, isto é, invocar o método “sacarDinheiro“, é necessário informar qual o
valor a ser retirado. Para isso, é necessário declarar o método com uma variável
dentro dos parênteses, como “valorSaque”, variável temporária que, ao final da
execução do método, deixará de existir. Esta variável temporária é chamada de
argumento ou parâmetro do método.
A palavra-chave this é utilizada para informar que “saldoConta” não é

uma simples variável e sim um atributo. Da mesma forma que temos o método
para retirar um valor da conta, temos o método para depositar um valor:
FIGURA 7 – EXEMPLO DE ATRIBUIÇÃO COM +=
FONTE: O autor
Outro detalhe importante é no exemplo apresentado na Figura 7, onde

na Linha 29, não é utilizada uma variável auxiliar para efetuar a soma e sim
a abreviação “+=”, que realiza a soma do valor que tem na conta com o valor
depositado e armazena no atributo “saldoConta”.

Da mesma forma que foi implementado o método sem retorno, utilizando
o void, o método também pode retornar um valor para o código que o invocou.
Utilizando nosso exemplo do método “sacarDinheiro”, é possível retornar
um valor indicando se a operação foi ou não bem-sucedida, como neste caso,
utilizando valores booleanos (true ou false). Você pode analisar este exemplo no
código-fonte da Figura 8, onde na Linha 24, o método está definido como retorno
“boolean” e perceba que não temos mais a palavra reservada “void”. Além disso,
note nas linhas 26 e 29 do código-fonte, onde é realizado o retorno do método, e
caso o valor do atributo “saldoConta” for menor que o parâmetro “valorSaque”,
então será retornando “false”, caso contrário “true”.
100
FIGURA 8 – EXEMPLO DE RETORNO DE MÉTODO
FONTE: O autor
Perceba que a declaração do método sem o void na frente significa que o

método devolve alguma informação a quem o invoca. No caso do exemplo da
Figura 8, retorna um valor booleano, através da palavra-chave return, indicando
que o método finaliza nesse ponto com o retorno da informação.
Quando é necessário criar novos atributos referentes a um cliente, como

CPF, nome, endereço, cidade, telefone, entre outros, o ideal é criarmos em uma
classe Cliente, pois estes atributos se referem a um cliente. Neste contexto, criamos
uma nova classe chamada Cliente, e na classe Conta retiramos os atributos “cpf” e
“nomeTitular”, sendo incluído o atributo “cliente” do tipo Cliente. Neste sentido,
quando um atributo de uma classe é do tipo de outra classe, isto é, um objeto é
delegado por outro, temos uma composição. Na Figura 9 temos o exemplo de
composição na linha 21, cujo atributo “cliente”, que é um objeto do tipo “Cliente”,
é delegado pelo objeto do tipo Conta.
FIGURA 9 – EXEMPLO DE COMPOSIÇÃO
FONTE: O autor
101
E MULTIDIMENSIONAIS
Analise agora a Figura 10, na qual você pode notar que na Linha 6 está
sendo criado um objeto do tipo Cliente, chamado de “objetoCliente”. Além
disso, você pode notar que na Linha 11 foi atribuído o objeto “objetoCliente”
como valor para o atributo do objeto “objetoConta”. Neste sentido, na Linha 13
é apresentado um exemplo de delegação, em que o objeto “objetoConta” delega
o objeto “objetoCliente” invocando o valor do atributo “nome”. Note na parte
inferior da Figura 10, na guia “Console” do Eclipse, o resultado da execução da
classe “ProgramaConta”.
Explicando de outro modo, objetoConta possui uma referência ao

mesmo Cliente que objetoCliente se refere, e esse pode ser acessado através de
objetoConta.cliente.
FIGURA 10 – EXEMPLO DE EXECUÇÃO DE COMPOSIÇÃO
FONTE: O autor
102
Um sistema orientado a objetos é um grande conjunto de classes se

comunicando entre si, transferindo responsabilidades para a classe que for mais
apta a realizar determinada tarefa. Nos exemplos apresentados, a classe Conta
usa a classe Cliente, sendo que, dessa forma, existe uma colaboração entre os
objetos através de troca de mensagens entre si.

Além disso, quando utilizamos o comando new em um objeto, ele inicializa
com seus valores padrão, ou seja, para números o valor 0 (zero), para booleano
o valor false e para referências o valor null. A palavra-chave null é utilizada para
indicar uma referência para nenhum objeto, ou objeto não existente em memória,
isto é, quando a utilizamos em um objeto e tentarmos acessar um atributo ou
método que está se referenciando para null, ocorrerá um erro durante a execução.
Até aqui você aprendeu o básico da orientação a objetos, e caso você

ainda não implementou os códigos-fontes apresentados no Eclipse, faça esta
atividade, pois para você entender os próximos códigos, é importante você ter
compreendido até este ponto.
5 ENCAPSULAMENTO
O termo encapsulamento (data hidding) é uma das características da
orientação a objetos, sendo um mecanismo para restringir acesso a variáveis e
métodos de uma classe. Segundo Furgeri (2015), com o encapsulamento, os
detalhes da implementação de uma classe se tornam ocultos ao usuário (código
que invoca o código oculto) da classe, e, com isso, o usuário utiliza serviços
da classe sem conhecer como o processo é realizado internamente, sendo
liberadas ao usuário algumas funcionalidades. Ainda segundo Furgeri (2015), o
encapsulamento pode ser chamado de acessibilidade, pois ele define o que está
acessível na classe.
Neste sentido, segundo Furgeri (2015), a utilização de encapsulamento

possui várias vantagens:
• Tornar o código-fonte mais legível, pois através da ocultação de código não

necessário.
• Minimização de erros de programação.
• Restringir conteúdo das variáveis.
• Facilitar ampliação de código em função de novas atualizações.
Um exemplo de encapsulamento é exposto no código-fonte da classe

apresentada na Figura 11, em que você pode analisar que se um usuário (código
invocando) tentar utilizar o atributo cpf do objeto do tipo Pessoa, receberá um erro
de compilação, pois este atributo é privado, o qual deve ser alterado invocando o
método mudaCPF.
103
E MULTIDIMENSIONAIS
FIGURA 11 – EXEMPLO DE ENCAPSULAMENTO
FONTE: O autor
6 MODIFICADORES DE ACESSO
Os modificadores de acesso são palavras-chave reservadas pelo Java que
fazem o controle de acesso às classes, interfaces, métodos, variáveis de instância
e variáveis de classe, tornando o acesso mais restritivo (FINEGAN; LIGUORI,
2018). Assim como outras palavras reservadas, não podem ser usadas como
nomes de métodos, classes ou atributos.
São quatro os modificadores de acesso básicos da linguagem de

programação Java: public, private, default e protected. O menos restritivo é o public,
já utilizados em exemplos anteriores, o qual permite que qualquer outra classe,
atributo ou método, presentes no mesmo projeto, possam acessar a classe ou
método declarados com este modificador, ou seja, ele é visível para todos os
pacotes do mesmo projeto (FINEGAN; LIGUORI, 2018). A Figura 12 apresenta
um exemplo de criação de uma classe e de um método com modificador de acesso
public.
FIGURA 12 – EXEMPLO DE UTILIZAÇÃO DO MODIFICADOR DE ACESSO PUBLIC
FONTE: O autor
104
O modificador de acesso private torna as classes, métodos ou atributos

visíveis apenas para a própria classe (DIMES, 2015). A Figura 13 exemplifica a
declaração de um atributo, na linha 5, com modificador de acesso private.
FIGURA 13 – EXEMPLO DE ATRIBUTO CRIADO COM MODIFICADOR DE ACESSO PRIVATE
FONTE: O autor
Quando na declaração da classe, não for definido nenhum tipo de

modificador de acesso, é considerado o tipo de modificador default, e, neste caso,
apenas as classes criadas no mesmo pacote podem ter acesso às classes, métodos
ou atributos com este modificador de acesso (DIMES, 2015). Como não é definido
um tipo da declaração, o modificador é identificado pelo compilador. A Linha 5
do código-fonte da Figura 14 apresenta um exemplo de declaração de um atributo
sem modificador de acesso, sendo então considerado o modificador default.
FIGURA 14 – EXEMPLO DE DECLARAÇÃO DE ATRIBUTO SEM MODIFICADOR DE ACESSO
FONTE: O autor
Por último, temos o modificador de acesso protected, no qual todos os

elementos se tornam visíveis para a própria classe e suas classes filhas, além
dos elementos que estiverem no mesmo pacote (FINEGAN; LIGUORI, 2018). A
Figura 15 apresenta um código-fonte de uma classe, no qual, na linha 5, existe a
declaração de um atributo com o modificador de acesso protected.
105
E MULTIDIMENSIONAIS
FIGURA 15 – EXEMPLO DE ATRIBUTO CRIADO COM MODIFICADOR DE ACESSO PROTECTED
FONTE: O autor
Repare que nos exemplos apresentados, todas as classes possuem

modificador de acesso public, pois modificadores private e protected não se aplicam
às classes, mas somente a seus atributos e métodos.
7 HERANÇA
A característica herança, na orientação a objetos, significa justamente o que
o próprio nome sugere, a herança de algo, no caso entre as classes (FURGERI, 2015).
Neste sentido, a herança ocorre quando uma classe herda métodos e atributos de
uma outra classe, a qual é conhecida por superclasse (FURGERI, 2015).
A técnica da herança permite o compartilhamento ou ainda

reaproveitamento de código-fonte definidos em outra classe, sendo que a classe
que fornece (herda) este recurso é chamada de superclasse, e a classe que recebe
estes recursos de subclasse (SERSON, 2007). Além disso, outro termo muito
utilizado quando se fala em herança é a especialização, característica que ocorre
quando uma classe A herda características da classe B, e a classe A implementa
partes específicas, como atributos próprios, não contidos na classe original B
(superclasse), e, desta forma, tornando-se especializada (FURGERI, 2015).
Ainda segundo Furgeri (2015), todas as classes criadas na linguagem de

programação Java possuem a característica de herança automaticamente, sem
que o programador implemente a herança, isso porque uma classe criada recebe
recursos da classe Object.
Analise o código-fonte exposto na Figura 16, no qual na classe apresentada

à esquerda, você pode notar uma simples classe Pessoa, contendo seus dois
atributos codigo e nome. Ainda referente a Figura 16, na classe à direita, você
pode analisar na linha 3 do código-fonte a palavra reservada extends, a qual
especifica que a classe Funcionario está herdando métodos e atributos da classe
Pessoa. Além disso, você pode notar a característica de especialização na classe
Funcionario, pois foi criado um atributo específico de Funcionario, o qual não
possui na classe Pessoa.
106
FIGURA 16 – EXEMPLO DE IMPLEMENTAÇÃO DE HERANÇA
FONTE: O autor
Note que na classe Pessoa, apresentada na Figura 16, para permitir acesso
aos atributos da classe, como eles possuem o modificador private, as boas práticas
dizem que devem ser criados dois métodos, set e get para cada atributo, sendo
que o método set de um atributo atribui valor a ele, e o método get serve para
pegar seu valor.
A Figura 17 apresenta a implementação da utilização da classe Funcionario

apresentada na Figura 16. Neste sentido, você pode analisar as linhas 10 e 11 do
código-fonte da Figura 17, onde estão sendo invocados os métodos setCodigo
e setNome, herdados da classe Pessoa, e, neste caso, pertencentes a classe
Funcionario. Neste exemplo, você pode notar claramente o recurso de reutilização
de código-fonte, pois não foi necessário implementar a declaração dos atributos
codigo e nome, assim como os métodos setters e getters, na classe Funcionario.
FIGURA 17 – EXEMPLO DE UTILIZAÇÃO DE UMA CLASSE QUE POSSUI IMPLEMENTAÇÃO

DE HERANÇA
FONTE: O autor
107
RESUMO DO TÓPICO 1
• Programação orientada a objetos (POO) é um paradigma de programação que

se baseia em conceito de objetos para representação de dados.
• O paradigma da Programação Orientada a Objetos foi uma das soluções

desenvolvidas para evitar muitos dos problemas que existiam no
desenvolvimento de software, permitindo, por exemplo, reutilização de
código-fonte e facilidade de manutenção.
• Objeto, na orientação a objetos, pode ser entendido pela abstração de alguma

coisa do domínio do problema, ou seja, em um software de cadastro de veículos,
por exemplo, pode ser abstraído o objeto carro, marca, fornecedor, entre outros
objetos que estão envolvidos no problema.
• Classe, na orientação a objetos, pode ser entendida por ser representação

de objetos com características em comum, em código-fonte, isto é, sua
implementação, por exemplo, objeto vendedor e objeto gerente, possuem as
mesmas características, como codigo, nome, cpf, telefone, e estes podem ser
representados pela classe Funcionario.
• Um objeto, durante a execução de um programa, é a instância de uma classe,

isto é, a criação de um objeto em memória do tipo de uma determinada classe
é um objeto.
• Um parâmetro pode ser entendido como uma variável temporária, enviada

para um método.
• Quando não existe retorno de alguma informação ao ser invocado um método,

este deve ser definido pelo tipo void, e caso exista retorno de algum dado, então
deve ser definido o método com um tipo, e utilizada a palavra reservada return
seguida do valor de retorno.
• Encapsulamento serve para ocultar do código que invoca um determinado

método, detalhes da implementação, pois quem invocar um determinado
método não precisa conhecer sua implementação, bastando invocá-lo.
• Modificadores de acesso podem ser entendidos por serem palavras-chave

reservadas pelo Java, os quais realizam o controle de acesso às classes, interfaces,
métodos, variáveis de instância e variáveis de classe, isto é, permitindo acessar
pela própria classe, ou por classes do pacote, por classes de todo o projeto etc.
108
• São quatro tipos de motificadores de acesso: public, private, default e protected.
• Herança é uma das principais características da orientação a objetos, podendo

ser entendida pela herança de métodos e atributos de uma classe A (superclasse)
por uma classe B, isto é, a classe B possui todos os métodos e atributos da classe
A sem a implementação deles, sendo utilizada a palavra reservada extends e o
nome da superclasse.
• Especialização é uma forma de herança em que a classe que herda atributos e

métodos de outra classe possui atributos ou métodos específicos.
109
AUTOATIVIDADE
1 Um dos aspectos que a linguagem de programação Java possui é a

semelhança com a linguagem de programação C++, tanto na sintaxe dos
comandos da linguagem quanto na característica da orientada a objetos,
sendo esta última, um padrão adotado no mercado. Referente à orientação
a objetos, é CORRETO afirmar:
a) ( ) É o paradigma de programação baseado em funções para resolver

algum problema.
b) ( ) O paradigma da programação orientada a objetos, baseado em
operações, é parecido com o paradigma procedural.
c) ( ) No paradigma da programação orientada a objetos, classes e objetos
são sinônimos.
d) ( ) É o paradigma de programação baseado em objetos para resolver
algum problema.
2 Atualmente, a programação orientada a objetos é universalmente adotada

como um padrão de desenvolvimento no mercado, a qual possui muitas
vantagens em relação à programação tradicional. Referente à orientação a
objetos, é CORRETO afirmar:
a) ( ) Classe pode ser descrita como sendo a implementação de objetos em

comum.
b) ( ) Objeto pode ser descrito como sendo a implementação de objetos em
comum do contexto da solução de uma aplicação.
c) ( ) Classe e objeto são sinônimos e possuem o mesmo significado dentro
do paradigma da orientação a objetos.
d) ( ) No paradigma da orientação a objetos, uma classe não pode ser definida
como tipo de um objeto.
3 Nas primeiras linguagens de programação, muitos eram os problemas

recorrentes durante a fase de desenvolvimento de software, como qualidade
ruim de código-fonte, dificultando manutenção, trechos de códigos
repetidos em vários locais do mesmo sistema, entre outros. Neste sentido, a
orientação a objetos surgiu para resolver estes e muitos outros problemas.
Referente à orientação a objetos, é CORRETO afirmar:
a) ( ) Quando uma classe é instanciada, o objeto possui todos os métodos e

atributos da classe de seu tipo.
b) ( ) Um objeto pode ter o tipo de uma classe, e quando esta classe é
instanciada, o objeto possui todos os atributos da classe, exceto os
atributos.
110
c) ( ) Em uma classe, não é permitido declarar uma variável fora de um
bloco, isto é, diariamente no escopo da classe.
d) ( ) Em um objeto, é permitido declarar uma variável apenas fora de um
bloco e não diretamente no escopo da classe.
4 A programação orientada a objetos permite o desenvolvimento da solução

para um problema baseado em objetos do contexto da aplicação. Referente
à orientação a objetos, é CORRETO afirmar:
a) ( ) Métodos estáticos podem ser entendidos por ser a implementação de

um objeto.
b) ( ) Atributos de uma classe são chamados de atributos estáticos por
possuirem o mesmo valor para todos os objetos da classe.
c) ( ) Atributos estáticos possuem valores diferentes em objetos do mesmo
tipo de uma classe.
d) ( ) Métodos estáticos possuem valores diferentes em objetos do mesmo
tipo de uma classe.
5 O paradigma da orientação a objetos é um padrão sólido de mercado, sendo

que a maioria das linguagens de programação atuais permitem trabalhar
neste paradigma. A orientação a objetos permite elaborar um software a
partir da abstração de objetos que se comunicam entre si. Referente à
orientação a objetos, é CORRETO afirmar:
a) ( ) Apesar de reduzir riscos de programação, o encapsulamento torna o

código-fonte menos legível para o código que invoca um determinado
trecho encapsulado.
b) ( ) Encapsulamento é uma das características da orientação a objetos que
possui uma das vantagens de restringir acesso a variáveis e métodos de
uma classe.
c) ( ) Os modificadores de acesso default e public possuem a mesma
funcionalidade de permitir que um método ou atributo seja acessado
por todas as classes da aplicação.
d) ( ) Quando se deseja que um método possua o tipo de modificador de
acesso default, este deve ser declarado, o qual permite acesso em todas
as classes da aplicação.
111
112
UNIDADE 2 TÓPICO 2
EXCEÇÕES E CONTROLE DE ERROS
1 INTRODUÇÃO
Agora que você já conhece os tipos primitivos de variáveis, assim como
alguns tipos de classes, comandos básicos para controle de fluxo, laços de
repetição, e compreende a orientação a objetos, é o momento de você aprender
como controlar erros durante a execução de programas.
Neste sentido, no Tópico 2 é apresentada a conceituação de exceção,

como controlar erros e também a gerar propositalmente exceções para situações
específicas que muitas vezes são necessárias. Exceção pode ser entendida como
um erro que pode ocorrer durante o tempo de execução de um programa,
podendo ser ocasionado pela tentativa de acessar algum objeto que não existe
em memória, estando apenas declarado, mas não instanciado (SCHILDT, 2015).
Ainda segundo Schildt (2015), uma exceção pode ocorrer também pela conversão
ilegal, isto é, converter caracteres de tipos inválidos para um determinado tipo,
como ao tentar converter um caractere alfanumérico (tipo String) para o tipo int,
por exemplo.
O termo exceção vem do do inglês Exception, sendo um acrônimo de

Exceptional events, podendo ser definidos como objetos que indicam que a
ocorrência de algum erro ou problema em tempo de execução de um programa.
Esses problemas podem ocorrer também no acesso a um índice inválido de um
vetor, por exemplo, ou ainda pela divisão de um número por zero, entre muitos
outros problemas.
Existem linguagens de programação que possuem mecanismos para

tratar as exceções ocorridas durante o tempo de execução, sendo este o objetivo
deste tópico. Você aprenderá como o tratamento de exceções funciona, utilizando
as palavras-chave try, catch e finally (SCHILDT, 2015). Além disso, em algumas
situações é necessário causar uma exceção propositalmente, e, neste sentido, a
linguagem Java possui o comando throw.
113
E MULTIDIMENSIONAIS
2 EXEMPLIFICANDO O TRATAMENTO DE EXCEÇÕES

Pense na situação de nosso sistema bancário, em que seja necessário
invocar o método “sacarDinheiro”, conforme apresentado na Figura 18, porém
com um valor acima do limite disponível. Neste caso, é necessário fazer com
que o sistema apresente uma mensagem de erro para que o usuário saiba que
não é possível sacar o valor informado por ultrapassar o limite. Lembre-se de
que o código-fonte que invocou o método “sacarDinheiro” não saberá sobre este
problema.
Neste sentido, assim que o usuário tentar realizar o saque e não conseguir
executar a ação, o sistema precisa ao menos informá-lo do motivo da negação do
saque.
FIGURA 18 – APRESENTAÇÃO DE MÉTODO SACARDINHEIRO
FONTE: O autor
Analise o código-fonte exposto na Figura 19, o qual apresenta a instância

da classe “Conta”, na qual está sendo forçado que uma Conta tenha um valor
de saldo negativo, ou seja, é apresentada uma situação inconsistente do que foi
projetado, conforme você pode analisar o log do console a seguir.
114
TÓPICO 2 | EXCEÇÕES E CONTROLE DE ERROS
FIGURA 19 – EXEMPLO DE EXECUÇÃO FORÇANDO SALDO NEGATIVO
FONTE: O autor
No caso apresentado na Figura 19, o saldo ficou negativo em 1700,00,

porém em sistemas reais, é comum que o erro seja tratado pelo código-fonte que
invocou o método e não pela própria classe.
Neste sentido, uma das soluções mais antiquadas é alterar o método

“sacarDinheiro” incluindo um retorno booleano para ele, realizando a validação
se a soma do limite com o saldo for maior que o valor a sacar, então o retorno é
true, e, caso contrário false, conforme apresentado na Figura 20.
FIGURA 20 – MÉTODO SACARDINHEIRO COM RETORNO BOOLEANO
FONTE: O autor
Na Figura 21 você pode analisar a invocação do método “sacarDinheiro”

com retorno booleano, onde na Linha 10 é realizada uma validação se o retorno
da invocação do método é true para então apresentar a mensagem que confirma
realização do saque.
115
E MULTIDIMENSIONAIS
FIGURA 21 – EXEMPLO DE INVOCAÇÃO DO MÉTODO SACARDINHEIRO COM

RETORNO BOOLEANO
FONTE: O autor
Conforme você pode analisar no código-fonte da figura anterior, com esta

solução, no código que invocar este método deve ser lembrado de implementar a
condição, e caso ocorrer o esquecimento desta implementação, problemas graves
poderiam acontecer, como uma máquina de autoatendimento bancário liberar
qualquer valor em saques solicitados pelos usuários, mesmo que o método
“sacarDinheiro” tivesse retornando.
Na linguagem de programação Java utilizamos uma forma diferente de

programar para a realização deste tipo de validação, tornando a aplicação mais
segura e evitando problemas de esquecimento de implementação de validações,
como a exemplificada anteriormente.
3 TRATAMENTO DE EXCEÇÕES EM JAVA

Para iniciar seu entendimento de como realizar tratamento de exceções,
analise o código-fonte apresentado na Figura 22, no qual você pode perceber que
o método main invoca o método “calcular”, e este, por sua vez, invoca o método
“calcularMedia”. Neste sentido, analise o que acontece com a JVM (Java Virtual
Machine) quando, ao executar um programa, ela encontra um erro de execução,
pelo acesso a um objeto null ou pela divisão de um número por zero, por exemplo.
No caso do código-fonte da Figura 22, ao ser realizado o cálculo na linha

19, dentro do método “calcularMedia”, você pode notar que foi passado para
o parâmetro “quantidadeNotas” o valor zero, e qualquer número dividido por
zero é um cálculo inválido, sendo então abortada a execução do programa, e
apresentado o erro no console, conforme apresentado na figura. Neste código-
fonte, foi criado este erro propositalmente para fins de aprendizado, e, desta
forma, você percebe os erros que ocorrem durante a execução em Java.
116
FIGURA 22 – EXEMPLO DE CLASSE COM ERRO DURANTE A EXECUÇÃO
FONTE: O autor
A saída apresentada no console, apresentado na Figura 22, é conhecido

por rastro da pilha (stack trace), sendo muito importante para o desenvolvedor
da aplicação, pois como você pode perceber, indica onde ocorreu o erro. Se
você pesquisar por este erro na internet, você encontrará vários blogs em que os
desenvolvedores postam os erros do console para as outras pessoas auxiliarem a
resolver o problema que está ocorrendo.
Um rastreamento de pilha (stack trace) pode ser compreendido por ser

uma lista de invocações de métodos, desde o momento em que a aplicação foi
iniciada até o local atual da execução do programa em que houve a exceção.
Neste sentido, o rastreamento de pilha é criado automaticamente pela JVM (Java
Virtual Machine) quando uma exceção (exception) é lançada para indicar o local em
que houve a exceção durante a execução do programa. O rastreamento de pilha
pode ser capturado através do método printStackTrace () dentro da cláusula catch.
117
E MULTIDIMENSIONAIS
Assim, quando uma exceção é executada (throw), a JVM verifica se o

método atual onde ocorreu a exceção (“calcularMedia”) realiza algum controle
de exceções, o que não é feito. Como o metodo “calcularMedia” não está
realizando o tratamento de exceções, então a JVM aborta a execução no ponto
em que ocorreu o erro e então realiza a verificação se o método que invocou o
“calcularMedia” realiza tratamento de erros, e como o método “calcular” também
não trata exceções, então é retornado para o método “main”, onde também não
existe tratamento de exceção, abortando o programa e apresentando o stracktrace.
As exceções que ocorrem durante a execução de programas podem ter

um impacto menor em alguns casos, mas em outros podem comprometer a
integridade da aplicação. Neste sentido, mecanismos devem ser implementados
para tratar as possíveis exceções, as quais podem ocorrer inesperadamente
muitas vezes, e, assim sendo, todo programa deve ter o controle do tratamento
de exceções (SCHILDT, 2015).
Em Java, para realizar o tratamento de exceções, o comando utilizado

para iniciar um bloco de código é o try, e este deve ser fechado com um ou mais
comandos catch, sendo o código-fonte tratado implementado entre os comandos
try e catch, e qualquer erro que ocorrer nesse código tratado, ocorre a execução
dos códigos subordinados ao comando catch (SCHILDT, 2015).
Além disso, dentro do comando catch é normalmente sinalizada a classe

Exception, pois esta é o tipo direto exceção para todas subclasses de erros (SCHILDT,
2015). Ainda segundo Schildt (2015), erros como falhas de sistema operacional ou
hardware por exemplo, podem ser tratados pela classe Exception, enquanto erros
que podem ser tratados pelo programador podem herdar da classe Error. Ambas
as classes estão dentro do pacote java.lang, o qual será estudado a seguir.
Exceções podem ser divididas em RuntimeException, IOException e

InterruptedException, sendo estas subclasses da classe Exception (FINEGAN;
LIGUORI, 2018). Neste sentido, o tratamento de exceções derivadas de
RuntimeException não é obrigatório, podendo ser utilizado a classe Exception,
mas para IOException e InterruptedException é obrigatório, quando efetuada
gravação de arquivo, por exemplo, para o IOException.
Agora, para você entender melhor o controle de fluxo de uma Exception,

o código-fonte de nosso exemplo foi alterado, no qual foi incluído o comando try
e catch para tratamento de exceções no bloco de código que ocorre o erro, e caso
ocorrer o erro novamente, o problema é tratado caindo a execução do comando
dentro do catch.
118
FIGURA 23 – CÓDIGO-FONTE TRATADO COM TRY E CATCH
FONTE: O autor
Analise a Figura 23, onde na Linha 20 foi incluído o comando try, e entre
as linhas 22 e 24 o comando catch e seu controle. Note que a variável “media”
teve que ser declarada no início do método, fora do tratamento de erro para
poder ser visualizada pelo comando return do método, pois se fosse declarada
apenas dentro do comando try, seu escopo seria apenas dentro deste, e não
poderia ser utilizada fora do tratamento de erros. Ainda na Figura 23, analise
o console apresentado como resultado da execução do programa, em que você
pode perceber na quarta linha do log, que o erro foi tratado e a mensagem “Erro
ocorrido” impressa.
FIGURA 24 – EXEMPLO DE CONTROLE DE EXCEÇÃO PARA EXECUÇÃO DO MÉTODO

“CALCULARMEDIA”
119
E MULTIDIMENSIONAIS
FONTE: O autor
Altere agora o código-fonte, retirando o tratamento de erros de dentro

do método “calcularMedia”, e inclua na invocação deste método, isto é, dentro
do método “calcular”, onde é invocado o método “calcularMedia”, conforme
linhas 13 até 18 apresentadas na Figura 24. Note nessa figura, os logs gerados
no console, em que a mensagem de erro do cálculo continua sendo apresentada,
porém após a execução do catch, a execução do programa continuou executando
demais comandos do método “calcular” e do “main”.
Na Figura 25 é apresentado um outro tipo de exceção, muito comum durante

a execução de programas, sendo o acesso a objetos que não estão instanciados, isto
é, criados em memória. Note que o objeto “conta” foi criado na Linha 6, na Linha
7 foi atribuído um valor para o atributo “numeroConta”, enquanto que na Linha 8
foi adicionado dinheiro através do método “depositarDinheiro”, porém, na Linha
10 foi tentado imprimir o nome do cliente, mas o atributo “cliente” está null, pois
não foi instanciado. Neste sentido, foi apresentado o erro no console, onde você
pode analisar a mensagem “ExecutandoNull.java:10”, indicando que na linha 10
da classe “ExecutandoNull” ocorreu o erro “java.lang.NullPointerException”,
que é o erro de acesso a objeto null, lembrando que null significa não estar criado
em memória.
120
FIGURA 25 – EXEMPLO DE EXCEÇÃO CAUSADA POR ACESSO A OBJETO NULL
FONTE: O autor
Na Figura 26 analise o código-fonte, onde você pode perceber que foi

incluído o tratamento de erros entre as linhas 10 e 15, e, neste caso, no momento
em que for executado o comando para imprimir o nome do cliente, do atributo
“cliente” do objeto “conta”, na Linha 11, a execução deste comando é abortada,
caindo a execução no catch, sendo impresso no console, neste caso, o erro ocorrido.
Além disso, você pode notar que após a execução do catch, o comando após o
tratamento de erros, localizado na Linha 17, é executado normalmente, isso por
estar fora e após o controle de exceção. Obviamente, este é um exemplo para
você entender como funciona o tratamento de exceções, mas este erro poderia ser
tratado no código-fonte incluindo uma validação se o objeto é diferente de null
para então tentar imprimir o nome do cliente.
121
E MULTIDIMENSIONAIS
FIGURA 26 – EXEMPLO DE EXCEÇÃO CAUSADA POR ACESSO A OBJETO NULL, PORÉM TRATADA
FONTE: O autor
Outro erro que poderia ocorrer seria erros de conversões entre tipos de
dados, isto é, quando um cast é realizado errado, como a conversão de um caracter
alfanumérico para tipo number, por exemplo. Esses tipos de exceções, as quais
podem ser tratáveis pelo programador, o compilador não verifica se as validações
estão sendo realizadas, e, com isso, o java não obriga a implementar o try/catch, as
quais são chamadas de exceções de unchecked.
4 TRATAMENTO DE EXCEÇÕES EM JAVA DO TIPO CHECKED

Existe um tipo de exceção em que o método construtor da classe obriga a
realizar o tratamento de um determinado tipo de exceção, que é a exceção checked,
pois conforme você pode perceber, ao implementar o código-fonte, o compilador
realiza a validação se a exceção, obrigatória no método construtor da classe, está
sendo tratada.
Para exemplificar este tipo de exceção, pode ser analisado o exemplo

apresentado na Figura 27, o qual serve para abrir um arquivo qualquer para
leitura. Neste caso, o método construtor da classe “FileInputStream” obriga a
ser tratada um determinado tipo de exceção, para realizar o tratamento, caso o
arquivo não existe, esteja corrompido ou ainda esteja sendo alocado por outro
programa e não possa ser aberto. Perceba neste código-fonte que na Linha 8, a
IDE Eclipse sinaliza que existem um erro; embora o código-fonte esteja correto, o
código-fonte não compila enquanto o problema não for resolvido.
122
FIGURA 27 – EXEMPLO ABERTURA ARQUIVO SEM TRATAMENTO
FONTE: O autor
Neste sentido, se você colocar o cursor com o mouse sobre a linha

sinalizada com erro, na IDE Eclipse será apresentada uma caixa apresentando
o motivo do erro, conforme apresentado na Figura 28. Perceba que a
mensagem informa que é necessário realizar o tratamento da exceção do tipo
FileNotFoundException.
FIGURA 28 – EXEMPLO ABERTURA ARQUIVO SEM TRATAMENTO
FONTE: O autor
Para resolver o problema tratando a exceção, o Eclipse possui um

recurso quase automático para realizar o tratamento, sem precisar programar
manualmente. Para isso, clique com o mouse no “X”, conforme sinalizado com a
seta em vermelho na Figura 29.
123
E MULTIDIMENSIONAIS
FIGURA 29 – SOLUÇÃO AUTOMÁTICA DO ECLIPSE PARA GERAR TRATAMENTO DE ERRO
FONTE: O autor
Após clicar no “X”, conforme Figura 29, será apresentada uma caixa que
permite selecionar duas opções de tratamento, sendo uma delas a “Add throws
declaration”, que inclui o tratamento no método atual, sendo que o erro pode ser
tratado pelo código que o invocou.
FIGURA 30 – TRATAMENTO DE ERRO UTILIZANDO A OPÇÃO ADD THROWS DECLARATION
FONTE: O autor
A outra opção que permite o tratamento automatizado pelo Eclipse,

referente à Figura 29, é a opção “Surround with try/catch”, a qual inclui
automaticamente o tratamento de exceção dentro do código-fonte, conforme
exemplos anteriores apresentados. Este tipo de tratamento você pode analisar na
Figura 31, e, além disso, na Linha 14 deste código-fonte, você pode analisar como
capturar o rastreamento de pilha (stack trace) através do método printStackTrace.
124
FIGURA 31 – TRATAMENTO DE ERRO UTILIZANDO A OPÇÃO SURROUND WITH TRY/CATCH
FONTE: O autor
Dependendo da situação, as vezes é melhor utilizar a opção “Add throws

declaration” para passar o tratamento para o método que invocou o método atual,
mas em muitos casos é melhor realizar o tratamento no próprio método. Sendo
assim, esta decisão depende do ponto em que existe o problema e se é possível
realizar o tratamento neste local.
Em muitas situações, é necessário realizar o tratamento de mais de uma

situação ao mesmo tempo, isto é, mais de um tipo de exceção deve ser tratada.
Neste caso, são utilizadas duas ou mais cláusulas catch, conforme apresentado
na Figura 32, onde você pode perceber que foi realizado o tratamento para o tipo
de exceção “InputMismatchException” e outro tratamento para o tipo de exceção
“ArithmeticException”.
FIGURA 32 – MAIS DE UM TRATAMENTO DE EXCEÇÃO AO MESMO TEMPO
FONTE: O autor
125
E MULTIDIMENSIONAIS
5 CLASSE THROWABLE
É interessante você conhecer a classe Throwable, a qual é a superclasse para
tratamento de todos os erros e exceções que podem ocorrer em um programa
desenvolvido com a linguagem Java. Neste sentido, somente objetos que são
instâncias desta classe, isto é, uma de suas subclasses, podem ser lançados
pela JVM (Java Virtual Machine), ou ainda podem ser lançados pelo comando
Java throw. Com isso, essa classe ou uma de suas subclasses pode ser o tipo
de argumento para o tratamento em uma cláusula catch. Assim, para fins de
verificação de exceções em tempo de compilação, a classe Throwable, assim como
suas subclasses, e que também não seja uma subclasse de RuntimeException ou
Error, é considerada exceção verificada (checked).
Além disso, as instâncias de duas subclasses, Error e Exception, são

utilizadas para realizar indicação de que ocorreram situações excepcionais
(determinadas exceções). Neste caso, essas instâncias são criadas no contexto de
uma situação excepcional, incluindo informações relevantes para o rastreamento
da pilha, isto é, apresentando o local onde ocorreu o erro e qual o erro ocorrido.
Uma classe throwable pode conter uma cadeia de mensagens, que fornecem
mais informações sobre o erro, assim como sua causa, facilitando a identificação
para o tratamento e correção. Neste sentido, a essas informações que formam
uma cadeia dá-se o nome de recurso de exceção encadeada, pois o motivo pode
ter uma causa, levando a uma cadeia de exceções, sendo uma causada por outra.
Para você entender melhor esta cadeia de exceções, pense em um erro que
pode ter uma causa em uma determinada linha de um método, o qual é invocado
por outro método que recebe um valor como retorno, por exemplo. Como o
último método, onde realmente ocorreu o problema, retornou um objeto null,
então o método que o invocou também terá o ocasionamento de uma exceção,
pois ao utilizar o objeto com valor null, ocorrerá outro erro, e assim se formam
as cadeias de exceções. Neste sentido, a classe que lança a exceção é construída
sobre uma abstração em camadas inferiores, e uma operação na camada superior
falha devido a uma falha na camada inferior.
A classe Throwable e suas subclasses possuem dois construtores, um que

não aceita argumentos, isto é, parâmetro, e outro que aceita um argumento String
que pode ser utilizado para produzir uma mensagem detalhada. Além disso, as
subclasses que provavelmente têm uma causa associada a elas devem ter mais
dois construtores, um que usa Throwable (a causa) e outro que usa uma String (a
mensagem detalhada) e uma Throwable (a causa).
126
6 REALIZANDO O LANÇAMENTO DE EXCEÇÕES

As cláusulas throw e throws podem ser compreendidas como sendo ações
que lançam exceções, isto é, em determinadas situações existem exceções que não
podem ser tratadas no mesmo método onde foi gerada a exceção. Nestes casos, é
necessário propagar a exceção para um nível acima, isto é, jogar a exceção para o
código que invocou o método atual.
Agora, analise novamente o método “sacarDinheiro”, o qual é apresentado

na Figura 33. Neste método, é retornado um valor booleano, sendo retorno true se
conseguiu realizar o saque, e caso contrário, retorna o valor false.
FIGURA 33 – MÉTODO SACARDINHEIRO
FONTE: O autor
Para evitar que seja esquecido de realizar uma condição (comando if)
para validar se o retorno do método “sacarDinheiro” teve sucesso, é possível
lançar uma exceção (Exception), garantindo que caso a validação não seja
implementada, o processo seja abortado.
Neste sentido, o termo throw, palavra reservada do Java, realiza o

lançamento de uma exceção (Exception), abortando o processo atual, equivalente
às exceções que você já estudou até aqui. Além disso, existe a palavra reservada
throws, que apenas sinaliza sobre a possibilidade do método que pode ocorrer
erro lançar uma exceção, obrigando o método que invocou o método que pode
ocorrer a exceção a tratar a exceção em questão.
Neste sentido, analise o código-fonte do método “sacarDinheiro”

na Figura 34, onde na Linha 22 você pode perceber a utilização da classe
“RuntimeException” para causar exceção caso o fluxo de execução entre na
condição do valor do parâmetro “valorSaque” ser maior que o valor do saldo
mais o limite.
127
E MULTIDIMENSIONAIS
FIGURA 34 – EXEMPLO DE USO DO THROW
FONTE: O autor
A classe RuntimeException é a exception mãe de todas as exceções não

checadas (exceptions unchecked), possuindo desvantagem por ser muito genérica.
Desta forma, o código que invocou o método “sacarDinheiro” receberá um erro
genérico, não sabendo exatamente qual foi o problema.
É possível utilizar uma Exception mais específica, conforme apresentado

na Figura 35, onde foi utilizado o tipo IllegalArgumentException de Exception. Este
tipo de exceção apresenta o erro um pouco mais detalhado, sendo uma Exception
unchecked, pois ela estende de RuntimeException, a qual faz parte da biblioteca
do Java. Assim, a classe IllegalArgumentException pode ser uma melhor opção
quando um argumento é inválido, por exemplo, números negativos, referências
nulas, entre outros.
128
FIGURA 35 – EXEMPLO DE USO DA CLASSE ILLEGALARGUMENTEXCEPTION
FONTE: O autor
O código-fonte do método “sacarDinheiro” da Figura 35 retorna um erro

genérico, mas é possível melhorar a mensagem do erro passando por parâmetro
uma mensagem, para posteriormente ser pega com o controle de exceção e ser
apresentada ao usuário, por exemplo. Neste sentido, basta incluir a mensagem
personalizada, conforme Linha 26 do código-fonte apresentado na Figura 36.
Com isso, através do método getMessage(), na linha 11 do código-fonte

da Figura 36, o qual está definido na classe Throwable, classe mãe de todas as
exceptions e erros, pode ser utilizado para capturar a mensagem que passamos
por parâmetro ao causar uma exceção na linha 26 do código-fonte da Figura 36.
129
E MULTIDIMENSIONAIS
FIGURA 36 – UTILIZAÇÃO DE MENSAGEM PERSONALIZADA PARA EXCEÇÃO
FONTE: O autor
Ao executar o código-fonte da classe ProgramaConta da Figura 36, como

foi passado por parâmetro um valor acima do saldo da conta, é impresso no
console a mensagem personalizada, conforme apresentado na Figura 37.
FIGURA 37 – MENSAGEM CAPTURADA E IMPRESSA NO CONSOLE DO ECLIPSE
FONTE: O autor
130
7 CRIANDO AS PRÓPRIAS EXCEÇÕES

Da mesma forma que são criadas outras classes de domínio, isto é, para
solução de algum problema, como uma classe Pessoa, Funcionario, Carro, entre
outras, na linguagem de programação Java é possível criar classes que herdam
da classe mãe das exceções, a Exception. Através de uma classe que herda da
Exception, é possível criar exceções específicas para uma determinada solução,
conforme você pode analisar o código-fonte da Figura 38, a qual apresenta a
classe “SemNumeroException” que realiza esta herança.
FIGURA 38 – EXEMPLO DE UMA CLASSE CRIADA COM EXCEÇÃO ESPECÍFICA
FONTE: O autor
Desta forma, você pode entender a necessidade de criar uma classe

de exceção, específica para uma situação em que se esteja realizando algum
processo e falte algum dado para realizar a operação. Assim, é possível realizar
uma validação através desta exceção, conforme apresentado entre as linhas 8
e 9 do código-fonte da Figura 39, onde você pode perceber que é validado se
existe o caracter “1” ou “2” na cadeia de caracteres da variável “fraseTeste”, e,
neste sentido, se tiver um dos dois, a execução do programa prossegue, e caso
contrário, é executada a exceção.
FIGURA 39 – EXEMPLO DE UTILIZAÇÃO DA CLASSE DE EXCEÇÃO PERSONALIZADA
FONTE: O autor
131
E MULTIDIMENSIONAIS
8 CLÁUSULA FINALLY
Este bloco serve para executar comandos, garantindo que estes sejam
executados mesmo que ocorra alguma exceção durante o processo anterior a este
bloco. Por exemplo, em um método existe a conexão com o banco de dados aberta,
um objeto chamado "conn" do tipo Connection, que você estudará mais adiante
neste livro e dentro deste método existe o tratamento de exceção (try/catch), e
em alguma linha dentro do bloco tratado, ocorra uma exceção, então a execução
passará para o bloco da cláusula catch, e, em seguida, obrigatoriamente para a
finally, realizando o fechamento da conexão com o banco de dados, realizando
a execução do comando "close" do objeto "conn". Neste sentido, assim que uma
exceção é lançada, e for preciso que um determinado comando seja realizado, é
utilizada a cláusula finally. Salienta-se que o método printStackTrace é fornecido
pela classe Throwable, que é útil para manipular exceções (SCHILDT, 2015).
FIGURA 40 – EXEMPLO DE UTILIZAÇÃO DA CLÁUSULA FINALLY
FONTE: O autor
132
Neste sentido, conforme apresentado na Figura 40, analise a Linha 11 do

código-fonte, no qual a variável “quantidadeTotal” é um objeto do tipo Integer,
que está sendo inicializada com valor null, isto é, não existe em memória este
objeto, o qual não pode ser utilizado enquanto tiver valor null. Neste caso, na
linha 13 do código-fonte está sendo realizado um cálculo dedivisão, porém, como
a variável “quantidadeTotal” possui valor null, e esta é o divisor, será gerada
uma exceção, mas o objeto “conn” possui a conexão com o banco de dados aberta.
Para evitar que a conexão com o banco de dados, objeto “conn”, fique aberta após
a geração da exceção, foi implementado na linha 22, dentro da cláusula finally,
o fechamento da conexão. Note que na linha 21 é realizada uma validação para
garantir que o objeto “conn” esteja instanciado, isto é, criado em memória, caso
contrário, se estivesse null, geraria outro erro, e teria que ser tratado também. Com
isso, não importa a exceção que ocorrer dentro do bloco tratado com a cláusula
catch, mas o fluxo do programa sempre executará a cláusula finally, realizando o
fechamento da conexão com o banco de dados.
Um detalhe interessante é você entender como realizar validação com

uma variável do tipo String, para a qual, se você precisar comparar seu valor
com outro valor, por exemplo, você utiliza o método “equals”, passando por
parâmetro o valor desejado para a comparação, podendo ser outra variável ou
ainda um valor fixo. Na Figura 41 é apresentado um exemplo da utilização do
método “equals” da classe String, conforme pode ser analisado na Linha 17 do
código-fonte, onde a variável “erro”, objeto do tipo String, é apenas inicializada,
então ela possui valor vazio, isto é, sem valor, e, neste caso, não importa se gerada
exceção ou não, o programa será finalizado no comando finally, apresentando a
mensagem para o usuário.
FIGURA 41 – EXEMPLO DE UTILIZAÇÃO DA CLÁUSULA FINALLY
FONTE: O autor
133
RESUMO DO TÓPICO 2
• Uma exceção em um programa pode ocorrer quando alguma situação

imprevista acontece, podendo ser causadas de erros de lógica ou ainda por
acesso a recursos que não estejam mais disponíveis em memória para utilização,
como objetos.
• São exemplos de situações que podem causar exceção: abertura de um arquivo

que não existe ou o diretório informado esteja errado; tentativa de alterar
um arquivo sem permissão; consulta em banco de dados, o qual não esteja
disponível; erro em um comando SELECT, ao ser executado; entre outros.
• Uma exceção (exception) muito comum é a tentativa de acessar um objeto que

esteja com valor null, isto é, não esteja criado em memória para utilizar seus
métodos e atributos.
• Para o tratamento de exceções em Java, utiliza-se os comandos try, para abrir o

bloco de tratamento de erro, e então a cláusula catch, onde pode ser recebido o
erro para tratamento, e a cláusula finally quando é necessário executar algum
comando mesmo que ocorra uma exceção.
• Muitas vezes, quando se é necessário lançar uma exceção proposital, para

validar algum dado, por exemplo, pode ser utilizado o comando “throw new
Exception”, ou uma das subclasses de Exception.
134
AUTOATIVIDADE
1 Independente da linguagem de programação utilizada para o desenvolvimento

de software, muitas são as regras ou cálculos implementados dentro do
código-fonte. Neste sentido, muitos erros podem acontecer no código-fonte
de um programa, podendo ser um erro de cálculo, ou alguma variável que
recebe o valor null, causando uma exceção. Referente às exceções (exceptions)
que podem ocorrer na execução de um programa, assinale a alternativa
CORRETA:
a) ( ) Exceção é apenas um erro ocasionado por uma falha do desenvolvedor.

b) ( ) Um programa desenvolvido coerentemente não pode gerar nenhum
tipo de exceção.
c) ( ) Na linguagem de programação Java, se ocorrida uma exceção, o
programa é abortado, não havendo uma forma de evitar este problema.
d) ( ) Exceção pode ser descrita como sendo um erro durante o tempo de
execução de um programa.
2 As linguagens de programação atuais possuem vários recursos que facilitam

o trabalho de desenvolvimento, inclusive o tratamento de exceções. Referente
às exceções (exceptions) que podem ocorrer na execução de um programa,
assinale a alternativa CORRETA:
a) ( ) Ao ser implementado um cálculo de divisão, caso o valor a ser dividido

seja uma variável com valor zero, será gerada uma exceção.
b) ( ) Caso seja realizada a conversão do valor “12”, de uma variável do tipo
String, para uma variável do tipo int será gerada uma exceção.
c) ( ) Ao ser implementado um cálculo de divisão, caso o divisor for uma
variável com valor zero, será gerada uma exceção.
d) ( ) Se ocorrida alguma exceção durante a execução de um programa, na
linguagem de programação Java, não existe uma forma de evitar o
aborto da execução, pois esta será encerrada.
3 Muitas são as exceções que podem ocorrer durante a execução de um

programa, independentemente da linguagem de programação que este foi
implementado. Referente às exceções (exceptions) durante a execução de
programas, assinale a alternativa CORRETA:
a) ( ) Para capturar as mensagens de erro de uma exceção, deve ser utilizado

o comando throw new Exception.
b) ( ) Para capturar o rastro de pilha, isto é, o passo a passo das invocações
dos métodos até chegar ao ponto do programa onde ocorreu a exceção,
deve ser utilizado o método printStacktrace.
135
c) ( ) O bloco finally deve ser utilizado para realizar a captura das mensagens
de erro de exceções ocorridas durante a execução de um programa,
sendo tratado pelo bloco try.
d) ( ) Durante a execução de um programa, quando ocorre alguma exceção,
seja por uma validação realizada ou por algum erro, ao se capturar o
erro dentro da cláusula catch, é possível saber apenas em qual classe
ocorreu o problema, não sendo especificada a linha do código-fonte
desta classe.
4 Muitas são as regras que devem ser implementadas para satisfazer as

funcionalidades de um software, como a realização de um cálculo ou ainda
a validação de algum dado errado que pode ser informado pelo usuário.
Neste sentido, implemente uma classe, conforme você já aprendeu, na qual
seja inicializada uma variável do tipo Double chamada “valorCarro”, e outra
variável do tipo double ou Double “percentualJuros”. Além destas duas, crie
também uma terceira variável “valorJuros”, a qual deve ser inicializada com
zero e ser utilizada para receber o valor do cálculo dos juros. Implemente
o tratamento de erros neste código-fonte, capturando o rastreamento de
pilha, inicializando a variável “valorCarro” com um determinado valor que
gere uma exceção. Defina o nome da classe como sendo “AutoAtividade4”.
5 O tratamento de exceções em qualquer linguagem de programação é muito

importante, o que pode evitar sérios problemas, como a metade da gravação
de dados de um processo. Neste sentido, implemente uma classe em Java
chamada “Carro”, criando nela um método chamado “calcularAutonomia”.
Este método deve ter os parâmetros Double quilometrosRodados e
Double litrosCombustivel, sendo realizado o cálculo de autonomia para
saber quantos quilômetros por litro um carro realiza. Além disso, crie
uma segunda classe chamada “AutoAtividade5”, a qual deve possuir o
método de execução “main”, sendo neste, criado um objeto do tipo Carro,
declarada a variável “km” do tipo Double, a qual deve ser inicializada com
valor null. Além disso, declare uma segunda variável “litrosGasolina”, do
tipo double, inicializada com valor 10. Neste sentido, realize a invocação
do método “calcularAutonomia” passando por parâmetros as variáveis
criadas na classe AutoAtividade5. Implemente o tratamento de erros para
ser capturada a mensagem de erro, podendo ser atribuída a uma variável,
que no final da execução, se ocorrida uma exceção, seja apresentado ao
usuário “Houve o erro xxxx!”, sendo xxxx o valor capturado do erro, e caso
não ocorrer exceção, então apresentar ao usuário a mensagem “Execução
bem sucedida!”. Para apresentação da mensagem final ao usuário, utilize a
biblioteca JoptionPane.
136
UNIDADE 2 TÓPICO 3
PACOTES JAVA.LANG, JAVA.IO E VETORES
1 INTRODUÇÃO
Até esse ponto, você aprendeu os conceitos básicos de orientação a
objetos, isto é, como criar classes, atributos e métodos, e implementar aplicações
com estes conceitos. Além disso, você também aprendeu a criar tratamentos de
exceções dentro de programas, controlando exceções ou erros, assim como criar
suas próprias exceções. Agora que você já conhece todos esses conceitos, além
dos conhecimentos básicos da linguagem de programação Java adquiridos na
unidade anterior, este tópico apresenta alguns dos principais pacotes utilizados
no desenvolvimento de aplicações Java: java.lang e java.io.
Além dos pacotes java.lang e java.io do Java, são apresentados conceitos e

práticas sobre arrays ou vetores na linguagem de programação Java, assim como
arrays multidimensionais, também chamados de matrizes, os quais são muito
utilizados para armazenar lista de objetos ou de dados para utilização nas mais
variadas lógicas.
Neste sentido, é muito importante que você, acadêmico, estude com

bastante dedicação cada um destes conceitos, e implemente na prática todos os
exemplos, isto é, desenvolva os códigos-fonte na IDE Eclipse, para que, além do
entendimento conceitual, você os compreenda na prática, facilitando seu estudo
e permitindo que você consiga evoluir nesta linguagem de programação.
2 PACOTE JAVA.LANG
Até este momento, você já utilizou muitas vezes as classes String e System,
sendo a classe System um tipo utilizado para variáveis, que na verdade são objetos
deste tipo, e a classe System, utilizada várias vezes para a invocação do método
“System.out.print” para impressão de mensagens no console. Em nenhuma
utilização das classes deste pacote foi necessário realizar a importação manual
do pacote, pois é o único pacote que automaticamente é realizada a importação.
Dentre outras classes no pacote java.lang, uma delas é a classe System,

sendo importada por java.lang.System, a qual possui vários campos e métodos
necessários para muitas soluções recorrentes em projetos. Além disso, a classe
System não pode ser instanciada.
137
E MULTIDIMENSIONAIS
A implementação da classe java.lang.System pode ser analisada clicando

sobre a classe, isto é, quando está sendo invocado o método System.out.println("”),
por exemplo, basta clicar sobre System, ou mesmo no método “println”, dentro da
IDE Eclipse, que automaticamente será aberta a implementação da classe.
Os três campos de saída da classe System são:
• static PrintStream: é o fluxo de saída padrão de erro;

• static InputStream: é o fluxo de entrada padrão;
• static PrintStream: é o fluxo de saída padrão;
DICAS
Acesse o link https://docs.oracle.com/javase/7/docs/api/java/lang/System.

html da Oracle, e conheça mais sobre a classe System, inclusive sobre outros métodos
disponíveis.
Ao ser analisada a documentação da Oracle, é possível entender que o

atributo out é do tipo PrintStream, o qual pertence ao pacote java.io, que será
visto mais adiante. Além disso, a classe System possui um método que serve para
retornar um código de erro para o sistema operacional, o qual é o System.exit(0).
Um dos métodos que você pode utilizar muitas vezes, como já deve
ter utilizado em exercícios práticos anteriores, é o System.out.println, utilizado
frequentemente para rastrear a execução de um programa, imprimindo valores
ou passos executados, por exemplo.
Quando temos um método que recebe o parâmetro de um determinado

tipo, para que seja possível enviar um parâmetro de outro tipo, é necessário
criar uma sobrecarga, conceito que pode ser entendido por ser uma duplicação
do método que se deseja, mas com parâmetros diferentes. No caso do método
System.out.println, ele permite passar qualquer valor ou objeto como parâmetro,
e não possui sobrecarga, sendo possível enviar por parâmetro para este método
qualquer objeto de qualquer tipo de classe. Analise a Figura 42, cujo código-fonte
está invocando o método “println”, para o qual está sendo enviado o objeto do
tipo Conta, sendo executado sem exceções, isto é, sem erros.
138
TÓPICO 3 | PACOTES JAVA.LANG, JAVA.IO E VETORES
FIGURA 42 – EXEMPLO DE OBJETO ENVIADO POR PARÂMETRO PARA MÉTODO PRINTLN
FONTE: o autor
Isso é possível, pois quando é criada uma classe, ela é obrigada a realizar
herança de uma outra classe, ou seja, para toda classe criada, esta nova classe
herda de uma superclasse. Neste sentido, o println aceita qualquer objeto passado
para ele por parâmetro. No entanto, até agora, na maioria dos exemplos deste
livro, não foram criadas muitas classes que herdam de uma superclasse, ou classe
mãe, como no código-fonte apresentado na Figura 42, por exemplo.
Neste sentido, caso não exista a palavra reservada extends, conforme

você estudou no tópico de orientação a objetos, o Java considera a herança da
classe System.Object, também disponibilizada no pacote java.lang. Você pode
implementar uma classe definindo a herança da classe System.Object, conforme o
código-fonte da classe Pessoa apresentado na Figura 43, o que não é necessário, e
dificilmente algum desenvolvedor implementa uma classe desta forma, embora
o Java permita e a classe possa ser instanciada ou executada normalmente. Ainda
na Figura 43, no código-fonte da classe Funcionario, você pode perceber a herança
da classe Pessoa, isto é, utilizada a palavra reservada extends seguida da classe
Pessoa.
139
E MULTIDIMENSIONAIS
FIGURA 43 – EXEMPLOS DE IMPLEMENTAÇÃO DE HERANÇA
FONTE: O autor
Com isso, toda classe em Java herda da classe System.Object, e, neste

contexto, qualquer classe Java possui todos os métodos da classe Object.
140
Conforme descrito no início, pode ser passado por parâmetro do método

println qualquer objeto do tipo de qualquer classe, pois é utilizado o método
toString, herdado da classe Object, para realizar sua impressão no console. O
método toString da classe System.Object retorna o nome da classe mais o sinal
@ e por último um número que o identifica, conforme exemplificado na Figura
44, onde foi criada uma variável do tipo String que recebe o conteúdo retornado
pelo método toString, o qual é impresso no console e você pode analisar na guia
“Console” da IDE Eclipse apresentada.
FIGURA 44 – EXEMPLO DE INVOCAÇÃO DE MÉTODO PRINTLN SENDO UM OBJETO

O PARÂMETRO ENVIADO
FONTE: O autor
Assim como o método toString da classe Object, todas as classes criadas

na linguagem de programação Java possuem também, além de outros, o método
“equals”, o qual apresenta a finalidade de comparar objetos do mesmo tipo, isto
é, temos dois objetos do tipo Funcionario, e é necessário comparar se ambos são
iguais.
141
E MULTIDIMENSIONAIS
O método equals somente realiza a comparação das referências de objetos,

isto é, quando um novo objeto é criado (realizada instância de uma classe), está
sendo executado o comando new, e neste caso a referência de cada objeto criado é
diferente uma da outra, não importando se os valores dos atributos são iguais. A
Figura 45 apresenta um exemplo para esta situação, cujo código-fonte, na Linha
12 é invocado o método equals, e como você pode analisar, entre as linhas 6 e 10
foram criados dois objetos de mesmo tipo, inclusive com valores de atributos
iguais, porém a saída no console apresenta a mensagem “Objetos diferentes”.
FIGURA 45 – EXEMPLO DE UTILIZAÇÃO DO MÉTODO EQUALS
FONTE: O autor
Agora analise o código-fonte apresentado na Figura 46, onde o mesmo

objeto é instanciado duas vezes, ou seja, possui a mesma referência, e, neste caso,
a saída no console é a regra de que os objetos são iguais, pois na Linha 12 está
sendo comparado ao mesmo objeto.
142
FIGURA 46 – EXEMPLO DE UTILIZAÇÃO DO MÉTODO EQUALS
FONTE: O autor
3 O PACOTE JAVA.IO
Em determinadas aplicações, existe a necessidade de realizar o

gerenciamento de arquivos e diretórios, isto é, criar, excluir ou copiá-los para
outros locais do próprio computador, ou ainda para algum local específico de
uma rede, como o diretório de um servidor, por exemplo. Para isso, sistemas
operacionais oferecem comandos, através do shell, para estas funcionalidades,
sendo possível executá-los diretamente de uma aplicação Java, embora não seja o
ideal, pois torna a aplicação diretamente relacionada com o sistema operacional.
Assim sendo, quando é necessário que um software seja migrado de

uma plataforma para outra, ou sistema operacional diferente, não é necessária
adaptação do sistema, pois o Java é multiplataforma e oferece comandos genéricos
para realizar a manipulação de arquivos e diretórios.
Assim como o pacote java.lang, o pacote java.io oferece mecanismos

para realizar estas funcionalidades, isto é, o controle de entrada e saída de
dados, chamado de io (Input/Output), é orientada a objetos, utilizando os
principais conceitos que você estudou nesta unidade, ou seja, classes, interfaces e
polimorfismo (FRIESEN, 2015).
143
E MULTIDIMENSIONAIS
Neste sentido, a ideia do polimorfismo para o pacote java.io é utilizar

fluxos de entrada (InputStream) e de saída (OutputStream) para qualquer
operação, isto é, podendo ser a geração de um arquivo, a leitura ou gravação de
um campo do banco de dados do tipo blob, ou então entrada e saída de texto de
um programa, como entrada pelo teclado, por exemplo (JANA, 2005).
DICAS
A classe InputStream é uma classe abstrata, sendo a superclasse de todas as

classes que representam um fluxo de entrada de bytes. A classe OutputStream é uma classe
abstrata, sendo a superclasse de todas as classes que representam um fluxo de saída de
bytes. Para conhecer mais sobre o pacote java.io, acesse https://docs.oracle.com/javase/7/
docs/api/java/io/package-summary.html.
Para as funcionalidades de tratamento de arquivos, o pacote java.io

oferece a classe File, a qual permite a manutenção de arquivos, isto é, criação,
exclusão e cópia ou transferência de um arquivo de um local para outro, assim
como streams para realizar gravação e leitura de arquivos.
A classe java.io.File começou a ser disponibilizada a partir do JDK 1.0,

oferecendo a abstração de arquivos como sendo recursos, e, neste sentido,
ocultando detalhes do funcionamento do sistema operacional (FRIESEN, 2015).
4 CLASSE FILE
Segundo Friesen (2015), uma determinada instância da classe File possui
o objetivo de selecionar um arquivo ou diretório do sistema, disponibilizando
vários comandos para realizar a manipulação do recurso solicitado. Ainda
segundo Friesen (2015), os construtores da classe File são:
• File(File parent, String child): cria uma nova instância de um objeto do tipo File
com o caminho informado pelo parâmetro parent concatenado com o valor do
parâmetro child.
• File(String pathname): cria uma nova instância de um objeto do tipo File com o
caminho informado no parâmetro do tipo String, sendo o caminho completo
até o arquivo.
• File(String parent, String child): cria uma nova instância de um objeto do tipo
File com o caminho informado no parâmetro parent do tipo String, concatenado
com o valor do parâmetro child, também do tipo String.
• File(URI uri): cria uma nova instância de arquivo convertendo o URI do arquivo
especificado no parâmetro em um nome de caminho abstrato.
144
DICAS
Para conhecer mais sobre a classe File do pacote java.io, acesse https://docs.
oracle.com/javase/7/docs/api/java/io/File.html.
Neste sentido, você pode analisar o código-fonte apresentado na Figura

47, no qual você pode perceber que foi realizado o tratamento de erro, através
do comando throws IOException no método main, sendo obrigatório, pois o
Eclipse aponta o erro logo que implementado o código. Além disso, na linha 9,
é apresentada a instância da classe File, sendo utilizado o construtor que possui
apenas o parâmetro do tipo String. Ainda neste código-fonte, ao ser executado,
caso o arquivo não existir, como foi o caso da execução apresentada na figura, é
impressa a mensagem “Arquivo criado com sucesso!”, e caso o arquivo já existisse,
seria apresentada a mensagem “Arquivo não criado pois já existe!”. A criação de
um arquivo é bem simples, desde que o caminho enviado ao parâmetro seja válido.
FIGURA 47 – EXEMPLO DE CRIAÇÃO DE ARQUIVO
FONTE: O autor
145
E MULTIDIMENSIONAIS
A exclusão de um arquivo utilizando a classe File é bem simples, bastando

criar um objeto do tipo File, conforme Linha 9 do código-fonte apresentado
na Figura 48, onde foi passado por parâmetro do método construtor da classe
o diretório completo do arquivo. Na Linha 11 deste código-fonte é invocado
o método delete da classe File, e caso seja efetuada a exclusão com sucesso, a
mensagem da Linha 12 é impressa no console.
FIGURA 48 – EXEMPLO DE EXCLUSÃO DE ARQUIVO
FONTE: O autor
5 CLASSE FILEINPUTSTREAM
A classe FileInputStream, disponibilizada no pacote java.io, representa a
classe abstrata InputStream, e, neste caso, a classe FileInputStream é derivada da
classe InputStream, a qual realiza a leitura de bytes de um arquivo, e a entrada
de um arquivo pode ser pelo nome de um arquivo. Segundo Jana (2005), a classe
FileInputStream realiza a leitura de um arquivo, através de seus bytes, podendo
ser qualquer arquivo, como uma imagem por exemplo. A classe FileInputStream
possui os seguintes construtores:
146
• FileInputStream(File file): cria um objeto do tipo FileInputStream realizando uma

conexão com um arquivo real (tipo File).
• FileInputStream(FileDescriptor fdObj): cria um objeto do tipo FileInputStream
utilizando o descritor de arquivo fdObj, passado por parâmetro, o qual
representa uma conexão existente com um arquivo real.
• FileInputStream(String name): cria um objeto do tipo FileInputStream abrindo
uma conexão com o arquivo real, passado pelo parâmetro do tipo String, o
qual possui o caminho completo do arquivo.
DICAS
Para conhecer mais sobre a classe FileInputStream do pacote java.io, acesse

https://docs.oracle.com/javase/7/docs/api/java/io/FileInputStream.html.
Neste sentido, conforme você pode analisar no código-fonte da Figura 49,

na Linha 9 foi criado um objeto do tipo FileInputStream para realizar a leitura de
um arquivo, sendo utilizado o construtor que requisita apenas uma String com o
caminho completo do arquivo.
FIGURA 49 – EXEMPLO DE UTILIZAÇÃO DA CLASSE FILEINPUTSTREAM PARA LEITURA

DE ARQUIVO
FONTE: O autor
147
E MULTIDIMENSIONAIS
No entanto, ao executar o código-fonte da Figura 49, como a classe

FileInputStream realiza a leitura de um arquivo em bytes, ao ser impresso o
conteúdo da variável “data”, conforme Linha 14, você terá o resultado apresentado
na Figura 50, onde você pode visualizar uma parte da impressão, sendo os bytes
de cada caractere lido do arquivo.
FIGURA 50 – EXEMPLO DE IMPRESSÃO DE BYTES LIDOS PELA CLASSE FILEINPUTSTREAM
FONTE: O autor
Neste sentido, para ser implementado um código que leia o arquivo e

seja impresso ou capturado o texto exatamente como está no arquivo, legível
para o ser humano, na Figura 51 foi utilizada outra classe do pacote java.io em
conjunto com a FileUnputStream, a ByteArrayOutputStream, conforme você pode
analisar nas linhas 13 e 17.
148
FIGURA 51 – EXEMPLO DE IMPRESSÃO DE BYTES LIDOS PELA CLASSE FILEINPUTSTREAM

CONVERTIDO
FONTE: O autor
O resultado do código-fonte da Figura 51 é justamente a impressão das

linhas do arquivo, legíveis para nossa leitura.
6 CLASSE FILEOUTPUTSTREAM
Agora que você já aprendeu a realizar a leitura de um arquivo qualquer,
assim como imprimir o conteúdo lido, faltou você aprender a realizar a gravação
de um arquivo, isto é, ler um arquivo qualquer e sobrescrever seu conteúdo.
Neste sentido, a classe FileOutputStream auxilia nesse processo, a qual é

derivada da classe OutputStream, que escreve bytes em um arquivo disponibilizado
em algum local (JANA, 2005). Para realizar a escrita em um arquivo de bytes
esta classe pode ser utilizada, e para a escrita de caracteres, pode ser utilizada a
classe FileWrites. Ainda segundo Jana (2005), a classe FileOutputStream possui os
seguintes construtores:
149
E MULTIDIMENSIONAIS
• FileOutputStream(File file): cria um fluxo de saída de arquivo para gravar no

arquivo representado pelo objeto File especificado.
• FileOutputStream(File file, boolean append): cria um fluxo de saída de arquivo para
gravar no arquivo representado pelo objeto File especificado, cujo parâmetro
append especifica, caso tenha valor true, adiciona linhas ao arquivo, e caso tenha
valor false o sobrescreve.
• FileOutputStream(FileDescriptor fdObj): cria um fluxo de saída de arquivo para
gravar no descritor do arquivo especificado, o que representa uma conexão
existente com um arquivo real no sistema.
• FileOutputStream(String name): cria um fluxo de saída de arquivo para gravar
no arquivo com o nome especificado.
• FileOutputStream(String name, boolean append): cria um fluxo de saída de arquivo
para gravar no arquivo com o nome especificado.
DICAS
Para saber mais sobre a classe FileOoutputStream, acesse https://docs.oracle.

com/javase/7/docs/api/java/io/FileOutputStream.html.
Neste contexto, você pode analisar o código-fonte da Figura 52, o qual

apresenta a leitura de um determinado arquivo, sendo o mesmo arquivo de
exemplos anteriores. Na Linha 11 deste código-fonte é criado um objeto do tipo
FileOutputStream, o qual é carregado com o arquivo desejado, e nas linhas 12 e 13
é passado byte para a gravação no arquivo. Note que na Linha 11 foi utilizado o
método construtor que possui dois parâmetros, o primeiro sendo a String com o
caminho completo do arquivo, e o segundo para especificar se é para adicionar
um texto ou para sobrescrever o arquivo. Neste caso, se o valor do parâmetro
append estiver true, apenas será adicionado o texto, e caso estiver false, o antigo
conteúdo do arquivo será sobrescrito.
150
FIGURA 52 – GRAVAÇÃO DE BYTES NO ARQUIVO PELA CLASSE FILEOUTPUTSTREAM
FONTE: O autor
Agora, alterando nosso código-fonte para realizar a gravação de um

texto em forma de String, legível, conforme pode ser analisado o código-fonte
da Figura 53.
FIGURA 53 – GRAVAÇÃO DE UMA STRING EM ARQUIVO, UTILIZANDO A CLASSE

FILEOUTPUTSTREAM
FONTE: O autor
151
E MULTIDIMENSIONAIS
Neste sentido, no código-fonte da Figura 53 foi criada uma variável

do tipo String, na linha 9, a qual possui o texto desejado para gravação no
arquivo. Note que na Linha 11, o segundo parâmetro do construtor da classe
FileOuputStream possui, agora, valor false, indicando que o conteúdo do arquivo
será sobrescrito. Na Linha 12, foi realizada uma pequena alteração, em que
foi passado por parâmetro do método write, a variável do tipo String criada,
chamada de “textoAEscrever”, e, neste caso, como precisamos passar o tipo
byte por parâmetro, utilizamos o método getBytes da variável String.
FIGURA 54 – ARQUIVO GRAVADO COM A STRING PASSADA POR PARÂMETRO
FONTE: O autor
Como você pode analisar a Figura 54, que apresenta o arquivo sobrescrito
pelo código-fonte da Figura 53, a String foi gravada em duas linhas, isso porque
entre as duas linhas foi incluído o caracter “\n”, que no Java significa saltar linha.
7 ARRAYS
Array é um vetor conhecido na linguagem de programação Java, sendo
uma estrutura de dados, a qual é constituída de uma lista de itens de dados de
mesmo tipo, e está contida no pacote java.util na coleção da API do Java. Arrays
são listas de objetos de mesmo tipo que possuem um número fixo de valores,
cujo tamanho é estabelecido quando criado, sendo que após a sua criação, seu
tamanho é fixo (BUELL, 2013).
Neste sentido, cada item de um array é conhecido por elemento ou

localização, sendo que cada elemento pode ser acessado pelo seu número na
lista, chamado de índice, isto é, para se referir a um elemento específico do array,
é especificado o nome do array e o seu índice (posição) do elemento desejado
(BUELL, 2013).
A Figura 55 apresenta a ilustração de um array com 12 posições ou

elementos, no qual você pode analisar como acessar cada elemento, ou linha, do
array, sendo utilizado o nome do array, que neste caso é “c”, seguido da abertura
de um colchetes, e dentro deste o índice (posição do elemento), e, por último, o
fechamento do colchetes.
152
Perceba ainda na Figura 55 que o array possui 12 elementos (linhas) no

total, porém o acesso ao primeiro elemento é iniciado pelo valor zero. Neste caso,
para acessar o último elemento do array é utilizado o Índice 11, isto é, “c[11]”.
FIGURA 55 – EXEMPLO DE UM ARRAY COM 6 ELEMENTOS
FONTE: O autor
Segundo Buell (2013), arrays são objetos que ocupam espaço na memória,
e todos os objetos em Java devem ser alocados dinamicamente utilizando o
operador new, o qual você já utilizou para instanciar classes.
FIGURA 56 – EXEMPLO DE DECLARAÇÃO E CRIAÇÃO DE UM ARRAY
FONTE: O autor
153
E MULTIDIMENSIONAIS
Ainda de acordo com Buell (2013), para declarar um array, deve ser
especificado o tipo dos elementos do array, e, em seguida, a quantidade de
elementos que este terá. Você pode analisar o código-fonte da Figura 56, no
qual, na linha 7 está sendo criado o array ilustrado na Figura 55, onde você pode
perceber que foi especificado o tipo int, em seguida o nome do array “c[]”, seguido
do sinal de igual, e então o operador new seguido do tipo com a quantidade entre
colchetes. Ainda referente ao código-fonte da Figura 56, analise a saída do console
após a execução da classe, em que você pode perceber que cada elemento do array
possui valor zero. Isso porque quando é criado um array do tipo int, inicialmente
todos os elementos possuem valor zero.
Outro detalhe importante, já que durante o desenvolvimento de software

é muito comum essa situação, é o acesso a um índice inválido, isto é, no caso
do nosso array “c[]”, temos 12 elementos, e conforme você pode analisar, na
Linha 9 do código da Figura 57, foi tentado acessar o índice 12, porém o índice
máximo de um array é a sua quantidade de elementos subtraindo um. No caso
deste código-fonte, ao ser executada a classe, foi impresso no console o erro “java.
lang.ArrayIndexOutOfBoundsException: 12”, que significa acesso a um índice
inválido.
FIGURA 57 – ACESSO A ÍNDICE INVÁLIDO
FONTE: O autor
É possível implementar com uma única declaração a alocação de memória

para vários arrays diferentes, conforme ilustrado na Linha 7 do código-fonte da
Figura 58, onde foram alocados os arrays “listaNomes” e “listaCidades”, cujos
elementos são do tipo String. Além disso, nesta classe você pode analisar a saída da
impressão do console, onde foi impresso o valor null para o primeiro elemento de
154
cada um dos arrays devido ao tipo ser um objeto (String). Neste caso, cada elemento
é criado como null até ser atribuído um objeto do tipo String. Esta regra vale para
qualquer outro tipo que é um objeto, como Double ou Integer, por exemplo.
FIGURA 58 – EXEMPLO DE ALOCAÇÃO DE MAIS DE UM ARRAY EM ÚNICA DECLARAÇÃO
FONTE: O autor
Na Linha 6 do código-fonte da Figura 59 foi criado um array do tipo Double,

no qual você pode analisar que ao ter sido executado o comando da Linha 8, foi
impresso o valor null para o elemento zero. Ainda neste código-fonte, na linha 10,
foi atribuído um valor do tipo Double para a posição zero do array, e, em seguida,
novamente foi impresso no console o valor do índice zero, sendo então impresso o
novo valor do elemento.
FIGURA 59 – EXEMPLO DE ATRIBUIÇÃO DE VALOR PARA ÍNDICE ZERO DE ARRAY
FONTE: O autor
155
E MULTIDIMENSIONAIS
Neste sentido, perceba como é atribuído valor a um determinado elemento

de um array, conforme a Linha 10 do código apresentado na Figura 59, basta
utilizar o nome do array, seguido do índice do elemento desejado, e atribuir o
valor.
Agora que você já conhece arrays, existe mais uma forma de se trabalhar
com estas estruturas de dados: utilizar comando de loop para acessar seus índices
automaticamente. Conforme ilustrado no código-fonte da Figura 60, você pode
analisar que foi criado um array do tipo String, com tamanho máximo de 5
elementos, tais elementos estão recebendo um valor do tipo String, entre as linhas
8 e 12. Na Linha 14 deste código-fonte, foi utilizado o comando de repetição for,
o qual, conforme você já aprendeu, repete algum código até que a sua condição
seja satisfeita, sendo que neste caso, a quantidade de iterações é a quantidade de
elementos do array, sendo pega pela propriedade length do array.
FIGURA 60 – EXEMPLO DE LOOP COM ARRAY
FONTE: O autor
Ainda referente à Figura 60, você pode analisar a saída do console, onde
foram impressos o valor de cada elemento do array.
156
No código-fonte da Figura 61 é apresentado um exemplo de solicitação

de dados ao usuário em um loop, sendo armazenado o valor informado em cada
elemento do array, conforme linhas 11 e 15 do código-fonte. Na Linha 21 desse
código é realizada a iteração com o comando for, onde é somando o valor de
cada elemento e atribuído a variável “soma” que é utilizada na Linha 25 para
realização da média de preço. Este é um simples exemplo de como você pode
utilizar um array, incluindo, neste caso, a realização de um cálculo, por exemplo.
FIGURA 61 – EXEMPLO DE UTILIZAÇÃO DE ARRAY PARA SOLICITAÇÃO DE DADOS AO USUÁRIO
FONTE: O autor
8 ARRAYS MULTIDIMENSIONAIS
Agora que você já compreendeu o que são arrays e como utilizá-los, você
aprenderá o que são arrays multidimensionais, os quais podem ser entendidos
por ser um tipo de array, porém declarado com duas dimensões, normalmente
utilizado para representar tabelas de valores, possuindo seus dados organizados
em linhas e colunas (SCHILDT, 2015).
Para ser identificado um elemento de uma tabela, é necessário informar a

linha, através do primeiro subscrito, e a coluna, identificada no segundo subscrito.
Este tipo de array, que exige dois subscritos para identificação do elemento, é
chamado de array bidimensional (SCHILDT, 2015).
157
E MULTIDIMENSIONAIS
Ainda segundo Schildt (2015), o Java não suporta diretamente arrays

multidimensionais, isto é, aqueles com várias linhas e várias colunas, mas é
possível implementar arrays unidimensionais de outros arrays unidimensionais,
cujos elementos também são arrays, conseguindo assim uma estrutura parecida
com arrays multidimensionais, possuindo mesmo efeito.
Neste contexto, em um array bidimensional, cada elemento é identificado

pela forma nomeArray[numeroLinha, numeroColuna], sendo “nomeArray” o
nome do array, “numeroLinha” o número da linha e, “numeroColuna” o número
da coluna do elemento desejado (SCHILDT, 2015).
Ao ser analisada a Figura 62, você pode perceber que está sendo apresentada
uma tabela com três linhas e quatro colunas, sendo um array destas proporções.
Neste sentido, na primeira linha (Linha 0), o primeiro subscrito (índice) possui
o valor zero, justamente por referenciar a linha zero, isto é, a primeira linha do
array. Na segunda linha apresentada nesta figura (Linha 1), consequentemente o
primeiro subscrito possui valor 1.
FIGURA 62 – EXEMPLO DE ARRAY BIDIMENSIONAL DE TRÊS LINHAS E QUATRO COLUNAS
FONTE: O autor
Agora, analisemos o segundo subscrito da Figura 62, onde é possível

constatar que na linha número zero e coluna número zero, o segundo subscrito,
o qual se refere ao índice da coluna, possui valor zero. Analise agora a posição
“[2][3]” do array desta figura, onde você pode notar que temos a coluna número
4 da linha número 2, terceira linha do array pois a contagem é iniciada da posição
zero, assim como a Coluna 4 é representada pelo Índice 3, pois a contagem é
iniciada do zero. Neste caso, se for necessário acessar a primeira coluna da terceira
linha do array, deve ser utilizado [2][0]. Na linha 7 da Figura 63 é apresentada a
implementação do array ilustrado na Figura 62, onde foi declarado com o nome
“tabela” e alocada a memória com array de 3 linhas e 4 colunas.
158
Para atribuir valores para cada elemento de um array bidimensional, da

mesma forma que para um simples array, basta acessar a posição do elemento,
que, neste caso, deve ser informada a coluna além do número da linha, e realizar a
atribuição desejada, conforme linhas 10 e 21 do código-fonte ilustrado na Figura 63.
FIGURA 63 – EXEMPLO DE DECLARAÇÃO E ALOCAÇÃO
FONTE: O autor
Para você entender melhor a utilização de arrays bidimensionais, analise

o exemplo do código-fonte apresentado na Figura 64, o qual apresenta um
programa que solicita o valor de três combustíveis para dois dias.
159
E MULTIDIMENSIONAIS
FIGURA 64 – EXEMPLO DE ARRAY BIDIMENSIONAL
FONTE: O autor
Neste contexto do código-fonte da Figura 64, as três colunas de cada

uma das duas linhas representam os elementos que receberão o valor de cada
combustível, isto é, combustível 1, 2 e 3. Já as duas linhas representam os dois
dias da análise. Com isso, entre as linhas 12 e 17, é solicitado ao usuário que
informe para cada dia o preço de cada combustível para cada um dos dois dias.
Após serem informados os valores de todos os combustíveis para todos os dois
dias, conforme ilustrado na Figura 65, é realizado o cálculo da média de cada dia,
entre as linhas 22 e 32 do código-fonte da Figura 64 e apresentado ao usuário.
FIGURA 65 – EXEMPLO DA SOLICITAÇÃO DO VALOR DE COMBUSTÍVEL PARA CADA DIA
FONTE: O autor
160
EXPLORANDO A CLASSE ARRAYLIST NO JAVA
Pretende-se, neste artigo, apresentar e demonstrar a utilização dos

métodos da classe ArrayList na manipulação de vetores (ou arrays) dinâmicos.
Em Deitel (2005, p. 673), uma coleção é uma estrutura de dados, na

realidade um objeto, que pode armazenar ou agrupar referências a outros objetos
(um contêiner). As classes e interfaces da estrutura de coleções são membros
do pacote java.util e a figura a seguir apresenta a hierarquia de algumas destas
interfaces oferecidas pelo Java.
HIERARQUIA DAS INTERFACES DA ESTRUTURA DE COLEÇÕES
Na lista de interfaces da estrutura de coleções destacam-se os conjuntos,

as listas, as filas e os mapas:
1) Conjunto (Set e SortedSet): uma coleção de elementos que modela a abstração

matemática para conjuntos. Não mantém indexação e nem contagem dos
elementos pertencentes. Cada elemento pertence ou não pertence ao conjunto
(não há elementos repetidos). Podem ser mantidos ordenados (SortedSet) ou não.
2) Lista (List): uma coleção indexada de objetos às vezes chamada de sequência.
Como nos vetores, índices de List são baseados em zero, isto é, o índice do
primeiro elemento é zero. Além dos métodos herdados de Collection, List
fornece métodos para manipular elementos baseado na sua posição (ou índice)
numérica na lista, remover determinado elemento, procurar as ocorrências de
um dado elemento e percorrer sequencialmente (ListIterator) todos os elementos
da lista. A interface List é implementada por várias classes, incluídas as classes
ArrayList (implementada como vetor), LinkedList e Vector.
3) Fila (Queue): uma coleção utilizada para manter uma "fila" de elementos. Existe
uma ordem linear para as filas que é a "ordem de chegada". As filas devem ser
utilizadas quando os itens deverão ser processados de acordo com a ordem
"PRIMEIRO-QUE-CHEGA, PRIMEIRO-ATENDIDO". Por esta razão as filas
são chamadas de Listas FIFO, termo formado a partir de "First-In, First-Out".
161
E MULTIDIMENSIONAIS
4) Mapa (Map e SortedMap): um mapa armazena pares, chave e valor, chamados

de itens. As chaves não podem ser duplicadas e são utilizadas para localizar
um dado de elementos associados. As chaves podem ser mantidas ordenadas
(SortedMap) ou não.
Para atender o propósito deste artigo será utilizada a classe ArrayList

na implementação de vetores dinâmicos (ou redimensionáveis). Veja a seguir a
relação dos principais métodos da classe:
• boolean add(Object element): adiciona o elemento especificado no final da lista;

• void add(int index, Object element): insere o elemento especificado na posição
indicada da lista;
• void clear(): remove todos os elementos da lista;
• boolean contains(Object element): retorna verdadeiro se a lista contém o
elemento especificado e falso caso contrário;
• Object get(int index): retorna o i-ésimo elemento da lista;
• int indexOf(Object element): retorna a posição da primeira ocorrência do
elemento especificado na lista;
• boolean isEmpty(): retorna verdadeiro se a lista estiver vazia e falso caso contrário;
• int lastIndexOf(Object element): retorna a posição da última ocorrência do
elemento especificado na lista;
• Object remove(int index): remove o i-ésimo elemento da lista;
• Object set(int index, Object element): substitui o i-ésimo elemento da lista pelo
elemento especificado;
• int size(): retorna o número de elementos da lista.
Na Listagem 1, foram implementados trechos de códigos que demonstram

a utilização da classe ArrayList para criar, manter e percorrer uma lista de contatos.
As seguintes funcionalidades foram implementadas: a) declarando e instanciando
um objeto agenda; b) usando o método add() para gravar 4 contatos na agenda; c)
mostrando os "n" contatos da agenda (usando o índice); d) removendo o i-ésimo
elemento da agenda; e) mostrando os "n" contatos da agenda (usando for-each);
e, f) mostrando os "n" contatos da agenda (com iterator).
162
APLICAÇÃO JAVA EXPLORANDO OS MÉTODOS DA CLASSE ARRAYLIST
import java.util.ArrayList;
import java.util.Iterator;
import java.util.Scanner;

public class Exemplo {

public static void main(String[] args) {
Scanner ler = new Scanner(System.in);

// [ A ] declarando e instanciando uma agenda de contatos
0 ArrayList<String> agenda = new ArrayList();

1 // [ B ] usando o método add() para gravar 4 contatos na
agenda
2 agenda.add("Juca Bala;11 1111-1111");
agenda.add("Marcos Paqueta;22 2222-2222");
3 agenda.add("Maria Antonieta;33 3333-3333");
agenda.add("Antônio Conselheiro;44 4444-4444");
4
int i;
5
// [ C ] mostrando os "n" contatos da agenda (usando o
6 índice)
// número de elementos da agenda: método size()
7 System.out.printf("Percorrendo o ArrayList (usando o
índice)\n");
8 int n = agenda.size();
for (i=0; i<n; i++) {
9 System.out.printf("Posição %d- %s\n", i, agenda.get(i));
}
0
System.out.printf("\nInforme a posição a ser excluída:\n");
1 i = ler.nextInt();

2 try {
// [ D ] remove o i-ésimo contato da agenda
3 agenda.remove(i);
} catch (IndexOutOfBoundsException e) {
4 // exceção lançada para indicar que um índice (i)
// está fora do intervalo válido (de 0 até agenda.size()-1)
5 System.out.printf("\nErro: posição inválida (%s).",
e.getMessage());
6 }
163
E MULTIDIMENSIONAIS
7 // [ E ] mostrando os "n" contatos da agenda (usando for-

each)
8 System.out.printf("\nPercorrendo o ArrayList (usando for-
each)\n");
9 i = 0;
for (String contato: agenda) {
0 System.out.printf("Posição %d- %s\n", i, contato);
i++;
1 }

2 // [ F ] mostrando os "n" contatos da agenda (com iterator)
System.out.printf("\nPercorrendo o ArrayList (usando
3 iterator)\n");
i = 0;
4 Iterator<String> iterator = agenda.iterator();
while (iterator.hasNext()) {
5 System.out.printf("Posição %d- %s\n", i, iterator.next());
i++;
6 }
}
7
}
8
164
Ao executar a aplicação, o resultado apresentado na figura a seguir

poderá ser exibido.
EXECUTANDO A APLICAÇÃO
FONTE: <https://www.devmedia.com.br/explorando-a-classe-arraylist-no-java/24298>.
Acesso em: 17 fev. 2020.
CHAMADA

165
RESUMO DO TÓPICO 3
• Para utilização do pacote java.lang não é necessária importação manual do

pacote.
• Uma das classes mais utilizadas do pacote java.lang é a System, a qual possui
vários métodos necessários para muitas soluções, como o println, por exemplo.
• O atributo out da classe System é do tipo PrintStream, o qual representa o fluxo

de saída de dados.
• Uma das possíveis utilizações para o método System.out.println é realizar

a impressão de mensagens em determinados pontos de um programa para
debugar.
• Quando existe um método que possui um parâmetro de um determinado tipo

específico, e é necessário o mesmo método para outro tipo, é implementada a
sobrecarga do método.
• Qualquer classe implementada na linguagem de programação Java herda da

classe System.Object.
• O pacote java.io possui soluções para tratar a manipulação de arquivos (criação,

exclusão, mover para outro diretório).
• Array pode ser entendido como sendo uma estrutura de dados, constituída por
uma lista de itens de dados de mesmo tipo.
• Cada item de um array é conhecido por elemento, o qual é acessado pelo seu
índice.
• Arrays multidimensionais são arrays que representam tabelas, isto é, várias

linhas com várias colunas cada uma delas.
• O Java não suporta arrays multidimensionais, porém é possível criar arrays de

arrays que possuem o mesmo efeito.
• Arrays bidimensionais são arrays que possuem dois subscritos, isto é, dois
índices para acessar um elemento, pois um deles indica a linha e o segundo a
coluna.
166
AUTOATIVIDADE
1 Uma das características importantes do desenvolvimento de software

utilizando as boas práticas no Java é a orientação a objetos, que através
deste paradigma é possível tornar o código-fonte reutilizável e de fácil
manutenção. Além disso, o pacote java.lang fornece muitos recursos
que facilitam o desenvolvimento. Neste sentido, assinale a alternativa
CORRETA:
a) ( ) A maioria das classes em Java, caso não utilizado o comando extends

para outra classe, não possui a característica de herança.
b) ( ) O objeto out do pacote java.lang não é acessível.
c) ( ) O método toString da classe System.Object retorna o valor dos atributos
da classe.
d) ( ) Toda classe desenvolvida na linguagem de programação Java herda a
implementação de outra classe.
2 Em muitos softwares, é necessária a implementação de controles ou

tratamentos para manipulação de arquivos, como realizar a transferência
de um arquivo de um local para outro por exemplo. Referente ao pacote
java.io do Java, assinale a alternativa CORRETA:
a) ( ) A única funcionalidade fornecida pelo pacote java.io é a transferência

de arquivos de um diretório para outro.
b) ( ) As únicas duas funcionalidades fornecidas pelo pacote java.io é a
transferência de arquivos de um diretório para outro e a leitura de
arquivos.
c) ( ) O pacote java.io permite a alteração de um arquivo, porém deve ser
tomado cuidado, pois o conteúdo original do arquivo sempre será
sobrescrito.
d) ( ) O pacote java.io permite realizar a criação, alteração, exclusão e
transferência de arquivos de um diretório para outro.
3 Dependendo do software que está sendo desenvolvido, muitas vezes é

necessária a realização de manipulação de arquivos, copiando um arquivo
de um diretório para um outro em algum servidor, por exemplo. Neste
sentido, crie um arquivo texto (extensão .txt) em um diretório qualquer de
seu computador, e então implemente um programa em Java que realize a
leitura deste arquivo, exibindo ao usuário, através da classe JoptionPane,
o conteúdo do arquivo. Após a exibição para o usuário, o programa deve
excluir o arquivo.
167
4 Em certas aplicações, é necessário armazenar em memória vários valores,
por exemplo, uma lista de notas de um aluno para que depois seja realizado
o cálculo da média, o que pode ser facilitado com a utilização de arrays.
Referente ao array na linguagem de programação Java, assinale a alternativa
CORRETA:
a) ( ) Um mesmo array pode ter elementos de tipos diferentes, isto é,

elementos do tipo int e também elementos do tipo String.
b) ( ) Na declaração de um array não é especificado tipo de dado dos
elementos, pois o array é dinâmico.
c) ( ) Após a declaração do array “int c[] = new int[12]”, ao ser impresso o
valor do elemento com índice zero, será impresso o valor null.
d) ( ) Para acessar um elemento de um array é necessária a utilização do
índice do elemento.
5 Arrays multidimensionais são normalmente utilizados para representar

tabelas, isto é, possui seus dados organizados em linhas e colunas, o
que permite a solução de algumas situações necessárias para satisfazer
algumas soluções. Neste sentido, implemente um programa que solicite ao
usuário 4 notas de 2 alunos e no final, apresente na tela, utilizando a classe
JoptionPane, a lista de notas de cada aluno com a sua média, isto é, deve
calcular a média do aluno 1 e apresentar a lista de notas e sua média, após
fechada esta janela, fazer o mesmo para o aluno 2.
168
UNIDADE 3
TECNOLOGIAS DE
DESENVOLVIMENTO JAVA
• apresentar uma introdução ao desenvolvimento de interfaces gráficas

utilizando a linguagem de programação Java;
• apresentar uma introdução ao desenvolvimento de sistemas web com a

linguagem de programação Java;
• apresentar o desenvolvimento de sistema persistindo dados no banco de

dados;
• aplicar os conceitos aprendidos nas unidades anteriores deste livro no

desenvolvimento de sistemas.
PLANO DE ESTUDOS
Esta unidade está dividida em três tópicos. No decorrer da unidade você
encontrará autoatividades com o objetivo de reforçar o conteúdo apresentado.
TÓPICO 1 – INTERFACES GRÁFICAS
TÓPICO 2 – MANIPULAÇÃO DE DADOS: UTILIZANDO JDBC PARA

DESKTOP
TÓPICO 3 – DESENVOLVIMENTO DE APLICAÇÃO WEB: JSP E SERVLET
CHAMADA

169
170
UNIDADE 3
TÓPICO 1
INTERFACES GRÁFICAS
1 INTRODUÇÃO
Agora que você já conhece os conceitos básicos da linguagem de
programação Java, suas variáveis, constantes, conversões, comandos de controle,
conceitos da orientação a objetos, arrays e a trabalhar com arquivos, chegou
o momento de você avançar nesta linguagem de programação e, com isso,
programar telas gráficas mais agradáveis, ao invés de apenas utilizar mensagens
no console.
Até este ponto do estudo, você já se adaptou a utilizar a classe JOptionPane,

mas, agora, você aprenderá o desenvolvimento de telas mais complexas, pois
você implementou códigos apenas com retorno no console e em formato de texto,
todos para seu aprendizado na linguagem. Neste sentido, este tópico permitirá
a você o desenvolvimento de software com alguma interação mais aprimorada
com o usuário, isto é, telas mais amigáveis, utilizando interfaces gráficas, e, com
isso, permitindo que você evolua nesse quesito, auxiliando o desenvolvimento
através da interface GUI.
2 INTERFACES GUI NO JAVA

Atualmente, os usuários de sistemas estão acostumados a utilizar software
que tenha uma interface gráfica mais rica, isto é, componentes visuais mais bonitos,
e telas mais amigáveis (FAIN, 2011). Neste sentido, o Java oferece uma biblioteca
de componentes visuais chamada Swing, utilizada para o desenvolvimento de
interfaces gráficas para aplicações desktop, conhecida por GUI (Graphic User
Interface) (SIAHAAN; SIANIPAR, 2019).
O desenvolvimento de interfaces gráficas no início era conhecido por

AWT (Abstract Window Toolkit), o qual foi substituído pelo Swing, que pertence
à biblioteca JFC (Java Foundation Classes), sendo Swing uma extensão do AWT
(FAIN, 2011). Neste sentido, este tópico está voltado para o desenvolvimento de
interfaces gráficas utilizando o Swing, por possuir uma aparência aprimorada e
melhores recursos do que o AWT. Segundo Furgeri (2015), a principal diferença
de desenvolvimento destas duas bibliotecas é a utilização da letra J na frente do
nome do componente quando se utiliza o Swing, por exemplo, para um botão, a
classe no AWT é Button, enquanto que no Swing a classe utilizada é JButton.
171
UNIDADE 3 | TECNOLOGIAS DE DESENVOLVIMENTO JAVA
Assim, aplicações gráficas podem ser consideradas aquelas que permitem

a criação de uma GUI (Graphical User Interface) ou Interface Gráfica do Usuário. Com
isso, quando for desenvolvida uma aplicação utilizando uma GUI, é necessário
realizar a definição de quais componentes são necessários para a solução, como
a definição de como estes componentes serão apresentados na janela (FURGERI,
2015). A biblioteca Swing possui várias classes diferentes para serem utilizadas no
desenvolvimento de uma GUI. A partir deste ponto, com este novo conhecimento
que você terá da linguagem, o desenvolvimento de software começa a ficar mais
interessante, pois você aprenderá o desenvolvimento de software utilizando
janelas gráficas. Ressaltando que ao se projetar um sistema gráfico, é necessário
que sejam definidos todos os componentes que serão utilizados, assim como seus
objetivos e a sua posição na janela (FURGERI, 2015).
Estes componentes, os quais serão apresentados a seguir, são objetos que

realizam a interação com usuário da aplicação através de teclado, mouse ou ainda
outros dispositivos que podem servir para realizar a entrada de dados. Dentre os
componentes mais utilizados podem ser citados: as etiquetas, os botões, as caixas
de texto, os painéis de rolagem, os menus, os objetos de múltipla escolha, entre
outros (BURD, 2014).
Assim como outras linguagens de programação, cada componente possui

suas propriedades, que podem ser alteradas durante o desenvolvimento ou em
tempo de execução, como cor, tamanho, fonte, ou posição na tela, por exemplo.
As classes do swing são extensões do pacote AWT, que, por sua vez, são extensões
da classe java.lang.Object, a superclasse de todas as classes do Java. Além dos
pacotes de classes da AWT e Swing, existem outras formas de criar interfaces em
Java não discutidas neste livro (FURGERI, 2015).
Conforme você perceberá nos exemplos apresentados, serão utilizadas

apenas objetos Swing, mas, para isso, as classes utilizadas requisitam várias
classes externas dos pacotes Swing e do AWT. Neste sentido, na maioria dos
exemplos apresentados, as classes utilizadas possuem ao menos três linhas com
a diretiva import, a qual realiza o apontamento para pacotes de classes externas,
cujas diretivas de importação estão listadas a seguir:
• import java.awt: serve para permitir utilização de diversas classes do pacote

AWT;
• import java.awt.event: serve para permitir o processamento de eventos que
ocorrem em janelas, como alteração de um campo de entrada de texto com a
entrada pelo teclado ou ainda pelo clique do mouse.
• import javax.swing: serve para permitir a utilização das diversas classes do
pacote Swing.
172
TÓPICO 1 | INTERFACES GRÁFICAS
3 CLASSE JFRAME
A classe JFrame, disponibilizada pelo pacote swing, será utilizada para
a criação de frames nos exemplos deste livro. A classe JFrame serve para criar
uma janela com uma barra de título, bordas e ainda pode ter outros componentes
visuais em seu interior (SCHILDT, 2015). Com isso, a aplicação a ser desenvolvida
neste tópico será do tipo MDI (Multiple Document Interface), na qual as telas do
software são apresentadas dentro de uma única janela.
4 CLASSE JLABEL
A classe JLabel permite que seja definido um texto para servir como título
de outro componente, isto é, na frente de um campo de entrada de texto, por
exemplo, especificar o nome do campo ou qual sua finalidade (BURD, 2014). São
várias as propriedades que podem ser personalizadas para esse campo da tela,
como seu alinhamento, o tipo de fonte, tamanho da fonte, a cor do texto, entre
outros. A Figura 1 apresenta um exemplo para a sintaxe de declaração e criação
de um objeto do tipo JLabel.
FIGURA 1 – EXEMPLO DE DECLARAÇÃO E CRIAÇÃO DE COMPONENTE DA CLASSE JLABEL
FONTE: O autor
A linha de código apresentada na Figura 1 cria em memória um objeto

chamado jlSenha, sendo apresentado na tela o texto “Senha”. Neste sentido, o
Quadro 1 apresenta os métodos disponibilizados pela classe JLabel.
QUADRO 1 – RESUMO DOS MÉTODOS DA CLASSE JLABEL
FONTE: Furgeri (2015, p. 138)
173
5 CLASSE JTEXTFIELD
Esta classe permite a criação de uma caixa de texto na tela, a qual funciona
como entrada de texto pelo usuário, e, além disso, esta classe também possui
várias propriedades cujos conteúdos podem ser modificados, como tipo de fonte,
cor, tamanho etc. (BURD, 2014). A Figura 2 apresenta um exemplo para a sintaxe
de declaração e criação de um objeto do tipo JTextField.
FIGURA 2 – EXEMPLO DE DECLARAÇÃO E CRIAÇÃO DE COMPONENTE DA CLASSE JLABEL
FONTE: O autor
O Quadro 2 apresenta os métodos disponibilizados pela classe JTextField,

sendo que apenas alguns deles serão utilizados nos exemplos deste livro.
QUADRO 2 – MÉTODOS DISPONIBILIZADOS PELA CLASSE JTEXTFIELD
6 CLASSE JPASSWORDFIELD
A classe JPasswordField é parecida com a classe JTextField, porém na
JPasswordField, ao ser digitados caracteres, eles são substituídos (visualmente)
por outro caractere para ocultar o que está sendo digitado, isto é, a senha digitada
é ocultada. O caractere padrão utilizado para esta ocultação é o asterisco “*”,
embora seja possível alterá-lo através do setEchoChar. A declaração e criação de
um objeto deste tipo (classe) é apresentado na Figura 3.
174
FIGURA 3 – EXEMPLO DE DECLARAÇÃO E CRIAÇÃO DE COMPONENTE DA CLASSE
FONTE: O autor
7 CLASSE JBUTTON
A classe JButton serve para realizar a criação de botões a serem utilizados
em outros componentes gráficos, como em frames e painéis, podendo ser criado
com um texto ou um ícone. A declaração e criação de um objeto deste tipo (classe)
é apresentado na Figura 4.
FIGURA 4 – EXEMPLO DE DECLARAÇÃO E CRIAÇÃO DE COMPONENTE DA CLASSE JBUTTON
FONTE: O autor
8 CRIAÇÃO DO FRAME PARA ACESSO DO USUÁRIO (LOGIN)

Aqui você aprenderá a desenvolver a primeira tela de nossa aplicação,
sendo a tela de acesso do usuário ao sistema, ou tela de login. Nesta tela, o
usuário deve fornecer os dados de entrada, como usuário e senha, e, caso
informados corretamente, nesta parte do exemplo será apresentada a mensagem
“EFETUANDO LOGIN!!!!”, apenas para um teste inicial da validação dos campos,
conforme apresentada na Linha 22 do código-fonte da Figura 5. Note na Figura
5 as importações realizadas entre as linhas 3 e 14, onde você pode perceber uso
das bibliotecas AWT e Swing por estar sendo utilizados componentes de ambas.
Entre as linhas 18 e 24 do código-fonte da Figura 5, estão apenas declarados os
componentes utilizados nesta tela, sendo que entre as linhas 37 e 49 estes objetos
(componentes) são criados em memória. Entre as linhas 51 e 56 deste código-
fonte, você pode notar o comando add para cada objeto de componente, isto é,
está sendo adicionando cada componente ao frame (tela).
175
FIGURA 5 – TELA DE ACESSO PARA USUÁRIO INFORMAR SEUS DADOS PARA EFETUAR LOGIN
176
FONTE: O autor
Neste contexto, o método setBounds(), muito utilizado a seguir, serve

para definição da posição vertical (parâmetro “x”), posição horizontal ou altura
(parâmetro “y”), a largura do componente (parâmtro width) e a altura do
componente (parâmetro height), todos nesta ordem, sendo então sua assinatura
da seguinte forma: setBounds(int x, int y, int width, int height).
Ainda referente à Figura 5, o método “vincularEventos” possui a

implementação dos eventos dos dois botões “jbEfetuaLogin” e “jbEfetuaCancelar”.
Neste sentido, para criar o evento de click em objeto do tipo Jbutton, deve ser
utilizado o “addActionListener”, conforme linha 64 do código-fonte, sendo que na
Linha 64 é criada uma variável do tipo String que recebe o valor digitado no campo
de senha, através do método getPassword() da classe JpasswordField. Entre as
linhas 66 e 79, foram implementadas validações nos campos, para saber se foram
informados, ou se estão sem valor, enquanto que na Linha 82 é a mensagem
177
apresentada se o acesso for bem-sucedido, isto é, usuário e senha informados

corretamente. Como não está sendo utilizado um banco de dados, são aceitos os
valores “admin” para o campo usuário e senha, conforme você pode analisar nas
linhas 70 e 78. Entre as linhas 95 e 103, foi implementado o evento do clique do
botão de cancelar, o qual é solicitado ao usuário uma confirmação se realmente
ele deseja cancelar a entrada no programa, sendo retornado o valor da seleção
do botão em uma variável do tipo int, e caso este valor seja zero, significa que
o usuário confirmou pressionando opção “Sim” do JOptionPane, sendo então
invocado o método exit da classe System, que fecha a aplicação.
Por último, o método main, da Figura 5, o qual é responsável por iniciar a

execução da aplicação, e neste caso, toda classe que precisa ser executada necessita
deste método, conforme você já estudou em exemplos de classes menores de
tópicos anteriores. Ainda neste método, nas linhas 111 e 112 está definido o
método de execução da aplicação, que implica na criação de uma thread. Na Linha
113 está sendo criado o objeto “guiAcesso” através do construtor GuiAcesso() da
classe, e, com isso, este objeto recebe todas as definições que estão no construtor da
classe GuiAcesso, como a inicialização de componentes e definição de eventos. A
Linha 114 invoca o método setDefaultCloseOperation, a qual serve para encerrar
o software assim que a janela for fechada, sendo que a constante utilizada é EXIT_
ON_CLOSE, que encerra a aplicação.
Segundo Furgeri (2015), outras constantes que podem ser utilizadas neste
método são:
• HIDE_ON_CLOSE: oculta a janela quando fechada.

• DO_NOTHING_ON_ CLOSE: apenas desativa o botão de encerramento.
• DISPOSE_ON_CLOSE: a janela desaparece e os recursos usados pela classe são
liberados.
DICAS
Para saber mais sobre threads em Java, acesse o artigo: https://www.devmedia.

com.br/trabalhando-com-threads-em-java/28780.
Ainda referente ao método main da Figura 5, na Linha 115 é criado o objeto

“tela” do tipo Dimension, o qual serve para se obter as dimensões da tela, valores
que dependem da resolução gráfica utilizada no ambiente em que o software
estiver sendo executado. Na Linha 116 é utilizado o método setLocation, o qual
serve para realizar a definição da posição na tela em que o frame será apresentado,
178
sendo o primeiro parâmetro o alinhamento horizontal, e o segundo parâmetro o

alinhamento vertical, que neste caso foi realizado o cálculo para deixar o frame
centralizado. Por último, o método setVisible com valor true para o seu parâmetro
torna o frame visível.
A Figura 6 apresenta a execução da classe GuiAcesso, isto é, a tela de acesso,

onde o usuário deve informar os dados para acessar o sistema internamente.
FIGURA 6 – EXEMPLO DA EXECUÇÃO DA CLASSE GUIACESSO
FONTE: O autor
9 CLASSES JMENUBAR, JMENU E JMENUITEM

É necessário criar a barra de menus antes do menu, para que sejam
apresentados os menus na parte superior da janela, e, para isso, é utilizada a
classe JMenuBar (FURGERI, 2015). A sintaxe para declaração e criação de um
objeto do tipo JMenuBar é apresentado na Linha 32 do código-fonte da Figura
7, assim como a definição do menu padrão para a janela, apresentado na linha
33, através do método setJMenuBar, passando por parâmetro o objeto do tipo
JMenuBar.
FIGURA 7 – EXEMPLO DE DECLARAÇÃO E CRIAÇÃO DE COMPONENTE DA

CLASSE JMENUBAR
FONTE: O autor
Com isso, basta criar um objeto do tipo JMenu para a definição deste
na barra de menus, pois apenas com a criação do objeto apresentado na Figura
6, a janela teria uma barra de menus vazia, sem menus para serem clicados.
Conforme a Linha 33 da Figura 8, onde está sendo criado o objeto com nome
179
“menuArquivo” do tipo JMenu, sendo atribuído ao parâmetro do construtor

o valor “Arquivo”, o que significa que será apresentado este menu na barra de
menus, e na Linha 35, está sendo adicionado o objeto do tipo JMenu para o objeto
“menuBarra”. O método setMnemonic serve para definir uma tecla de atalho
rápido para um determinado menu, e no caso da linha 34 do código-fonte, foi
atribuído o parâmetro “A”, o que significa que o atalho é “ALT + A”.
FIGURA 8 – EXEMPLO DE DECLARAÇÃO E CRIAÇÃO DE COMPONENTE DA CLASSE JMENU
FONTE: O autor
Até agora foi incluído o item na barra de menus da janela, e é necessário

a inclusão de itens de menu, o que é realizado através de objetos do tipo
JMenuItem. No caso do menu “Arquivo” incluído no código da Figura 8, uma
de muitas possibilidades é a inclusão de um item de menu “Sair”. Para isso,
conforme Linha 38 do código-fonte apresentado na Figura 8, onde foi declarado
e criado um objeto do tipo JMenuItem, basta incluir como valor de parâmetro
do método construtor desta classe o nome do item de menu. Referente à Figura
9, perceba que na Linha 40 do código foi adicionado o item de menu para o
menu “menuArquivo”, e na Linha 39, é definido um atalho para o item de menu
“Sair”, o qual é implementado através do método setAccelerator. Neste atalho
estão sendo utilizados os parâmetros para o atalho “ALT + S”. Note que o método
setAccelerator é diferente do método setMnemonic (FURGERI, 2015).
FIGURA 9 – EXEMPLO DE DECLARAÇÃO E CRIAÇÃO DE COMPONENTE DA

CLASSE JMENUITEM
FONTE: O autor
A Figura 10 apresenta o código-fonte da classe GuiAcessoInterno, a qual

representa a janela a ser aberta após o usuário efetuar o login pela janela da classe
GuiAcesso. No código-fonte da classe GuiAcessoInterno, você pode analisar que
os objetos de componentes foram declarados entre as linhas 17 e 20, sendo criados
em memória, isto é, classes instanciadas, somente entre as linhas 31 e 41, onde é
descrito o nome do objeto seguido do sinal de igual “=”, e a seguir o comando
new, que, por sua vez, é seguido do nome da classe. Note que a criação de
alguns componentes, como das classes JMenu e JMenuItem, o método construtor
requisita o nome do menu (String).
180
FIGURA 10 – CÓDIGO-FONTE DA JANELA GUIACESSOINTERNO
FONTE: O autor
181
Além disso, note nas linhas 43 e 44 do código-fonte apresentado na

Figura 10, que os objetos do tipo JMenuItem estão sendo adicionados ao objeto
do tipo JMenu, isso para que quando a janela for aberta, cada menu tenha seus
respectivos itens para que o usuário possa selecioná-los. O mesmo para os
objetos da classe JMenu, os quais precisam ser adicionados ao objeto do tipo
JMenuBar, sendo realizado entre as linhas 46 e 47. Por último, um objeto do
tipo JMenuBar precisa ser adicionado à janela, e, para isso, objetos deste tipo
são adicionados através do método setMenuBar, passando como parâmetro o
objeto do tipo JMenuBar sendo utilizado.
Após implementada a classe GuiAcessoInterno, altere o método

vincularEventos da classe GuiAcesso, substituindo a Linha 82 da Figura 11,
trecho ilustrado na Figura 13, com a linha 82 da Figura 14, isto é, como a classe
GuiAcessoInterno não possui método main, esta será invocada pelo evento da
tela de acesso, através da invocação do método GuiAcessoInterno.abrir(), desde
que informados o usuário e senha corretos.
FIGURA 11 – TRECHO DO CÓDIGO-FONTE DA CLASSE GUIACESSO
FONTE: O autor
Conforme descrito no parágrafo anterior, a Linha 82 da classe GuiAcesso

deve ser substituída pela linha 82 do código apresentado na Figura 12, sendo
implementada, desta forma, a funcionalidade para abrir a janela da classe
GuiAcessoInterno quando informados os dados corretos de usuário na tela de
acesso (login).
FIGURA 12 – LINHA 82 A SER SUBSTITUÍDA PARA ABERTURA DA JANELA DA CLASSE

GUIACESSOINTERNO
FONTE: O autor
A Figura 13 ilustra a apresentação da tela criada por objeto do tipo

GuiAcessoInterno, a qual é apresentada após os dados informados corretamente
na tela de acesso (login). Nesta tela, você pode perceber o item de menu “Sair”,
o mesmo se clicar no menu “Exemplos”, em que será apresentado o seu item de
menu.
182
FIGURA 13 – EXEMPLO DA APRESENTAÇÃO DA TELA CRIADA POR OBJETO DE TIPO

GUIACESSOINTERNO
FONTE: O autor
10 CLASSE JPANEL
A classe JPanel serve para a criação de objetos do tipo painel ou
container, o qual serve para abrigar outros componentes, como botões e campos
de entrada de texto, permitindo algumas melhorias de layout, como estilos de
bordas e cores, além de melhor organização de telas e código (FURGERI, 2015).
Neste sentido, a Figura 14 apresenta a implementação de nossa classe para a
criação de painel ou container para a inclusão de outros botões.
FIGURA 14 – EXEMPLO DE CLASSE DO TIPO JPANEL
183
FONTE: O autor
Note que a classe apresentada na Figura 14 possui um extends para a classe

JPanel, na qual foram declarados os objetos do tipo JButton, na Linha 13, e um
objeto do tipo ImageIcon na Linha 14. Para uma melhor aparência de botões, existe
a possibilidade de ser incluído um ícone ao invés de um simples texto em um
botão, e, neste sentido, você pode analisar a Linha 23 do código-fonte da classe
GuiPainelBotao, na qual está sendo criado um objeto do tipo ImageIcon, sendo
passado por parâmetro do método construtor da classe ImageIcon, o caminho da
imagem que se deseja utilizar como ícone. Lembrando que a altura da imagem
deve ser menor do que a altura do botão, ou seja, como o botão tem altura 38, a
imagem deve ser menor que esse valor, sendo a mesma regra para a largura.
Para que seja apresentado o painel da classe GuiPainelBotao, cuja

implementação é apresentada na Figura 14, é necessário incluir a distância desta
classe em algum ponto da aplicação.
Para isso, você pode alterar o evento do objeto itemMenuBotao da classe

GuiAcessoInterno, conforme ilustrado na Figura 15, onde entre as linhas 63 e 66
esta funcionalidade foi implementada. Neste trecho do código-fonte, na Linha 63
está implementada a criação do objeto “guiPainelBotao” do tipo GuiPainelBotao,
isto é, a instância desta classe. Na Linha 64, são removidos todos os objetos do
container, através do método removeAll, cujo método possui o intuito de manter
apenas o último objeto a ser armazenado no container. Na Linha 65 do código-
fonte da Figura15 é adicionado o objeto do tipo JPanel, criado ao container da
aplicação, enquanto que na Linha 66, com o método validade, é realizada a
validação do container e do objetos dentro dele. Você pode utilizar estes passos
para apresentação de um objeto do tipo JPanel como uma receita de bolo.
184
FIGURA 15 – EXEMPLO DE IMPLEMENTAÇÃO PARA APRESENTAÇÃO DO PAINEL DA

CLASSE GUIPAINELBOTAO
FONTE: O autor
A Figura 16 apresenta o container a partir do objeto do tipo

GuiPainelBotao, na qual você pode notar o ícone no botão de mensagem.
FIGURA 16 – ABERTURA DO CONTAINER APÓS CLIQUE NO ITEM “BOTÃO”

DO MENU “EXEMPLOS”
FONTE: O autor
11 CLASSE JCHECKBOX
A classe JCheckBox permite a criação de caixas de opção, isto é, uma caixa
na tela para selecionar, podendo ser sinalizada para ativada, que possui valor true,
ou desativada, que possui valor false (FURGERI, 2015). Ainda segundo Furgeri
(2015), caixas de opção são componentes que permitem ao usuário selecionar
nenhuma ou várias opções.
185
QUADRO 3 – MÉTODOS DA CLASSE JCHECKBOX
O Quadro 3 apresenta os métodos da classe JCheckBox, dentre eles, o

getStateChange() é um dos mais utilizados para resgatar o valor do componente,
isto é, se possui valor true ou false.
Neste sentido, analise a tela na Figura 17, que possui as caixas de opção,
onde o usuário pode selecionar um ou vários cursos.
FIGURA 17 – EXEMPLO DA TELA COM COMPONENTE CAIXAS DE OPÇÃO DA

CLASSE JCHECKBOX
FONTE: O autor
Antes de tudo, deve ser novamente alterada a classe GuiAcessoInterno,

adicionando a declaração de um novo item de menu (JMenuItem), sendo chamado
de “itemOpcaoCurso”, conforme apresentado no final da Linha 20 da Figura 18.
186
FIGURA 18 – DECLARAÇÃO DE NOVO ITEM DE MENU (JMENUITEM)
FONTE: O autor
Outra alteração na classe GuiAcessoInterno é a inclusão da linha de

comando para criação do objeto “itemOpcaoCurso”, do tipo JMenuItem, conforme
na Linha 42 da Figura 19.
Além disso, deve ser adicionado este item de menu ao objeto

“menuExemplo”, conforme Linha 46 da Figura 19.
Desta forma, o menu “Exemplos” da nossa janela da classe

GuiAcessoInterno possui duas opções de menu: “Botão” e “Opções de Curso”.
FIGURA 19 – CRIAÇÃO DE OBJETO ITEMOPCAOCURSO E INCLUSÃO DESTE NO

OBJETO MENUEXEMPLO
FONTE: O autor
Para acessar o próximo painel, existe mais uma alteração na classe

GuiAcessoInterno, a criação do evento do objeto item de menu “itemOpcaoCurso”,
sendo que, para isso, deve-se incluir o seguinte evento no método vincularEventos
da classe GuiAcessoInterno, conforme apresentado na Figura 23.
FIGURA 20 – INCLUSÃO DE EVENTO PARA ACESSAR PAINEL DA CLASSE GUIOPCAOCURSO
FONTE: O autor
187
Após a inclusão do item de menu “itemOpcaoCurso”, basta realizar a

implementação da classe GuiOpcaoCurso, conforme Figura 21. No código-fonte
da classe GuiOpcaoCurso, analise a Linha 13, a qual possui a declaração dos
objetos do tipo JcheckBox, e entre as linhas 25 e 27, a criação dos objetos (instância
da classe).
FIGURA 21 – CLASSE GUIOPCAOCURSO COM EXEMPLOS DE COMPONENTES JCHECKBOX
188
FONTE: O autor
Ainda referente à Figura 21, da mesma forma que para outros

componentes, as caixas de opções precisam ser adicionadas à tela, através
do método add, conforme linhas 34 e 36, e possuem o método setBounds para
definição de seu tamanho e posicionamento na tela, conforme linhas 38 e 40.
Referente ao método vincularEventos da Figura 21, analise a

implementação do evento do objeto “jbMarcar”, entre as linhas 52 e 54, em
que ao ser pressionado o botão, todos os três campos do tipo JcheckBox são
selecionados (valor true), através do método setSelected. Entre as linhas 63 e 65,
no evento do objeto “jbDesmarcar”, é passado o parâmetro false para o método
189
setSelected, deixando os três campos desmarcados (valor false). Por último, entre
as linhas 73 e 87, são verificados os três campos, através do método isSeleted, e
caso este método retornar valor true, pelo motivo dos objetos do tipo JCheckBox
estarem selecionados, então é atribuído o nome do curso a variável para então
no final ser apresentada a mensagem.
12 CLASSE JRADIOBUTTON
A classe JRadioButton serve para a criação de campos de seleção,
conhecidos por botões de rádio, que permite apenas uma das várias opções ser
selecionada pelo usuário (FURGERI, 2015). Ainda segundo Furgeri (2015), botões
de rádio devem ser criados em um agrupamento, utilizando o componente da
classe ButtonGroup, isso para cada conjunto de botões de rádio de um painel.
Segundo Furgeri (2015), através do componente ButtonGroup é definida a
regra para que o usuário possa selecionar apenas um dos botões de rádio do
mesmo grupo, e caso criados os botões de rádio fora de um ButtonGroup, estes
funcionarão como o JCheckBox, permitindo a seleção de várias opções.
Como será criada nova classe para novo painel, inclua na classe
GuiAcessoInterno mais um item de menu, declarando o objeto de
“itemOpcaoPeriodo”, conforme Linha 20 da Figura 22.
FIGURA 22 – DECLARAÇÃO DE NOVO ITEM DE MENU ITEMOPCAOPERIODO
FONTE: O autor
Outra alteração na classe GuiAcessoInterno é a criação do objeto

“itemOpcaoPeriodo”, conforme linha 43 da Figura 23, onde foi passado por
parâmetro o valor “Opções Período”.
FIGURA 23 – CRIAÇÃO DE OBJETO ITEMOPCAOPERIODO
FONTE: O autor
190
A última alteração na classe GuiAcessoInterno é a criação do evento do

novo item de menu no método vincularEventos, conforme apresentado na Figura
24. Perceba que a implementação da classe GuiOpcaoPeriodoTurma é apresentada
logo a seguir.
FIGURA 24 – INCLUSÃO DE EVENTO PARA ITEM DE MENU ITEMOPCAOPERIODO
FONTE: O autor
Com estes ajustes realizados, após implementada a classe

GuiopcaoPeriodoTurma, apresentada na Figura 25, a aplicação pode ser testada
novamente, a qual terá o novo item no menu “Exemplos” ativo, sendo aberto o
painel criado pela classe GuiopcaoPeriodoTurma.
FIGURA 25 – IMPLEMENTAÇÃO DA CLASSE GUIOPCAOPERIODOTURMA
191
FONTE: O autor
Ainda referente ao código-fonte da Figura 25, analise as linhas 16 e 17, nas

quais estão declarados os objetos de tipos JRadioButton e ButtonGroup, sendo
estes objetos criados entre as linhas 27 e 32. Além disso, entre as linhas 34 e 36,
os objetos do tipo JradioButton são adicionados ao objeto do tipo ButtonGroup.
Ao ser clicado no item de menu “Opções Período”, será apresentado o

painel implementado na classe GuiOpcaoPeriodoTurma, conforme Figura 26.
192
FIGURA 26 – EXECUÇÃO DO ITEM DE MENU “OPÇÕES PERÍODO”
FONTE: O autor
13 CLASSES JLIST
A classe JList permite a criação de um componente tipo lista, no qual o
usuário pode selecionar uma ou várias opções (FURGERI, 2015). O Quadro 4
apresenta os métodos disponibilizados pela classe JList.
QUADRO 4 – MÉTODOS DISPONIBILIZADOS PELA CLASSE JLIST
Como será criada nova classe para novo painel, inclua na classe
GuiAcessoInterno mais um item de menu, declarando o objeto de
“itemOpcaodisciplina”, conforme Linha 20 da Figura 27.
FIGURA 27 – DECLARAÇÃO DE NOVO ITEM DE MENU ITEMOPCAODISCIPLINA
FONTE: O autor
193
Outra alteração na classe GuiAcessoInterno é a criação do objeto

“itemOpcaodisciplina”, conforme Linha 44 da Figura 28, onde foi passado por
parâmetro o valor “Opções Disciplinas”.
FIGURA 28 – CRIAÇÃO DE OBJETO ITEMOPCAODISCIPLINA
FONTE: O autor
Logo após a alteração apresentada na Figura 28, é necessário adicionar o

objeto “itemOpcaodisciplina” ao objeto “menuExemplo”, conforme Linha 50 da
Figura 29.
FIGURA 29 – ADIÇÃO DE OBJETO ITEMOPCAODISCIPLINA AO MENU
FONTE: O autor
A última alteração na classe GuiAcessoInterno é a criação do evento do

novo item de menu no método vincularEventos, conforme apresentado na Figura
30, para que seja aberto o painel implementado na classe GuiListaDisciplina.
Perceba que a implementação da classe GuiListaDisciplina é apresentada logo a
seguir.
FIGURA 30 – INCLUSÃO DE EVENTO PARA ITEM DE MENU ITEMOPCAOPERIODO
FONTE: O autor
Com estes ajustes realizados, e após implementada a classe

GuiListaDisciplina, conforme apresentada na Figura 31, a aplicação pode ser
testada novamente, a qual terá o novo item no menu “Exemplos” ativo, sendo
aberto o painel criado pela classe GuiListaDisciplina.
194
FIGURA 31 – IMPLEMENTAÇÃO DA CLASSE GUILISTADISCIPLINA
FONTE: O autor
195
Conforme código-fonte da Figura 31, nas linhas 16 e 17 foram declarados

dois tipos novos de classes JList e o JscrollPane, sendo esta segunda classe um
componente para inclusão do componente de lista, melhorando a visualização na
tela. Entre as linhas 27 e 31 do código apresentado na Figura 31, você pode perceber
que foi criada uma variável lista de String, a qual possui algumas disciplinas
em seu conteúdo, utilizada na Linha 35, onde é passada como parâmetro para
a criação do objeto do tipo JList. Na Linha 36 do código-fonte da Figura 31, foi
criado o objeto do tipo JscrollPane, cujo método construtor está recebendo o objeto
do tipo JList. Perceba que como estamos vinculando o objeto “jsDisciplina” ao
objeto “jsScroll”, não é adicionado (método add) o objeto do tipo JList à janela e
também não é utilizado o método setBounds para configuração do objeto na tela,
pois ele estará dentro do objeto do tipo JScrollPane. Por fim, no evento do objeto
“jbListar”, do tipo JButton, na Linha 53 é retornada a lista dos índices do objeto
JList que estão selecionados, e entre as linhas 55 e 57, deve-se atribuir ao nome
das disciplinas selecionadas a variável que é utilizada na linha 59 para exibir a
mensagem ao usuário.
A Figura 32 apresenta a execução do evento do objeto itemOpcaodisciplina,

isto é, o novo item de menu “Opções Disciplinas”.
FIGURA 32 – PAINEL IMPLEMENTADO NA CLASSE GUILISTADISCIPLINA
FONTE: O autor
14 CLASSES JCOMBOBOX
Da mesma forma que componente da classe JList, um componente da
classe JComboBox funciona parecido, permitindo selecionar um ou mais itens
(FURGERI, 2015). O Quadro 5 apresenta os métodos disponibilizados pela classe
JComboBox.
196
QUADRO 5 – MÉTODOS DISPONIBILIZADOS PELA CLASSE JCOMBOBOX
Para apresentação de um exemplo de utilização da classe JComboBox,

foram realizadas algumas alterações na classe GuiListaDisciplina, onde
foram incluídos dois novos objetos: jlCursos do tipo JLabel e jcCursos do tipo
JComboBox, conforme apresentados no código-fonte da Figura 33. Observe
que, entre as linhas 35 e 37 da Figura 33, foi criada uma outra lista de String,
chamada de “listaCursos”, a qual possui três cursos e é utilizada no método
construtor do objeto do tipo JComboBox na Linha 45.
FIGURA 33 – INCLUSÃO DE COMPONENTE DA CLASSE JCOMBOBOX
197
FONTE: O autor
Além disso, na linha 44 da Figura 33, foi criado o objeto “jlCursos” do

tipo JLabel, assim como utilizado o método setBounds para esses dois novos
componentes entre as linhas 46 e 47, sendo ajustadas às alturas dos demais
componentes, pois os dois novos componentes são apresentados acima dos
demais. Os objetos “jlCursos” e “jcCursos” foram adicionados ao frame nas linhas
56 e 57, respectivamente, e entre as linhas 72 e 73 foi adicionado o comando para
pegar o texto do item selecionado do campo tipo JComboBox.
Neste sentido, a Figura 34 apresenta a execução do painel implementado

pela classe GuiListaDisciplina, após inclusão dos campos para selecionar o curso.
198
FIGURA 34 – EXECUÇÃO DO PAINEL IMPLEMENTADO PELA CLASSE GUILISTADISCIPLINA
FONTE: O autor
199
RESUMO DO TÓPICO 1
• Interfaces gráficas são muito importantes, pois usuários de sistemas estão

acostumados a utilizar software que tenham uma interface gráfica mais rica, e
o Java oferece a biblioteca Swing para resolver esta questão.
• A biblioteca Swing é um aperfeiçoamento da antiga biblioteca AWT.
• Aplicações gráficas são aplicações que permitem interface gráfica de usuário

(GUI).
• A biblioteca Swing possui vários componentes visuais, os quais possuem

várias propriedades que permitem personalização de tipo de fonte, cores, entre
outras.
• A classe JFrame permite a criação de uma janela com uma barra de título,
bordas e cores.
• A classe JLabel permite a criação de um tipo de componente que serve como

título para outros componentes.
• As classes JTextField e JPasswordField são classes que permitem a criação de

componente de entrada de text, sendo que a única diferença é o componente
de a classe JpasswordField apresentar, ao digitar algum caracter, asteriscos,
embora o texto real digitado esteja oculto.
• A classe JButton permite a criação de botões, que através da classe ImageIcon é

possível incluir ícone em um botão, melhorando seu visual.
• Para a criação de um objeto do tipo de um componente (classe), basta ter

declarado o objeto, ou mesmo no momento da declaração, incluir o comando
new seguido da classe.
• Algumas classes de componentes possuem parâmetro a ser informado no

método construtor que serve para título ou descrição do componente.
• O método setBounds serve para definir o tamanho de um determinado

componente, assim como definir o posicionamento dele.
• O método setLocation é utilizado para definir o posicionamento de um

componente do tipo Jframe na tela.
200
• Um painel (container) serve para abrigar outros componentes, o qual pode ser
criado através da classe JPanel.
• Para a criação de uma barra de menus em uma janela é utilizada a classe

JMenuBar; para criar um menu utiliza-se a classe Jmenu, e para um item de
um menu a classe JMenuItem.
• As classes JCheckBox e JRadioButton permitem a criação de componentes de

caixas de seleção, mas a diferença é que a classe JRadioButton, quando criado
o componente dentro de um componente do tipo ButtonGroup, permite ao
usuário selecionar apenas uma das opções.
• As classes JList e JComboBox permitem a criação de listas para o usuário

selecionar, sendo que na classe JComboBox normalmente são utilizadas
quando se deseja permitir a seleção de um dos itens.
201
AUTOATIVIDADE
1 Atualmente, os usuários de sistemas estão acostumados a utilizar aplicações

com aparência visual mais amigável, benefício possibilitado pelas novas
linguagens de programação. Neste sentido, assinale a alternativa CORRETA
que apresenta esta possibilidade da linguagem de programação Java:
a) ( ) Atualmente, o AWT é utilizado para o desenvolvimento de sistemas

com visual mais amigável.
b) ( ) O AWT possui componentes melhores que a biblioteca Swing.
c) ( ) O componente para botão, na biblioteca AWT é utilizada a classe
JButton, e no Swing é a classe Button.
d) ( ) O AWT foi substituído pela biblioteca Swing.
2 Os componentes visuais permitem a interação do usuário com o sistema

através de teclado, mouse ou por outros dispositivos que possibilitem a
entrada de dados. Neste sentido, assinale a alternativa CORRETA referente
à interface gráfica ao usuário na linguagem de programação Java:
a) ( ) As classes de componentes do Swing não possuem relação com o pacote

AWT, sendo uma nova geração de componentes melhorados.
b) ( ) Ao ser utilizada a biblioteca Swing para o desenvolvimento de telas
visuais, nenhuma importação do pacote AWT será realizada, sendo
apenas realizadas importações do pacote Swing.
c) ( ) Os componentes visuais do Java permitem a alteração de configurações
em tempo de execução, tais como cor, tamanho, fonte e posição na tela.
d) ( ) Alguns componentes visuais do Java permitem a alteração em tempo
de execução da cor e da fonte, apenas.
3 Ao serem utilizados os componentes do swing, caso implementados eventos

e criados os componentes em tela, ao menos três diretivas de importação
de pacotes são realizados. Além disso, muitos são os componentes que
permitem a entrada de dados para um software através do usuário. Neste
sentido, assinale a alternativa CORRETA referente a componentes de
interface gráfica na linguagem de programação Java:
a) ( ) As classes JRadioButton e JCheckBox permitem o desenvolvimento

do mesmo tipo de componente, mas componentes da JRadioButton
permitem a seleção de apenas um item.
b) ( ) As classes JTextField e JPasswordField permitem a criação de entrada
de texto pelo usuário.
c) ( ) A classe JButton permite a criação de botões, permitindo que o usuário
execute eventos na aplicação, porém não é possível a inclusão de ícone
como imagem neste tipo de componente.
d) ( ) Um componente do tipo JList pode ser descrito como uma lista de
valores que permite ao usuário selecionar apenas uma das opções.
202
4 Seguindo o padrão dos exemplos apresentados neste tópico, isto é, a
estrutura das classes, possuindo o método construtor da classe que invoca
os métodos criarComponentesTela e vincularEventos, assim como a
implementação destes dois métodos, desenvolva uma tela que possua um
botão, que ao pressioná-lo, seja exibida a mensagem “Exibindo a mensagem
solicitada!”. Não esqueça de implementar o método main, o qual serve para
a execução da classe. Segue imagem ilustrativa de como a tela deve ficar.
5 Seguindo o padrão dos exemplos apresentados neste tópico, isto é, a

estrutura das classes, possuindo o método construtor da classe que
invoca os métodos criarComponentesTela e vincularEventos, assim como
a implementação destes dois métodos, e o método main para permitir a
execução da classe, desenvolva uma tela utilizando a biblioteca swing.
Nesta tela deve ter um campo de entrada de texto para usuário informar
o nome de uma pessoa, assim como ter duas opções para seleção do
sexo (masculino ou feminino) desenvolvido com a classe JRadioButton,
permitindo selecionar apenas uma das opções. Além disso, deve ser
utilizada a classe JList para a criação das seguintes opções de lazer que o
usuário pode selecionar: “Assistir Séries”, “Academia”, “Exercícios ao Ar
Livre”, “Viajar”. Abaixo do formulário, deve ser criado um botão, que ao
ser pressionado, seja apresentado o nome informado da pessoa, seu sexo
e as opções de lazer selecionadas. Não esqueça de realizar a validação de
cada campo no evento do botão, para garantir que todos sejam informados
pelo usuário. Segue imagem ilustrativa de como a tela deve ficar.
203
204
UNIDADE 3
TÓPICO 2
MANIPULAÇÃO DE DADOS: UTILIZANDO JDBC PARA DESKTOP
1 INTRODUÇÃO
Agora que você já sabe como desenvolver aplicações desktop em Java,
existe mais um passo para tornar suas aplicações mais úteis: realizar consulta
e manutenção de dados em um banco de dados, permitindo que uma tela de
cadastro, por exemplo, insira os dados da tela em uma tabela do banco de dados,
podendo ser recuperado posteriormente. Neste sentido, este tópico apresenta
os principais fundamentos para manipulação de dados em Java, inclusive
apresentando alguns exemplos básicos de comandos SQL, necessários para o
desenvolvimento destas funcionalidades.
Neste tópico, você aprenderá a realizar manipulação de dados através de

programas Java, funcionalidade parecida para aplicações web, que será estudado
no tópico a seguir através da tecnologia Servlet. Portanto, siga os exemplos e os
implemente para seu melhor entendimento da tecnologia, sendo um recurso
indispensável para o desenvolvimento de aplicações.
2 JDBC: MANIPULAÇÃO DE DADOS

Neste contexto de manipulação de dados em Sistemas Gerenciadores
de Banco de Dados (SGBD), a linguagem de programação Java possui uma
biblioteca de classes que permitem conexão com algum banco de dados, sendo
estas classes pertencentes ao pacote JDBC (Java Database Connectivity) (SIAHAAN;
SIANIPAR, 2019). Neste sentido, o JDBC pode ser entendido por ser uma API
(Aplication Program Interface) que permite comunicação com vários Sistemas
Gerenciadores de Bancos de Dados (SGBD), dentre eles o Oracle, MySQL, SQL
Server, entre outros (FAIN, 2011). Para se utilizar o JDBC, para manipulação de
dados, indiferentemente de qual SGBD é utilizado, a linguagem padrão para a
manipulação de dados é o SQL (Structured Query Language) (FURGERI, 2015).
Além disso, segundo Furgeri (2015), é possível manipular dados em um

banco de dados através de frameworks, evitando a necessidade de conhecer a
linguagem SQL, sendo um exemplo o framework Hibernate, um dos mais utilizados
no Java. No entanto, como você está aprendendo o básico da linguagem Java, para
não complicar seus estudos ainda mais, este livro trata apenas de manipulação de
dados utilizando o JDBC, com alguns comandos básicos do SQL.
205
DICAS
Para compreender o Hibernate, acesse os artigos: https://www.caelum.com.br/

apostila-java-web/uma-introducao-pratica-ao-jpa-com-hibernate/ e https://www.devmedia.
com.br/jpa-e-hibernate-acessando-dados-em-aplicacoes-java/32711.
Segundo Fain (2011), o Java possui dois pacotes com classes que são
necessárias para trabalhar com banco de dados: o java.sql e o javax.sql. O pacote
java.sql possui classes normalmente utilizadas, como Connection, Statement e
ResultSet, as quais você verá o uso nos exemplos. Já o pacote javax.sql é utilizado
para oferecer suporte à conectividade do banco de dados no lado do servidor,
possuindo classes como DataSource e RowSet.
Neste sentido, drivers JDBC (Java Database Connectivity) enviam instruções

SQL do Java para um SGBD para execução, ou ainda simplesmente executam
um programa armazenado dentro de um SGBD, chamado de procedimento
armazenado (SIAHAAN; SIANIPAR, 2019). Segundo Fain (2011), se os dados
forem recuperados como resultado dessas ações, o programa Java realizará a
manipulação dos dados fazendo chamadas apropriadas para o JDBC.
O driver JDBC realiza o papel de intermediário entre um programa Java

e um SGBD, sendo que os drivers estão disponíveis em fornecedores de banco
de dados, como o Oracle. Segundo Fain (2011), existem quatro tipos de drivers
JDBC:
• Driver Tipo 1: este funciona como uma ponte entre o JDBC e o ODBC,
permitindo que programas Java manipulem dados através de banco de dados
utilizando drivers ODBC da Microsoft. No entanto, dentre as desvantagens
de utilização de drivers ODBC é o fato de serem mais lentos que os demais,
além de terem de ser instalados e configurados na máquina de cada usuário,
sendo executados apenas em máquinas Windows. Este tipo de driver JDBC
raramente é usado.
• Driver Tipo 2: este driver possui classes Java que funcionam em conjunto com
drivers nativos fornecidos pelo fornecedor do SGBD. Estes drivers possuem
a vantagem de funcionarem mais rápido que os drivers do Tipo 1, porém
requerem instalação e configuração na máquina onde os programas Java são
executados.
• Driver Tipo 3: este driver, também chamado de middleware, pode ser fornecido
por fornecedores de servidores de aplicativos, sendo consistido por duas
partes: a parte do cliente executa uma chamada SQL, e esta é convertida em
um protocolo DBMS específico pela parte do servidor do driver.
206
TÓPICO 2 | MANIPULAÇÃO DE DADOS: UTILIZANDO JDBC PARA DESKTOP
• Driver Tipo 4: este é o driver Java puro, o qual geralmente é um arquivo na

extensão .jar, e executa chamadas diretas para o servidor de banco de dados.
Este tipo de driver não necessita de nenhuma configuração na máquina do
cliente, sendo incluído o nome da classe do driver principal no código Java,
conforme você aprenderá no desenvolvimento dos exemplos.
Ainda segundo Fain (2011), para ambientes em produção, é possível

implantar o tipo de driver 3, o qual fornece um melhor desempenho para as
aplicações. Entretanto, normalmente se utiliza o tipo 4, o qual é mais simples de
ser implementado, e é este que será utilizado nos exemplos de aplicações com
persistência em banco de dados deste livro.
Não importa qual o Sistema Gerenciador de Banco de Dados (SGBD) a ser

utilizado, mas normalmente existem os seguintes passos básicos necessários para
se conseguir realizar a manipulação de dados através de uma aplicação:
• Criação do banco de dados: este passo você realizou na Unidade 1 deste livro.
• Inclusão do driver de conexão JDBC na aplicação ou dentro do diretório lib do
servidor de aplicação Tomcat.
• Definição do endereço de conexão com o banco de dados: realizada no momento
de configuração do banco de dados, sendo normalmente em um computador
de teste, é localhost mais a porta.
• Desenvolvimento da aplicação que realizará a manipulação de dados no SGBD.
Conforme já descrito, para realizar o acesso a um banco de dados através

da linguagem de programação Java, é necessário realizar o carregamento de um
driver específico para o Sistema Gerenciador de Banco de Dados a ser utilizado
na aplicação. De acordo com Furgeri (2015), diferentes versões de drivers para
o mesmo SGBD existem e, normalmente, basta baixar o driver de algum site da
Internet, assim, é possível adicionar o caminho do arquivo baixado, do arquivo
.jar, à variável de ambiente CLASSPATH, ou ainda copiar o driver.jar para a pasta
“ext” do diretório do Java instalado na máquina, sendo então “java\jre8\lib\ext”
ou a versão do JRE instalada.
Ainda segundo Furgeri (2015), para que o pacote seja encontrado em

tempo de desenvolvimento pelas IDEs, basta copiar o arquivo .jar de conexão
para a pasta do jdk instalada na máquina, sendo “jdk1.8.0_11\jre\ lib\ext”, ou
outra versão do JDK utilizado na máquina. Existe outra forma para garantir que o
driver JDBC seja encontrado, sendo a importação do .jar para dentro da aplicação
sendo desenvolvida, conforme você aprenderá neste tópico.
Para a implementação de uma classe de conexão com um banco de dados,

é necessário carregar o driver do SGBD correto, sendo que para cada um existe
um driver diferente. Neste sentido, segundo Furgeri (2015), em Java, o driver
é carregado na memória por meio da sintaxe Class. forName(“pacote.nome-do-
driver”). Seguem alguns drivers que podem ser utilizados no Sistema de Banco
de Dados:
207
• Access: Class.forName(“sun.jdbc.odbc.JdbcOdbcDriver”).
• MySQL: Class.forName(“com.mysql.jdbc.Driver”).
• Oracle: Class.forName(“oracle.jdbc.driver.OracleDriver”).
• Microsoft SQL Server 2000: Class.forName(“com.microsoft.jdbc.sqlserver.
SQLServerDriver”).
• Sysbase: Class.forName(“com.sybase.jdbc2.jdbc.SybDriver”).
• PostgreSQL: Class.forName(“org.postgresql.Driver”).
Neste contexto, para apresentar o processo de desenvolvimento de uma

aplicação em Java que desempenhe manipulação de dados em um SGBD, são
criadas pequenas aplicações as quais realizam leitura e gravação de dados em
tabelas do SGBD MySQL. Ressaltando que você já deve ter realizado a instalação
e configuração do MySQL, conforme apresentados os passos na Unidade 1 deste
livro.
3 CRIAÇÃO DE CLASSE DE CONEXÃO

Inicialmente, deve ser criado um novo projeto Java, e, para isso, no Eclipse,
dentro da guia “Project Explorer”, clique com o botão direito do mouse, selecione a
opção “New” e então a opção “Project”, conforme apresentado na Figura 35.
FIGURA 35 – CRIAÇÃO DE NOVO PROJETO JAVA
FONTE: O autor
Na janela que abrir, selecione a opção “Java Project”, pressionando

o botão “Next”, e então informe o nome do projeto desejado, o qual pode ser
“CadastroCliente”, pois será desenvolvido neste tópico uma aplicação para esta
funcionalidade. O novo projeto Java criado está ilustrado na Figura 36, onde você
pode notar que já foi criada inclusive a package “br.com.conexao”, a qual você
deve criar para seguir os exemplos deste tópico.
208
FIGURA 36 – EXEMPLO DE NOVO PROJETO CRIADO
FONTE: O autor
Sobre a package “br.com.conexao”, clique com o botão direito do mouse

e selecione a opção “New” e então “Class”, para ser criada uma classe em Java,
e então na janela que abrir, informe o nome “ConexaoBD”, a qual servirá para
retornar a conexão com o banco de dados. Antes da implementação da classe de
conexão, analise a Figura 37, a qual apresenta o arquivo .jar baixado, sendo este
específico para o MySQL, se no momento em que você estiver desenvolvendo for
disponibilizado um conector com versão mais recente, é ideal baixar a nova versão.
FIGURA 37 – ARQUIVO .JAR DO JDBC BAIXADO PARA UM DIRETÓRIO
FONTE: O autor
Com o arquivo .jar baixado, é necessário que ele seja importado para
dentro do projeto, o que, conforme descrito anteriormente, é uma das formas
de se utilizar o conector Java com o banco de dados. Neste sentido, clique com
o botão direito do mouse sobre o projeto, conforme apresentado na Figura 38, e
então selecione “Build Path” e “Configure Build Path”.
209
FIGURA 38 – IMPORTAÇÃO DE BIBLIOTECA (.JAR) PARA DENTRO DE PROJETO
FONTE: O autor
Com o passo exposto na Figura 38, é apresentada a janela ilustrada na

Figura 39, na qual você deve selecionar a opção “Add External JARs...”, que será
aberta a caixa de diálogo para seleção do arquivo .jar baixado, bastando selecioná-
lo, e então pressionar o botão “Apply and Close”. Note na Figura 39 como o arquivo
.jar deve ser apresentado após importado.
FIGURA 39 – JANELA ABERTA PARA IMPORTAÇÃO DE BIBLIOTECA (.JAR) PARA

DENTRO DE PROJETO
FONTE: O autor
A criação da tabela Cliente no banco de dados Uniasselvi é mais uma

configuração necessária para permitir a implementação do sistema de cadastro
de cliente, conforme apresentados comandos do MySQL na Figura 40, através
da linha de comando do MySQL, o qual, conforme você já aprendeu, é instalado
com o MySQL.
FIGURA 40 – CRIAÇÃO DE TABELA CLIENTE NO BANCO DE DADOS UNIASSELVI
FONTE: O autor
210
E
IMPORTANT
Para acessar a linha de comando do MySQL, no Sistema Ooperacional

Windows, digite MySQL, o qual deve retornar entre as opções, o “MySQL Line Command”,
bastando pressioná-lo.
Por fim, basta inserir registros na tabela Cliente, conforme o comando

INSERT do SQL na Figura 41.
FIGURA 41 – EXEMPLO DE COMANDO INSERT DO SQL PARA POPULAR TABELA CLIENTE
FONTE: O autor
DICAS
Caso você tenha dúvidas de comandos SQL básicos, acesse o artigo: https://
www.devmedia.com.br/primeiros-passos-no-mysql/28438.
Continuando com a implementação da classe de conexão ConexaoBD,

classe necessária para carregar um driver de comunicação com o banco de dados,
no caso de exemplos deste livro, o MySQL, permitindo a criação de uma aplicação
que realiza a manipulação de banco de dados. Neste sentido, para facilitar a
compreensão e a padronização do código-fonte, a manipulação do banco de
dados é apresentada pela classe de conexão, e após será criada uma outra classe
para manipulação de dados.
Neste sentido, implemente a classe ConexaoBD, criada anteriormente,

com o código-fonte sendo apresentado na Figura 42.
211
FIGURA 42 – CLASSE DE CONEXÃO COM BANCO DE DADOS
FONTE: O autor
Referente ao código-fonte da Figura 42, na linhas 3 e 4 foram importadas

as classes do pacote SQL necessárias para buscar uma conexão com o banco de
dados. Na Linha 13 deste código-fonte, é carregado o driver a ser utilizado pela
aplicação Java para realizar a comunicação com o banco de dados. Observe que o
comando Class.forName foi implementado dentro de um bloco try-catch, pois se
o driver puder ser carregado, por não ter sido localizado, então será ocasionada
a exceção ClassNotFoundException, portanto, se em sua aplicação ocorrer este
erro, verifique se o .jar de conexão está corretamente importado na aplicação. A
Linha 14 do código-fonte da Figura 42, estabelece a conexão através do objeto
conn do tipo Connection, contendo a URL de conexão com o banco de dados
MySQL, além dos parâmetros usuário e senha, necessários para conexão com o
banco de dados.
Segundo Furgeri (2015), a URL de conexão poderia ser “jdbc:mysql://

localhost:3306/mysql”, sendo o último parâmetro “mysql” o nome do banco de
dados. A Linha 14 também implementada dentro do bloco try-catch, pois caso
a conexão não possa ser realizada, será ocasionada a exceção SQLException.
Quanto aos dados de login e senha, são os dados que você informou no momento
da configuração do MySQL, e caso você seguiu o passo a passo deste livro, o
usuário é “root” e senha “root”, sendo que o usuário padrão do MySQL é “root”,
a menos que você inseriu algum outro usuário.
212
Perceba que a classe apresentada na Figura 42 possui apenas um método

que retorna a conexão com o banco de dados através do objeto “conn”. Neste
sentido, após a conexão recebida, o trecho de código-fonte que invocar o método
getConnection deverá realizar o tratamento para fechar a conexão assim que esta
não for mais necessária, para inativar usuários indevidos no banco.
Agora, partindo para a implementação de uma classe teste para utilização

da conexão com o banco de dados, após implementada a classe de conexão, crie
uma nova package no projeto “br.com.view”, sendo que nesta serão criadas classes
de implementação de telas com componentes Swing. Crie então nesta package uma
classe chamada TesteBD, conforme código-fonte apresentado na Figura 43.
FIGURA 43 – CLASSE DE EXEMPLO PARA CONSULTA DE DADOS
FONTE: O autor
213
A Linha 13 do código-fonte da Figura 43 invoca o método getConnection

da classe ConexaoBD, sendo armazenada a conexão recebida no objeto conn
do tipo Connection. Na Linha 16 é criado um objeto ps do tipo da interface
PreparedStatement, o qual é utilizado na Linha 21, que permite a execução de
um script SQL através da conexão realizada com o banco de dados pelo objeto
conn. Na Linha 17 é criado o objeto resultSet do tipo da interface ResultSet, o qual
é utilizado para armazenar o resultado gerado pelo script SQL, na Linha 22,
por meio do método executeQuery do objeto preparedStatement. Segundo Furgeri
(2015), é possível dizer que objetos do tipo ResultSet armazenam o resultado da
ação efetuada pelo script SQL.
Ainda referente à Figura 43, o comando SQL pode ser entendido da

seguinte forma: o asterisco indica a seleção de todos os campos da tabela, então
selecione (SELECT) os campos CODIGO, NOME, EMAIL e SEXO da tabela
CLIENTE. Segundo Furgeri (2015), o resultado do comando SQL é armazenado
no objeto resultSet, com formato de uma tabela que possui linhas e colunas,
baseado na tabela em que a consulta é realizada. Outro ponto importante você
saber é na Linha 23, na qual é utilizado o comando while “while (resultSet.next())”,
que realiza a consulta de todas as linhas retornadas no comando SQL, isto é, se
forem encontrados 10 registros, então a impressão de dados de 10 registros serão
impressos entre as linhas 24 a 27. Caso você deseja imprimir os dados somente
do primeiro registro encontrado no comando SQL, então deveria ser utilizado “if
(resultSet.next())”.
Após executada a classe da Figura 43, você perceberá que haverá a

impressão no console dos dados entre as linhas 24 e 27.
FIGURA 44 – IMPRESSÃO NO CONSOLE DADOS ORIUNDOS DO COMANDO SQL
FONTE: O autor
Para Furgeri (2015), um objeto do tipo ResultSet recebe o retorno da

execução de um comando SQL, recebendo todos os registros retornados pelo
comando SQL. Ainda segundo Furgeri (2015), um objeto do tipo ResultSet possui
vários métodos, sendo alguns deles:
• first(): método que posiciona o cursor no primeiro registro retornado pelo SQL.
Exemplo: “resultSet.first()”;
• last(): método que posiciona o cursor no último registro retornado pelo SQL.
Exemplo: “resultSet.last()”;
214
• next(): método que posiciona o cursor para o próximo registro. Exemplo:

“resultSet. next()”;
• previous(): método que posiciona o cursor no registro anterior em relação ao
atual. Exemplo: “resultSet.previous ()”.
Um cuidado que se deve ter ao utilizar o tipo de método para retornar

algum dado de uma tabela, sendo o tipo do campo da tabela um e for solicitado
pelo método de outro tipo, como no caso do erro apresentado na Figura 44, onde
o campo da tabela é de um tipo String (Varchar, Char) que aceita caracteres
alfanuméricos, e o método solicitado para este campo foi o getInt, o qual é do tipo
inteiro.
FIGURA 45 – EXEMPLO DE ERRO COMUM AO SER REALIZADA CONSULTA NO BANCO DE DADOS
FONTE: O autor
4 PADRÃO DAO
O padrão de projeto DAO foi desenvolvido pela necessidade de realizar
a separação da lógica de negócios de uma aplicação com a lógica de persistência
de dados (acesso a dados de uma tabela de banco de dados) (SONI, 2015). Uma
das vantagens da utilização deste padrão é a possibilidade de alterar a forma de
persistência, podendo alterar um comando SQL por exemplo, sem influenciar em
códigos-fonte da lógica de negócio, e, além disso, torna as classes mais legíveis,
pois o acesso aos dados de uma tabela estarão em uma classe DAO específica
(LUCKOW; MELO, 2010).
Neste sentido, as classes DAO servem para realizar a troca de dados

com o Sistema Gerenciador de Banco de Dados (SGBD), fornecendo operações
de manipulação de dados em tabelas (alteração, inclusão, consulta e exclusão)
(LUCKOW; MELO, 2010). Com isso, estas classes permitem consultar dados de
uma tabela, e então transformá-los em objetos ou lista de objetos.
Neste contexto, uma classe DAO referencia a uma única tabela do banco
de dados, como no caso da aplicação de cadastro de cliente, será utilizada a
tabela Cliente, então será desenvolvida uma classe ClienteDAO (SONI, 2015).
Também deve ser criada uma classe entidade, isto é, uma classe que representa
a tabela, possuindo todos os campos da tabela em atributos na classe, pois um
objeto do tipo da classe entidade que é retornada em uma consulta, conforme
você aprenderá.
215
Para isso, crie uma nova package (pacote) no projeto, chamado “br.com.
entidade”, na qual devem ser criadas classes ‘entidade’ dentro dela. Neste sentido,
crie a classe Cliente, apresentada na Figura 46, a qual você pode perceber que que
possui a estrutura da tabela Cliente.
FIGURA 46 – CLASSE QUE REPRESENTA A TABELA CLIENTE
FONTE: O autor
Agora, para a implementação de um exemplo do padrão DAO, deve ser

criada a classe ClienteDAO, a qual pode ter todas as operações para manipulação
de dados, isto é, um método para inserir registro, outro para alterar um registro,
método para excluir, outro método para consultar um determinado registro, e um
outro para retornar uma lista de registros em objetos. Analise a implementação
da classe ClienteDAO, apresentada na Figura 47, onde você pode perceber dois
métodos de consulta de cliente, um para inserir cliente, um para alterar um cliente
e outro para realizar a exclusão do registro na tabela do banco de dados.
216
FIGURA 47 – IMPLEMENTAÇÃO DA CLASSE CLIENTEDAO
217
218
FONTE: O autor
Conforme a implementação da classe ClienteDAO, apresentada na

Figura 47:
• Entre linhas 3 e 8 do código-fonte são realizadas importações da biblioteca

JDBC, utilizadas na classe, e na Linha 10 importada a classe Cliente, utilizada
como parâmetro e retorno dos métodos.
• Na Linha 13 do código-fonte, o atributo “connection” do tipo Connection está
declarado, o qual recebe a instância com a conexão do banco de dados na Linha
15, dentro do método construtor, através do parâmetro do mesmo tipo.
• O método consultar, implementado entre as linhas 19 e 48, possui o parâmetro
“codigo” do tipo int, sendo o código do cliente a ser consultado, e, neste caso,
este método retorna um objeto do tipo Cliente. Note que no método consultar,
é realizado o comando SQL “SELECT * FROM CLIENTE”, o qual retorna todos
os campos da tabela, pois foi utilizado o asterisco, e a cláusula where “WHERE
CODIGO = ?” é uma condição que retorna somente o registro da tabela que
possui o código de cliente passado por parâmetro (interrogação). Perceba que
na Linha 23, é declarado o objeto “cliente” do tipo Cliente, o qual é o retorno
do método, na Linha 47, através da palavra reservada return. Na Linha 28 é
passado o parâmetro para o comando SQL, através do comando “ps.setInt”,
cujos parâmetros são a sequência do parâmetro, que neste caso é 1, pois somente
existe ele, e o valor do parâmetro, que é o parâmetro “codigo” do cliente a ser
consultado. Na Linha 31, o objeto “cliente” é instanciado, e entre as linhas 32
e 35 são atribuídos os valores das colunas aos respectivos atributos do objeto
“cliente”, isto é, na Linha 32, o comando “resultSet.getInt("CODIGO")” retorna
o valor do campo “CODIGO” da tabela do banco de dados, e este é atribuído
ao atributo codigo do objeto “cliente” através do método setCodigo, e após
219
executar esta linha, ao ser invocado o método getCodigo(), este retornará o

valor atribuído para o atributo codigo. Ainda referente às linhas 32 e 35, note
que dependendo do tipo do atributo, é utilizado o método getInt ou getString,
pois é necessário retornar o mesmo tipo de dado para o atributo do objeto
“cliente”, mas a classe ResultSet possui outros métodos para outros tipos,
como: getDouble, getBoolean, getBigDecimal, entre outros. Ao final do método
consultar, entre as linhas 39 e 45, os objetos “preparedStatement” e “resultSet”
são fechados e recebem valor null para limpeza da memória. Uma observação
importante é que na Linha 30 do método consultar, em que foi utilizado o
comando while, que enquanto houver registros encontrados na consulta,
o trecho entre as linhas 31 e 35 é executado, porém como a consulta retorna
apenas um único registro, se encontrar, esta linha poderia ser substituída por
“if (resultSet.next()){”, que entra uma única vez se tiver registro encontrado.
• No método listarClientes, entre as linhas 50 e 81, também é realizada consulta
na tabela Cliente do banco de dados, porém, neste método, retorna o tipo
“List<Cliente>”, isto é, uma lista de objetos do tipo Cliente. Note que na Linha
58, ao invés da cláusula WHERE do SQL, existe apenas o comando SQL “ORDER
BY CODIGO”, que apenas ordena os registros pelo campo “CODIGO”, não
existindo um filtro, e neste caso retorna todos os registros da tabela. Na Linha
55, é criado um objeto do tipo List<Cliente> (lista de objetos do tipo Cliente),
o qual é o retorno do método listarClientes, utilizado na Linha 68, para o qual
é adicionado cada objeto criado do tipo Cliente. Na Linha 62 é criado o objeto
cliente do tipo Cliente, e nas linhas 63 e 66, são atribuídos os valores dos campos
da tabela aos seus respectivos atributos do objeto cliente, que, então, na Linha
68 é adicionado à lista chamada “lista”. Na Linha 80 o objeto “lista” é retornado
para o trecho de código que invocou o método listarClientes.
• Entre as linhas 84 e 106, está implementado o método inserir, o qual serve
justamente para realizar a inserção de um registro na tabela Cliente através de
um objeto do tipo Cliente, passado por parâmetro. Neste método existe apenas
o parâmetro “cliente” do tipo Cliente, o qual é utilizado para passar os valores
de seus atributos para os parâmetros do objeto “preparedStatement”, para que
seja inserido o registro na tabela CLIENTE do banco de dados. Na Linha 92
está implementado o comando SQL “INSERT”, sendo que na Linha 93 é sua
continuação, sendo declarados os parâmetros para cada campo a ser inserido,
isto é, existem quatro campos na tabela, então existem quatro parâmetros
(ou quatro interrogações). Entre as linhas 95 e 98 são passados os valores dos
atributos do objeto “cliente” para os parâmetros do objeto “preparedStatement”.
Perceba que na Linha 88 é criada a variável “proximo”, do tipo int, recebendo
a quantidade de objetos retornados pelo método listarClientes, através da
propriedade “size”, sendo na Linha 89 atribuído mais uma variável, ou seja,
pegando a quantidade de clientes cadastrados mais um para gerar o código do
próximo registro a ser inserido na tabela. Sendo que o parâmetro, na Linha 95,
recebe o valor da variável “proximo”.
220
• Entre as linhas 108 e 130, está implementado o método alterar, o qual também
recebe por parâmetro um objeto do tipo Cliente, sendo utilizados seus atributos
para atribuir seus valores para os parâmetros do objeto “preparedStatement”
entre as linhas 116 e 119. Analise o comando SQL na Linha 113, o qual é
constituído do comando “UPDATE”, que indica alteração, mais o nome da
tabela “CLIENTE”, seguido do comando “SET”, e então os campos da tabela a
serem alterados, sendo que cada nome de campo da tabela é seguido do sinal
de igual com uma interrogação, indicando a sequência de parâmetro. Na Linha
114, existe a cláusula where “WHERE CODIGO = ?”, o que indica que somente
o registro com este código de cliente será alterado, sendo especificado o cliente
na Linha 119. Entre as linhas 121 e 123 está implementada uma validação, e
caso a quantidade de registros alterados for diferente de um, então é causada
uma exceção para abortar o processo que solicitou esta alteração.
• Por último, entre as linhas 132 e 152, está implementado o método excluir, que
da mesma forma que o método alterar, recebe por parâmetro um objeto do tipo
Cliente, mas na linha 137 está implementado o comando SQL “DELETE FROM”
seguido do nome da tabela “CLIENTE”, que exclui registros da tabela cliente.
Na Linha 138 está implementada a continuidade do comando de exclusão
de registro, sendo a cláusula where “WHERE CODIGO = ?”, o que permite
que apenas o registro que contenha o código especificado no parâmetro seja
excluído. Entre as linhas 142 e 145 está implementada a validação que caso
a quantidade de registros excluídos seja diferente de um, então é causada
exceção no trecho de código que invocou o método excluir.
Após a implementação da classe ClienteDAO, apresentada na Figura 47, é

importante realizar mais um teste de conexão com o banco de dados, invocando
alguns dos métodos de nossa classe ClienteDAO. Para isso, implemente a classe
TesteDaoBD, apresentada na Figura 48, na qual você pode analisar na Linha 15 a
instância da classe ClienteDAO, cujo método construtor requisita um objeto do
tipo Connection como parâmetro, e que, para isso, foi passado o objeto “conn”.
Ainda referente à Figura 48, na Linha 16 foi criado um objeto do tipo List<Cliente>,
isto é, armazena uma lista de objetos do tipo Cliente. Na Linha 18, é invocado o
método listarClientes da classe ClienteDAO, sendo atribuída a lista retornada
pelo método para o objeto “listaClientes”. Entre as linhas 20 e 28, é realizada a
iteração da lista de objetos, através do comando for, sendo impresso no console
o valor dos atributos de cada objeto da lista, sendo criado no comando for um
objeto cliente do tipo cliente que recebe a posição atual da lista. Entre as linhas
30 e 38, é realizada a mesma funcionalidade, apenas com uma forma diferente de
iteração, onde foi criada uma variável do tipo int para controle da iteração, e o
valor dos atributos é impresso diretamente do objeto da lista.
221
FIGURA 48 – IMPLEMENTAÇÃO DE CLASSE DE TESTE PARA TESTEDAOBD
FONTE: O autor
222
Através da classe ClienteDAO, apresentada na Figura 47, é fácil

compreender o porquê da importância do uso do padrão DAO, ou seja, toda a
persistência (consulta, inclusão, alteração ou exclusão de registros) de uma tabela
do banco de dados é implementada apenas na classe DAO que referencia a tabela.
O trecho de código-fonte que invocar métodos da classe DAO apenas visualiza o
método, não misturando comandos SQL em outras implementações, tornando o
código-fonte mais legível, e, além disso, a manutenção do código-fonte se torna
mais fácil, pois qualquer programador saberá onde é realizada a persistência de
uma determinada tabela.
5 APLICAÇÃO DESKTOP (SWING) COM BANCO DE DADOS

Agora que você já compreendeu alguns comandos SQL básicos, assim
como a importância e a implementação do padrão DAO, a Figura 49 apresenta a
implementação de uma tela, na qual é invocado o método listarClientes, da classe
ClienteDAO, que retorna a lista de clientes cadastrados, sendo carregados todos
os registros em uma tabela (grid) na tela, criada a partir da classe JTable do Swing.
FIGURA 49 – CLASSE DE TELA UTILIZANDO COMPONENTES SWING COM ACESSO

A BANCO DE DADOS
223
224
FONTE: O autor
Conforme você já aprendeu, as primeiras linhas do código-fonte

apresentado na Figura 49 se referem às importações das bibliotecas, sendo a
maioria delas só Swing e AWT, porém, entre as linhas 18 e 20, foram importadas
as classes Cliente, ClienteDAO e ConexaoBD. Na Linha 25 está declarado o objeto
“jtTabelaClientes” do tipo JTable, classe que serve para apresentar tabelas em
telas, conforme você aprenderá neste exemplo. Na Linha 26, está declarado o
objeto “jsScrollTable” do tipo JScrollPane, o qual é criado na Linha 41 e adicionado
ao frame na Linha 45. Na linha 54, evento do botão criado através do objeto
“jbConsulta”, é invocado o método “carregarTabelaClientes”, o qual pode ser
explicado da seguinte forma:
• Na Linha 61 está sendo solicitada a instância da classe Connection, para se ter

a conexão com o banco de dados.
• Na Linha 62 é instanciada a classe ClienteDAO.
• Na Linha 63, conforme exemplo anterior, é declarado um objeto do tipo
List<Cliente>, o qual recebe na linha 65 a lista de objetos do tipo Cliente, através
do método listarClientes da classe ClienteDAO.
• Na Linha 67 é criado o objeto “tableModel” do tipo DefaultTableModel, o qual
é utilizado para criar os títulos das colunas da tabela, sendo que este objeto é
enviado por parâmetro ao construtor da classe JTable, na Linha 73, para que a
tabela seja criada com estas colunas.
• Na Linha 74 é criado o objeto defaultTableModel, também do tipo
DefaultTableModel, recebendo a instância a partir do método getModel do
objeto jtTableClientes, vinculando as linhas a este objeto, utilizado para criar
cada linha de item da tabela.
• Na Linha 76 é iterado o objeto listaClientes através do comando for, sendo que
entre as linhas 79 e 82 é atribuído o valor de cada atributo do objeto atual da
lista ao respectivo campo da tabela, isto é, na Linha 78 é criado uma lista de
Strings de 4 posições (linhas), sendo que cada linha representa uma coluna da
tabela (índice zero do objeto dadosTabela representa o campo código, Índice
1 representa o campo nome, Índice 2 representa o campo e-mail e Índice 3
representa o campo sexo);
• Na Linha 84, é adicionado o objeto dadosTabela com a lista de valores de cada
campo, para o objeto “defaultTableModel”.
• Na Linha 86, a tabela é adicionada ao componente da tela jsScrollTable para
exibição atualizada da tabela.
225
Para finalizar o entendimento da utilização do JDBC em uma aplicação

desktop Java, foi alterada a implementação da classe TabelaListaCliente,
apresentada na Figura 50, para a inclusão de novas funcionalidades à tela: inclusão,
alteração, exclusão além da consulta de cliente. Analise a Figura 51, a qual ilustra
a tela a ser implementada com a alteração da classe TabelaListaCliente, com as
seguintes alterações:
• Inclusão de campo código, que recebe o código ao selecionar linha da tabela

(grid) da tela, utilizado para alteração ou exclusão do registro.
• Incluídos campos nome, e-mail e sexo, os quais sevem tanto para a inclusão
quanto para alteração dos dados de um registro.
• Incluído o campo “Gravar”, o qual realiza a inclusão de um novo registro, se o
campo código estiver em branco, e alteração do registro que foi selecionado na
tabela (grid) da tela.
• Incluído botão “Cancelar”, o qual apenas realiza a limpeza dos campos da tela.
• Incluído botão “Excluir”, o qual invoca o método excluir da classe ClienteDAO,
realizando a exclusão do registro (cliente).
• A carga da tabela (grid) com todos os cadastros, é realizada no momento do
carregamento da tela.
FIGURA 50 – TELA DE CADASTRO DE CLIENTE
FONTE: O autor
Neste sentido, a Figura 51 apresenta a implementação da tela ilustrada

na Figura 50, cujo código-fonte foi alterado para a inclusão dos novos campos
na tela e novas funcionalidades. Analise a linha do código-fonte da Figura 51,
onde foi eliminada a declaração do botão que havia, e incluídos três novos
componentes do tipo JButton, além disso, foram incluídas as declarações para
os novos componentes entre as linhas 32 e 35. Na Linha 40, isto é, dentro do
bloco construtor da classe TabelaListaCliente foi incluída a invocação para o
método carregarTabelaClientes, e dentro do método criarComponentesDaTela,
foi incluída a criação dos novos componentes declarados.
226
FIGURA 51 – TELA DE CADASTRO DE CLIENTE FUNCIONANDO COM TODAS AS OPERAÇÕES
227
228
229
230
FONTE: O autor
Ainda referente ao código-fonte da Figura 51, note que na Linha 45

houve alteração do tamanho da janela (frame), e os componentes que já existiam,
consequentemente também tiveram alteração de tamanho e posicionamento,
portanto, verifique todos os parâmetros de onde é utilizado o método setBounds.
No método vincularEventos foram incluídos eventos para os três novos botões da
tela, e excluído o evento do antigo botão que apenas atualizava a tabela (grid) da
tela. Os três eventos criados são para os seguintes botões:
• jbGrava: implementado entre as linhas 108 e 130 do código-fonte da classe,

sendo realizadas validações se os campos foram informados, que caso positivo, é
invocado o novo método criado na classe chamado gravarCliente, implementado
entre as linhas 263 e 311, assim como os métodos carregarTabelaClientes
e limparcampos são invocados após a gravação. Referente ao método
gravarCliente, entre as linhas 270 a 272, é realizada uma validação para saber
se o campo jtCodigo possui valor, e caso possuir, é atribuído o valor ao atributo
codigo do objeto “cliente”, para ser tratado como alteração de cadastro e
não alteração. Além disso, na Linha 268 do código-fonte, dentro do método
gravarCliente, é invocado o método setAutoCommit da classe Connection,
sendo enviado por parâmetro para este o valor false, indicando que é o início
de uma transação do banco de dados, e enquanto não for executado o método
commit ou rollback da classe Connection, a transação continua ativa. Entre as
linhas 282 e 286, se o atributo codigo do objeto “cliente” tiver valor maior que
zero, então será realizada alteração, e caso contrário, será realizada inclusão de
um novo registro.
231
• jbCancela: evento deste componente apenas invoca o método limparCampos,

implementado entre as linhas 183 e 191 do código-fonte, o qual apenas realiza
a limpeza dos componentes da tela e joga o foco do cursor no campo nome da
tela. A seleção de qual campo da tela irá receber o foco é realizada através do
método requestFocus, conforme linha 190.
• jbExclui: evento de componente, implementado entre as linhas 141 a 181,
sendo atribuído ao atributo codigo do objeto cliente, instanciado na Linha 148,
o valor do campo código da tela, e invocado então o método excluir da classe
ClienteDAO.
DICAS
Caso você tiver dúvida sobre transação em banco de dados, acesse os artigos:
https://www.devmedia.com.br/java-jdbc-melhorando-o-desempenho-de-aplicacoes-
java/31976 e https://www.devmedia.com.br/transacoes-no-oracle-commit-rollback-e-save
point/349.
Estas são as alterações realizadas na classe TabelaListaCliente, para

manter a tela de cadastro de cliente funcionando com todas as alterações.
Com este exemplo, você conseguirá desenvolver um sistema com várias telas,
realizando a persistência em um banco de dados. Uma observação importante
é você saber que o objeto conn do tipo Connection poderia ter sido instanciado
e recebido a conexão no método construtor da classe, e este ser reutilizado em
cada método de persistência, ao invés de ser instanciado e buscar a conexão
para cada operação realizada, porém são formas diferentes de se desenvolver
uma aplicação.
232
RESUMO DO TÓPICO 2
• JDBC (Java Database Connectivity) é uma biblioteca de classes que permite

conexão e acesso a dados por algum banco de dados na linguagem de
programação Java.
• JDBC permite conexão e acesso a vários SGBDs diferentes, como Oracle,

MySQL, SQL Server, entre outros.
• SQL (Structured Query Language) é a linguagem padrão utilizada para

manipulação de dados em SGBD através do JDBC.
• Através do framework Hibernate é possível manipular dados se utilização de

SQL.
• Dois pacotes do Java necessários para trabalhar com banco de dados são: o
java.sql e o javax.sql.
• O JDBC envia instruções SQL do Java para um SGBD realizando a execução

dos comandos, realizando papel de intermediário entre um programa Java e
um SGBD.
• O driver JDBC tipo 3 é o que fornece um melhor desempenho para as

aplicações, embora normalmente seja utilizado o tipo 4, por ser mais simples
de se implementar.
• Para configurar o JDBC em uma aplicação Java, basta baixar o arquivo do

conector que possui a extensão .jar, importando para dentro do projeto, embora
seja possível adicionar o caminho onde o arquivo está, à variável de ambiente
CLASSPATH, ou ainda copiar o arquivo para a pasta “ext” do diretório do Java
instalado na máquina.
• É necessário carregar o driver do SGBD correto, e, para isso, o driver deve

ser carregado na memória por meio da sintaxe Class. forName(“pacote.nome-
do-driver”), por exemplo, “com.mysql.jdbc.Driver” para o MySQL ou “oracle.
jdbc.driver.OracleDriver” para o Oracle.
• Caso uma aplicação Java que estiver solicitando conexão com um banco de
dados ser executada, e o driver não for localizado, então será ocasionada a
exceção ClassNotFoundException.
233
• A classe Connection serve para receber a conexão com o banco de dados.
• A classe PreparedStatement permite a execução de um comando SQL através

da conexão realizada com o banco de dados pela classe Connection.
• A classe ResultSet armazena o resultado recebido do comando SQL.
• O padrão DAO realiza a separação da lógica de negócios de uma aplicação

com a lógica de persistência de dados, tornando o código-fonte mais legível e
de fácil manutenção.
• A classe JTable, do pacote Swing, permite a criação de componente tabela (grid)

em telas, listando dados de uma consulta SQL.
234
AUTOATIVIDADE
1 A maioria dos sistemas, atualmente, possuem a necessidade de armazenar

dados em um Sistema Gerenciador de Banco de Dados (SGBD) para
posterior consulta ou manutenção. Referente à manipulação de dados em
Java, assinale a alternativa CORRETA:
a) ( ) Em programas Java, a única forma de realizar a comunicação com um

SGBD é através do ODBC.
b) ( ) Para utilização da funcionalidade de manipulação de dados através
de programas Java, não existe a necessidade de baixar bibliotecas, pois
esta funcionalidade está disponível no Java.
c) ( ) A biblioteca JDBC permite a conexão de programas Java apenas com o
SGBD MySQL.
d) ( ) O Java possui a API JDBC, a qual permite manipulação de dados em
um SGBD.
2 Para permitir acesso a um Sistema Gerenciador de Banco de Dados (SGBD)

por um programa Java, é necessário configurar a conexão, assim como
preparar o banco de dados. Referente aos pacotes para manipulação de
dados em Java, assinale a alternativa CORRETA:
a) ( ) O Java possui apenas um pacote com classes necessárias para trabalhar

com banco de dados: o java.sql.
b) ( ) A funcionalidade de manipulação de dados no Java já está disponível,
não necessitando de importação de pacotes e bibliotecas externas.
c) ( ) O pacote java.sql possui as classes Connection, Statement e ResultSet.
d) ( ) O pacote javax.sql possui as classes Connection, Statement e ResultSet.
3 Dentre os sistemas que necessitam muito da funcionalidade de manipulação

de dados em SGBDs, podem ser citados ERPs, os quais precisam do
armazenamento de grandes volumes de dados, vitais para as empresas.
Referente à manipulação de dados em Java, assinale a alternativa CORRETA:
a) ( ) Além do JDBC, sempre existe um outro conector que serve de

intermediário entre o programa Java e o banco de dados.
b) ( ) O JDBC envia instruções SQL de um programa Java para um SGBD, o
qual realiza a execução.
c) ( ) O JDBC possui as classes DataSource e RowSet que são responsáveis
pela execução de comandos SQL.
d) ( ) No JDBC, comandos SQL são utilizados apenas para manipulação de
dados no MySQL.
235
4 O JDBC é uma API (Aplication Program Interface) que permite programas
desenvolvidos pela linguagem de programação Java realizarem a
manipulação de dados em SGBDs. Referente ao JDBC e seus tipos, assinale
a alternativa CORRETA:
a) ( ) O driver JDBC tipo 4 é o mais utilizado, sendo apenas um arquivo .jar

importado, não necessitando de nenhuma configuração na máquina do
cliente.
b) ( ) O driver JDBC tipo 1 é o mais utilizado, pois sua configuração é muito
mais simples, necessitando apenas do arquivo .jar para conectar ao
banco de dados.
c) ( ) O driver JDBC tipo 2 possui classes que funcionam em conjunto com
drivers nativos, porém o acesso ao banco de dados é mais lento que o
JDBC tipo 1.
d) ( ) O driver JDBC tipo 3 é o mais utilizado, consistido por um arquivo
conector com extensão .jar, baixado diretamente pela fabricante do
JDBC.
5 Implemente uma classe entidade chamada Produto, para representar a

tabela PRODUTO, e uma classe chamada ProdutoDAO, para realização da
persistência da classe produto. Crie no banco de dados Uniasselvi, o qual
você já criou para os exemplos deste livro, a tabela PRODUTO, conforme
apresentado o comando SQL a seguir, e, para isso, primeiro conecte no banco
de dados Uniasselvi (comando connect uniasselvi), e depois de conectado,
então informe o comando SQL para criação da tabela (CREATE TABLE).
Após a criação da tabela, então insira alguns registros nela, conforme
exemplos apresentados do comando INSERT. Com a tabela e as duas classes
requisitadas criadas, então crie a classe Autoatividade5Unidade3Topico2
para implementação de uma tela que tenha o componente JTable (tabela
ou grid) para apresentação de todos os produtos cadastrados, sendo
carregados no momento da apresentação da janela (JFrame). Além desta
funcionalidade, ao ser clicada em uma linha da tabela, deve ser apresentada
uma mensagem na tela para o usuário, informando o código, descrição
e tamanho do produto selecionado, o que você deve fazer utilizando a
biblioteca JOptionPane. A tela ilustrada a seguir apresenta como deve ela
deve ficar após a execução.
236
237
238
UNIDADE 3
TÓPICO 3
DESENVOLVIMENTO DE APLICAÇÃO WEB: JSP E SERVLET
1 INTRODUÇÃO
Até este ponto da Unidade 3, você aprendeu a desenvolver aplicações
na linguagem de programação Java utilizando a tecnologia Swing, com intuito
de aplicações desktop, além dos conceitos básicos já estudados anteriormente.
Agora que você já conhece todos estes conceitos, além de programação desktop, é
o momento de você aprender uma das tecnologias do Java para desenvolvimento
de aplicações para web. Neste contexto, este tópico apresenta a tecnologia JSP e
Servlet, as quais permitem o desenvolvimento dinâmico de aplicações web.
Assim que a internet surgiu, no início, sua finalidade era a troca de

conteúdos, através de páginas HTML estáticas, sendo arquivos desenvolvidos
em formato HTML e disponibilizados em servidores para serem acessados por
navegadores. No entanto, com o tempo, notou-se que a internet poderia oferecer
muito mais que isso, permitindo comunicação e interação, e para esse objetivo da
internet, as páginas estáticas não eram suficientes, e seriam necessárias páginas
HTML geradas dinamicamente. Para solucionar este novo objetivo da internet,
na plataforma Java surgiu a primeira tecnologia de geração dinâmica de páginas:
o Servlet. Atualmente, a versão mais recente do Servlet é a 3.0, a qual utilização a
especificação JSR 315.
A partir deste ponto, é essencial que você tenha instalado e configurado

o servidor de aplicação Tomcat, apresentado na Unidade 1 deste livro, pois ele
é base para o funcionamento da tecnologia JSP e Servlet, permitindo que você
implemente os exemplos apresentados neste tópico.
2 JSP (JAVA SERVER PAGES)

O JSP (Java Server Pages) pode ser descrito por ser um tipo de arquivo
que torna possível a geração de conteúdo dinâmico em páginas da internet, sendo
que a sintaxe do JSP é constituída da linguagem Java, utilizada até este momento.
Para Furgeri (2015), além do código Java, implementado dentro de uma página
Web, normalmente é utilizada também a linguagem HTML (HyperText Markup
Language), misturando as duas linguagens.
239
Neste contexto, o JSP utiliza a linguagem de programação Java, a qual

é executada em um servidor de aplicação, e enviada a página HTML, gerada
dinamicamente, para um navegador de internet que realiza a leitura e exibição
para o cliente. Ainda segundo Furgeri (2015), são vários os servidores que
suportam a tecnologia JSP, como o Tomcat, GlassFish, JBoss, entre outros.
Além disso, o JSP é um arquivo na extensão .jsp consistido de uma página

com código-fonte HTML e Java, sendo que o código Java é implementado entre
as tags <% e %>, as quais são denominadas scriptlets (HUNTER; CRAWFORD,
2001).
Segundo Furgeri (2015), a execução de uma página JSP é constituída pelo

acesso do usuário a uma página JSP no navegador de Internet, e, com isso, o
servidor realiza a interpretação da página, gerando uma página em HTML, sendo
este retornado ao navegador do cliente. Para que a interpretação pelo servidor
do JSP em tempo real seja efetuada, existe a compilação do conteúdo JSP em
bytecodes. Um arquivo JSP é dividido em:
• Cabeçalho: possui algumas configurações, como imports de classes e

declarações, como métodos e atributos.
• Corpo: conteúdo a ser formatado em linguagem HTML.
Além do HTML e código Java, uma página JSP pode ter outras tecnologias
associadas, como CSS (Cascating Style Sheets), Javascript., os quais permitem o
desenvolvimento de páginas web dinâmicas e mais amigáveis ao usuário.
Para a criação de um projeto web, conforme apresentado na Figura 52,

imagem esquerda, na guia “Project Explorer” do Eclipse, clique com o botão
direito do mouse, e selecione as opções “New” e então “Other”. Na janela que
abrir, ilustrada na imagem direita da Figura 52, selecione as opções “Web”, e
então “Dynamic Web Project”.
240
TÓPICO 3 | DESENVOLVIMENTO DE APLICAÇÃO WEB: JSP E SERVLET
FIGURA 52 – CRIAÇÃO DE UM NOVO PROJETO WEB
FONTE: O autor
Logo após a seleção do menu “Dynamic web Project”, é aberta uma

janela, na qual é necessário informar o nome do projeto, podendo ser o de sua
preferência, mas se você quiser seguir os exemplos, facilitando seus estudos,
informe “SistemaWeb” como nome do projeto, e então pressione o botão Finish“.
Com isso, o projeto será criado, e para a criar uma nova página JSP, basta
clicar com o botão direito do mouse sobre a pasta “WebContent” do projeto,
conforme apresentado na Figura 53, e então selecionar as opções “New” e então
“JSP File”, e será aberta uma janela para informar o nome do arquivo JSP, e, neste
caso, informe “index.jsp”, para que seja a página inicial do projeto.
241
FIGURA 53 – CRIANDO UMA NOVA PÁGINA JSP EM UM PROJETO
FONTE: O autor
Após criada a JSP, dependendo da configuração de seu servidor de

aplicação, o Eclipse pode sinalizar erro “The superclass javax.servlet.http.
HttpServlet was not found on the Java Build Path”, e para resolver este problema,
basta baixar a biblioteca servlet, isto é, o arquivo servlet.jar, disponível por
exemplo na URL http://www.java2s.com/Code/Jar/s/Downloadservletjar.htm.
Após baixado o arquivo, este deve ser descompactado em um diretório de sua
preferência, e então copie o arquivo servlet.jar para dentro da pasta “lib” do
projeto, que se encontra dentro da pasta “WebContent”, bastando então clicar
com o botão direito do mouse sobre o projeto e selecionar a opção Refresh, para
atualizar os arquivos do projeto.
Com a criação do arquivo “index.jsp”, é possível identificar as divisões da

estrutura existente em um JSP, conforme arquivo apresentado na Figura 54.
FIGURA 54 – ARQUIVO JSP CRIADO NO PROJETO
FONTE: O autor
242
Você pode analisar as linhas 1 e 2 do arquivo ilustrado na Figura 54, nas

quais existe o cabeçalho da página com a especificação da diretiva page, a qual
contém alguns atributos:
• “language”: indica a linguagem utilizada, no caso java;

• “contentType”: especifica o tipo do conteúdo da página, assim como a
codificação utilizada, sendo que o padrão é o charset ISO-8859-1 (latin 1),
porém, se alterado para UTF-16, por exemplo, ao ser carregada a página, serão
apresentados caracteres em formato chinês (FURGERI, 2015). Charset está
vinculado ao conteúdo de resposta gerado pela página;
• “pageEncoding”: este atributo se refere à codificação utilizada na criação da
página.
Ainda referente ao código do JSP apresentado na Figura 54, na linha

4 é definido o início do HTML, sendo a partir desta linha considerados os
elementos de acordo com a especificação HTML. Entre as linhas 5 e 8, é definido
o cabeçalho da página HTML, sendo determinado o tipo de codificação utilizada
no documento HTML pela tag “meta, além da tag “title”, a qual define o título da
página, que é apresentado na barra de título do navegador de internet (browser).
Entre as linhas 9 até 19, é definido o corpo do documento HTML, porém, entre as
linhas 11 e 17, é delimitado o código em JSP que também foi inserido na página
HTML, implementado entre os caracteres <% e %>, sendo código na linhagem de
programação Java, chamado de scriptlet por estar dentro do JSP.
Para executar a página JSP, apresentada na Figura 54, deve ser incluída
a aplicação web ao servidor de aplicação Tomcat, bastando clicar com o botão
direito do mouse sobre o servidor de aplicação Tomcat, conforme ilustrado na
Figura 55, selecionar a opção “Add and Remove...”, e então adicionar a aplicação
web para a lista direita.
FIGURA 55 – ADICIONANDO PROJETO WEB AO SERVIDOR DE APLICAÇÃO
FONTE: O autor
243
Após a execução do projeto no servidor de aplicação, e acessada a página

ilustrada na Figura 55, você pode observar o conteúdo gerado pelas linhas 10 a
17, sendo as duas primeiras linhas conteúdo fixo, e as demais linhas geradas pelo
comando for, isto é, conteúdo dinâmico, na execução do JSP ilustrada na Figura 56.
FIGURA 56 – EXECUÇÃO DO ARQUIVO JSP
FONTE: O autor
Neste sentido, é possível criar uma aplicação web utilizando apenas

arquivos JSP, escrevendo os códigos-fonte Java dentro deles, porém, o exemplo
anterior apresentou apenas a execução de páginas em JSP, sem a utilização de
parâmetros para envio e recebimento de valores.
3 APLICAÇÃO CLIENTE COM JSP

Uma aplicação cliente pode ser especificada por uma página HTML, um
aplicativo de um smartphone, ou também qualquer outro tipo de aplicação cliente
que realize requisições pelo protocolo TCP/IP (FURGERI, 2015).
FIGURA 57 – PÁGINA HTML COM FORMULÁRIO
FONTE: O autor
244
DICAS
A página JSP apresentada na Figura 57 utiliza HTML e a tecnologia responsiva

Bootstrap, a qual serve para tornar o formulário responsivo. Para conhecer mais sobre o
HTML, acesse o artigo https://www.devmedia.com.br/html-basico-codigos-html/16596, e
para conhecer mais o Boostrap, acesse o link https://getbootstrap.com.br/docs/4.1/getting-
started/introduction/.
Para compreender na prática como desenvolver uma aplicação cliente-

servidor utilizando a tecnologia JSP, crie um arquivo JSP no mesmo projeto web
que você já criou no Eclipse, basta clicar com o botão direito do mouse sobre a
pasta “WebContent”, e então selecionar a opção “New”, e então “JSP File”. No
exemplo apresentado na Figura 57, foi criada a pasta “cliente-servidor” dentro
de “WebContent”, para uma melhor organização, onde serão criados os arquivos
deste exemplo, e o ideal é você fazer o mesmo para não ter problemas com os
caminhos (paths) dos arquivos. Após selecionar a opção “JSP File”, então será
aberta uma janela, na qual você deve especificar o nome do arquivo JSP, e, neste
caso, informe “login.jsp” e pressione o botão “Finish”, para que ele seja criado
no projeto. O HTML implementado na Figura 57 se refere a um formulário de
login, no qual o usuário informa seu e-mail e senha, pressionando o botão para
envio destes dados ao servidor, isto é, validados e processados pela página JSP
chamada “valida-login.jsp”, a qual é apresentada na Figura 58. Ainda referente à
Figura 57, analise a Linha 15, na qual o submit do formulário é direcionado para
“valida-login.jsp”, isto é, ao clicar no botão “Submit”, os dados são enviados para
o arquivo “valida-login.jsp”, ilustrado na Figura 58.
A Figura 58 ilustra a página JSP “valida-login.jsp”, a qual recebe os

dados da página de login, após pressionado botão de submit, e então realiza o
processamento, isto é, nas linhas 12 e 13, através do objeto request, atribui as duas
variáveis do tipo String os valores dos respectivos campos da tela. Na Linha 15, é
realizada a validação dos dados de forma fixa, isto é, se o campo e-mail da tela foi
informado o valor “marcio.teste@uniasselvi.com.br” e a senha igual a “123456”, e
caso confirmados estes valores, então o usuário permanece na tela “valida-login.
jsp”, na qual é impresso na tela a mensagem “Você se conectou como marcio.
teste@uniasselvi.com.br”. Caso os dados informados não conferem, então ocorre
o redirecionamento de volta para a página “login.jsp”, conforme você pode
analisar entre as linhas 19 e 20 do código-fonte apresentado na Figura 58.
245
FIGURA 58 – ARQUIVO JSP PARA VALIDAÇÃO DOS DADOS INFORMADOS NO

FORMULÁRIO DE LOGIN
FONTE: O autor
Neste sentido, se informado dados não aceitos na lógica do código-

fonte ilustrado na Figura 63, ocorre o redirecionamento para a página de login
(“login.jsp”), e, com isso, na Linha 19, é enviado para a página “login.jsp” uma
mensagem para alertar ao usuário, através da criação do atributo na requisição,
isto é, o método setAttribute do objeto request. Neste contexto, é necessário
que seja realizada uma pequena alteração na página de login, incluindo uma
regra para validar se na requisição existe o atributo “mensagem”, enviado pela
página “valida-login.jsp”, e caso existir, conforme linhas 29 a 37, então imprimir
na página a função “alert” do javascript, apresentando o valor deste atributo,
conforme linha 33 a 35 apresentadas na Figura 59.
FIGURA 59 – INCLUSÃO NA PÁGINA LOGIN.JSP DE REGRA PARA APRESENTAÇÃO

DE MENSAGEM DO SERVIDOR
FONTE: O autor
Após salvar a alteração do arquivo login.jsp, execute novamente a

aplicação e então informe dados não aceitos pela lógica. Neste caso, será
apresentada a mensagem enviada por atributo do request, conforme Figura 60.
246
FIGURA 60 – MENSAGEM ENVIADA POR ATRIBUTO DO REQUEST APRESENTADA AO USUÁRIO
FONTE: O autor
4 TECNOLOGIA SERVLET
Servlets podem ser entendidos como objetos Java que estão armazenados
em um servidor, e seu nome, em inglês, significa Serv (Servidor) e let (pequeno),
pois é considerado um pequeno servidor, ou seja, servidores Java são também
conhecidos por contêineres de aplicações (FURGERI, 2015). Neste contexto, assim
como para uma página em JSP ser executada, uma Servlet também necessita da
utilização de um servidor de aplicação.
Para Furgeri (2015), Servlet é uma classe na linguagem de programação

Java, a qual estende (extends) funcionalidades de um servidor, e devido a isso,
ao ser criada uma Servlet, conforme você notará, é utilizado o mecanismo de
herança para a classe HttpServlet (por extends de HttpServlet). Uma classe Servlet
pode receber dados (parâmetros) oriundos de um formulário HTML, assim
como realizado exemplo na classe “valida-dados.jsp”, e realizar alguma regra de
negócio com os dados recebidos, ou ainda atualizar em um banco de dados.
Servlet e JSP possuem funcionalidades parecidas, porém existem algumas

diferenças (FURGERI, 2015):
• Servlet é apenas uma classe em Java, e páginas JSP pode ter código Java, HTML
CSS, Javascript.
• Servlets possuem a extensão “.java” e arquivos JSP possuem a extensão “.jsp”.
• Servlets, quando no servidor, são arquivos compilados (.class), enquanto
que uma página JSP quando acessada pela primeira vez, é gerado uma
Servlet correspondente para ela, e a partir do segundo acesso, sua Servlet
correspondente já existirá no servidor e não é recriada.
• Servlets são indicadas para controlar aplicações, e páginas JSP são mais
indicadas para conter conteúdo a ser disponibilizado ao usuário (HTML, CSS,
Javascript).
247
Ao se utilizar a arquitetura MVC, Servlets seriam parte da camada

Controler da aplicação, pois realizam controle de requisições, e páginas JSP
fariam parte da camada View.
Estas são as principais diferenças entre Servlet e JSP, porém é possível

utilizar apenas uma destas tecnologias para desenvolver uma aplicação, pois
Servlet pode retornar código HTML e uma JSP pode ter código Java, embora o
ideal é trabalhar com as duas, uma sendo a camada de controle (Servlet) e a outra
a camada de visualização do usuário (JSP).
5 EXEMPLO DE APLICAÇÃO UTILIZANDO SERVLET E JSP

Para o desenvolvimento de uma aplicação utilizando Servlet, crie um
novo projeto, para tornar mais fácil o desenvolvimento, separando as duas
metodologias de desenvolvimento. Neste sentido, novamente, no Eclipse, na
guia “Project Explorer”, clique com o botão direito do mouse, e selecione a opção
“New”, então a opção “Other”, procure na janela que abrir a opção “Web”, e
então selecione a opção “Dynamic Web Project”. Com isso, será aberta a janela
para configuração do novo projeto e, nela, informe o nome do projeto como
“CadastroClienteWeb” e então pressione o botão “Finish”. Ressaltando que
o nome do projeto pode ser outro, mas para facilitar o acompanhamento dos
exemplos, utilize “CadastroClienteWeb”.
No novo projeto, crie um novo pacote java (package), clicando com o

botão direito do mouse sobre a pasta do projeto “src”, selecione a opção “New”
e então “Package”, informando “br.com.servlet” e pressione o botão “Finish”.
Neste pacote é que serão criados os Servlets da aplicação. Será desenvolvida
uma aplicação parecida com um cadastro de cliente exemplificada em desktop
utilizando o Swing, porém agora será web.
Após criado o novo pacote (package), clique com o botão direito do

mouse sobre ele, e selecione a opção “New” e então a opção “Servlet”, conforme
248
FIGURA 61 – CRIAÇÃO PARA CRIAÇÃO DE UMA NOVA SERVLET
FONTE: O autor
Será aberta uma tela para informar o nome da Servlet, e, neste caso,
informe “LoginServlet” e, novamente, pressione o botão “Finish”. Com este passo,
será criada a classe LoginServlet, a qual é apresentada na Figura 62. Ressaltando
que para um projeto web utlizando Servlet e JSP é necessária a importação da
biblioteca “servlet.jar”, conforme você pode observar na Figura 62, onde na pasta
lib que está dentro da pasta “WEB-INF” do diretório do projeto, existe o arquivo
da biblioteca.
FIGURA 62 – EXEMPLO DE NOVA SERVLET CRIADA EM PROJETO
FONTE: O autor
249
Na Servlet apresentada na Figura 62, você pode analisar na Linha 10 a

anotação @WebServlet, a qual define como a Servlet será chamada pelo cliente, isto
é, se o conteúdo desta anotação for “/loginServlet”, em iniciada por minúsculo, é
assim que ela será invocada por um cliente (html ou aplicativo por exemplo), pois
é case sensitive. Na Linha 11 está implementado o nome da classe, a qual estende
da classe HttpServlet. Entre as linhas 18 e 21 do código-fonte apresentado na
Figura 62, está implementado o método doGet, o qual recebe requisição HTTP do
tipo GET, isto é, para buscar dados, e entre as linhas 23 e 26 do código-fonte está
implementado o método doPost, o qual recebe requisição HTTP do tipo POST,
isto é, uma requisição enviada por um formulário do tipo POST.
Conforme ilustrado na Figura 55, adicione o novo projeto

“CadastroClienteWeb” ao servidor de aplicação, clicando com o botão direito
do mouse sobre o servidor de aplicação Tomcat, selecionando a opção “Add and
Remove” e arrastando o projeto para a lista direita da janela que abrir. Com este
passo é possível a execução da Servlet, isto é, realizar uma requisição do tipo GET
através do navegador de internet, com isso você entenderá melhor como funciona
este tipo de requisição em uma classe Servlet. Inicialize o servidor de aplicação
Tomcat e no navegador de internet de sua preferência, chame a aplicação web,
mas incluindo no final da URL o valor da anotação “@WebServlet”, que no
caso apresentado na Figura 62 é “/LoginServlet”, então a URL deve ser “http://
localhost:8080/CadastroClienteWeb/LoginServlet”, a menos que você alterou a
porta de execução do Tomcat, e neste caso você deve substituir pelo 8080.
FIGURA 63 – EXEMPLO DE REQUISIÇÃO GET REALIZADA PARA A SERVLET LOGINSERVLET
FONTE: O autor
Conforme apresentado na Figura 63, ao ser invocada a Servlet pelo

navegador, é realizada uma requisição do tipo GET, a qual é respondida pelo
método doGet da Servlet, a qual, na Linha 20, responde com uma mensagem,
sendo neste caso o nome da aplicação, mas poderia ser, por exemplo um Json com
dados de alguma consulta.
Agora, crie uma nova página JSP dentro do diretório “WebContent” da

aplicação, a qual deve ser nomeada para “index.jsp”, conforme apresentada na
Figura 64.
250
FIGURA 64 – JSP DE LOGIN AJUSTADA NA LINHA 15: INCLUSÃO DE INVOCAÇÃO DE SERVLET
FONTE: O autor
Com a página “index.jsp” criada, copie o conteúdo do arquivo “login.

jsp” criado na aplicação anterior, para dentro da página “index.jsp”, conforme
ilustrado este código-fonte na Figura 64, porém, deve ser alterado o valor do
atributo “action” do form para “LoginServLet”, conforme apresentado na Linha
15 do código-fonte da Figura 64, para que ao ser pressionado o botão “Submit” da
página, seja realizado uma requisição do tipo POST para a Servlet.
Além disso, na Linha 15 foi incluído o atributo “method” cujo valor

é POST, fazendo com que a requisição seja deste tipo, pois caso não tiver este
atributo, ao ser realizada uma requisição para o servidor, esta será do tipo GET.
Com este passo, a página de acesso ao sistema (login) está funcionando, porém é
preciso criar a lógica na classe LoginServlet para realizar alguma ação de login.
Antes, porém, crie uma nova página chamada “acesso_interno.jsp”, conforme
ilustrada na Figura 65, a qual será apresentada ao usuário quando o acesso for
bem-sucedido.
251
FIGURA 65 – CRIADA PÁGINA ACESSO_INTERNO.JSP PARA APRESENTAR A USUÁRIO

APÓS LOGIN EFETUADO
FONTE: O autor
Nesta aplicação será implementado o padrão DAO para persistência

no banco de dados, e, para isso, importe o arquivo de conexão JDBC “mysql-
connector” com extensão “.jar”, o mesmo que já foi utilizado neste livro, para
dentro da pasta “lib” do projeto, a qual está dentro do diretório “WEB-INF”, e
este dentro de “WebContent”. Crie os pacotes “br.com.conexao”, “br.com.dao”
e “br.com.entidade” na aplicação atual “CadastroClienteWeb”. Copie as classes
ConexaoBD, ClienteDAO e Cliente para os devidos pacotes, conforme Figura
66. Ainda referente à Figura 66, você pode analisar a implementação da classe
ConexaoBD, a qual é a mesma que foi implementada no Tópico 2 – Manipulação
de Dados: utilizando JDBC para Desktop, assim como as demais classes.
FIGURA 66 – APRESENTAÇÃO DOS PACOTES CRIADOS E DA CLASSE CONEXAOBD
FONTE: O autor
252
Note na Figura 66, que além das classes Cliente e ClienteDAO, foram
criadas as classes Usuario e UsuarioDAO, cujos códigos-fonte são apresentados a
seguir, porém, deve ser criada a tabela USUARIO no banco de dados, conforme
apresentados os comandos SQL na Figura 67, isto é, o comando “connect
Uniasselvi” para conectar ao banco de dados “UNIASSELVI”, e o comando
“CREATE TABLE USUARIO (EMAIL VARCHAR(200), SENHA VARCHAR (10)
)”o qual cria a tabela no banco de dados conectado. Execute também o comando
INSERT, o qual também está sendo apresentado na Figura 67, pois será utilizado
este usuário para os testes na aplicação.
FIGURA 67 – EXEMPLO DE CRIAÇÃO DA TABELA USUARIO NO BANCO DE DADOS
FONTE: O autor
Após a criação da tabela USUARIO no banco de dados, é necessária a

criação da classe que serve para representar a tabela, isto é, a classe Usuario,
dentro do pacote br.com.entidade, cuja implementação está na Figura 68.
FIGURA 68 – CLASSE ENTIDADE QUE REFERENCIA A TABELA USUARIO DO BANCO DE
FONTE: O autor
253
Com a classe Usuario implementada, falta a implementação da classe

UsuarioDAO, a qual deve ser criada dentro do pacote br.com.dao, conforme
apresentada na Figura 69, na qual foi implementado um método para consulta
da tabela USUARIO, que será utilizado para validar o usuário informado na tela
de acesso ao sistema.
FIGURA 69 – IMPLEMENTAÇÃO DA CLASSE USUARIODAO
FONTE: O autor
Após as classes Usuario e UsuarioDAO implementadas, além das

demais importações descritas, basta realizar a implementação da regra de login
no método doPost da classe LoginServlet, conforme apresentado entre as linhas
31 e 76 do código-fonte da Figura 70. Conforme você pode analisar, na Linha 33
do código-fonte da Figura 70, conforme já desenvolvido em exemplo anterior
deste livro, é invocado o método getConnection da classe ConexaoBD para
atribuir a conexão ao objeto conn, do tipo Connection.
254
FIGURA 70 – IMPLEMENTAÇÃO DO MÉTODO GOPOST DA CLASSE LOGINSERVLET
FONTE: O autor
255
Na Linha 35 do código-fonte da Figura 70 é realizada a validação se o

objeto conn possui conexão com o banco de dados, e caso tive valor “null”, sem
conexão com banco de dados, então são executadas as linhas 58 a 61, onde é
enviada mensagem para a tela através de um atributo da requisição na Linha 58,
e ocorre o redirecionamento do usuário para a tela de acesso novamente através
das linhas de código 60 e 61. Na Linha 42 da Figura 70 é realizada consulta no
método consultar da classe UsuarioDAO, a qual retorna o objeto instanciado, se
encontrar registro na tabela USUARIO, ou null se não encontrar registro na tabela
com os dados informados. Consequentemente, na Linha 44 do código-fonte, é
validado se o objeto usuario é diferente de null, e caso não seja, então novamente
é o usuário é redirecionado para a tela de acesso com uma mensagem enviada por
atributo do objeto request informando que os dados não estão corretos. Entre as
linhas 45 e 48 ocorre o redirecionamento para a página “acesso_interno.jsp” caso
o usuário informado for encontrado na tabela do banco de dados e, inclusive,
na Linha 45 é enviado o objeto usuário como atributo da sessão, o qual é lido na
Linha 7 da página “acesso_interno.jsp”, conforme você pode analisar o código-
fonte da Figura 71. Referente a enviar um objeto para a sessão, como um atributo,
enquanto durar a sessão do usuário, este objeto pode ser recuperado a qualquer
momento e em qualquer página, como está sendo feito na Linha 7 do código da
Figura 71.
FIGURA 71 – ALTERAÇÕES REALIZADAS NO ARQUIVO ACESSO_INTERNO.JSP
FONTE: O autor
Ainda referente ao código-fonte da Figura 71, analise a Linha 4, na qual

é realizada a importação da classe Usuario, isso para que na Linha 7 a classe seja
reconhecida e possa ser utilizada. Neste sentido, qualquer classe que for utilizada
em uma JSP, é necessária a importação através do atributo “import” da diretiva
page.
256
Analise o código-fonte da página “acesso_interno.jsp”, na Figura 72, o

qual sofreu algumas alterações, como a inclusão do menu entre as linhas 21 e
28 e, consequentemente, para uma melhor aparência, foi incluído o estilo CSS
na Linha 16, o qual você pode analisar o código na Figura 73, gerando um menu
horizontal, no topo da tela com um simples efeito ao passar o cursor do mouse
sobre ele.
Referente ao arquivo “menu.css”, apresentado na Figura 73, o qual contém

a implementação do código-fonte CSS para estilo do menu, foi criada uma pasta
chamada “css”, dentro da pasta “WebContent” do projeto, e dentro da pasta “css”
foi criado o arquivo de estilo. Este estilo é reutilizado em algumas páginas, e é por
esse motivo a importância de se criar o estilo em um arquivo separado (.css), pois
este pode ser reutilizado sem haver repetição de código.
FIGURA 72 – INCLUSÃO DE MENU NA PÁGINA ACESSO_INTERNO.JSP
FONTE: O autor
257
FIGURA 73 – CÓDIGO-FONTE DO ARQUIVO MENU.CSS UTILIZADO PARA APARÊNCIA DO MENU
FONTE: O autor
Dentro do pacote br.com.servlet, foi criada a classe ClienteServlet,

apresentada na 74, a qual serve para controlar a tela de cadastro de cliente,
apresentada na Figura 75.
FIGURA 74 – CÓDIGO-FONTE DA CLASSE CLIENTESERVLET
258
FONTE: O autor
Ainda referente à classe ClienteServlet, apresentada na Figura 74, entre as

linhas 31 e 89 está implementado o método doPost, no qual, entre as linhas 39 e
42, é realizada validação dos campos da tela, se possuem valor, e caso contrário,
é enviado um atributo chamado “mensagem” com a mensagem de erro e, nas
linhas 66 e 67, redirecionado o usuário para a tela de cadastro. Na Linha 54 da
classe ClienteServlet, é validado o atributo codigo do objeto cliente, e caso este
esteja com valor zero, isto é, o campo codigo da tela de cadastro estiver com valor
259
zerado, então é invocado o método inserir da classe ClienteDAO, realizando

a inserção do novo cliente como registro da tabela CLIENTE. Todavia, caso o
atributo codigo do objeto cliente tiver valor, significa que é uma alteração e, neste
caso, é invocado o método alterar, realizando a atualização dos campos nome,
e-mail e sexo.
FIGURA 75 – CÓDIGO-FONTE DA PÁGINA DE CADASTRO DE CLIENTE CADASTRO.JSP
260
FONTE: O autor
A Figura 75 apresenta o código-fonte da página “cadastro.jsp”, no qual

foi implementado o formulário para realizar cadastro de um novo cliente, assim
como alteração de um cliente. Analise as linhas do código-fonte da Figura 75,
utilizada para alteração de um cliente, nas quais é realizada validação se o
objeto cliente do atributo da requisição é diferente de null, para então carregar
os valores dos atributos do objeto cliente nas respectivas variáveis, as quais são
utilizadas para atribuir valor aos respectivos campos da tela. Além disso, nas
linhas 48 e 94 do código-fonte da Figura 75, existe o campo do tipo hidden, cujo
nome é “codigo”, o qual recebe o valor da variável “codigo”, criada na linha 8, e o
mesmo é feito com os demais campos, os quais recebem o seu valor da respectiva
variável criada entre as linhas 8 e 11. A Linha 46 também merece atenção, pois no
atributo “action” do form deve ser incluído o servlet a ser invocado, neste caso o
“ClienteServlet”, que é o nome atribuído a anotação @WebServlet, na linha 18 da
Figura 74.
Uma nova alteração na classe ClienteServlet foi realizada, agora no

método doGet, conforme Figura 76, onde foi incluído o objeto conn recebendo
a conexão com o banco de dados, e na Linha 34 uma validação se existe o
parâmetro “codigo” e, caso não existir, indica que a requisição veio da nova tela,
ilustrada na Figura 77, que solicita a lista de clientes cadastrados para exibição
em uma tabela, consulta realizada na Linha 35 da classe ClienteServlet, e ocorre o
redirecionamento para a classe “listaClientes.jsp”, conforme linhas 37 e 38. Caso
existir o parâmetro “codigo”, então a solciitação veio do botão alterar da tela
“listaClientes.jsp”, sendo nas linhas 41 e 42 realizada consulta deste código de
cliente e então enviado o objeto retornado para um atributo da requisição, o qual
é lido na tela “cadastro.jsp”.
261
FIGURA 76 – ALTERAÇÃO NO MÉTODO DOGET DA CLASSE CLIENTESERVLET
FONTE: O autor
A Figura 77 apresenta o código-fonte da nova página criada, chamada

“listaClientes.jsp”, em cujo código-fonte, na Linha 7, é retornada a lista de objetos
do tipo cliente, isto é, a lista de clientes cadastrados na tabela CLIENTE do banco
de dados. Na Linha 36 é iniciada a implementação de uma tabela HTML, e entre
as linhas 46 e 65 é varrida a lista de clientes através do comando for, e para cada
objeto é criada uma nova linha da tabela.
FIGURA 77 – CÓDIGO-FONTE DA PÁGINA LISTACLIENTES.JSP
262
FONTE: O autor
Um detalhe não mencionado é que foi alterado o menu de todas as

páginas, sendo incluído o link para acesso a nova tela “listaClientes.jsp” através
da invocação do método doGet da classe ClienteServlet, conforme você pode
analisar na Linha 27 do código-fonte da Figura 77.
263
EL: EXPRESSION LANGUAGE
Para remover um pouco do código Java que fica na página JSP, a Sun
desenvolveu uma linguagem chamada Expression Language que é interpretada
pelo servlet container.
Nosso primeiro exemplo com essa linguagem é utilizá-la para mostrar

parâmetros que o cliente envia através de sua requisição.
Por exemplo, se o cliente chama a página testaparam.jsp?idade=24, o

programa deve mostrar a mensagem que o cliente tem 24 anos.
Como fazer isso? Simples, existe uma variável chamada param que, na
expression language, é responsável pelos parâmetros enviados pelo cliente. Para
ler o parâmetro chamado idade basta usar ${param.idade}. Para ler o parâmetro
chamado dia devemos usar ${param.dia}.
Exercícios: parâmetros com a Expression Language
Crie uma página chamada WebContent/digita-idade.jsp com o conteúdo:
<html>
<body>
Digite sua idade e pressione o botão:<br />
<form action="mostra-idade.jsp">
Idade: <input type="text" name="idade"/> <input type="submit"/>
</form>
</body>
</html>
Crie um arquivo chamado WebContent/mostra-idade.jsp e coloque

o código de expression language que mostra a idade que foi enviada como
parâmetro para essa página:
<html>
<body>
Testando seus parâmetros:<br />
A idade é ${param.idade}.
</body>
</html>
Teste o sistema acessando a página http://localhost:8080/fj21-agenda/

digita-idade.jsp.
264
FONTE: <https://www.caelum.com.br/apostila-java-web/javaserver-pages/#exerccios-
parmetros-com-a-expression-language>. Acesso em: 19 fev. 2020.
265
RESUMO DO TÓPICO 3
• No início, a internet era constituída por troca de conteúdos estáticos, isto é,

páginas HTML estáticas, os quais eram disponibilizados em servidores para
serem acessados por navegadores.
• Com a necessidade de maior interação e comunicação, apareceram novos

recursos para a internet, que através destas necessidades, surgiu, na plataforma
java, a tecnologia Servlet, permitindo geração de conteúdos dinâmicos, isto é,
geração de páginas HTML dinâmicas.
• Para a execução de aplicações com a tecnologia Servlet, é necessário ter um

servidor de aplicação web instalado, para disponibilização do conteúdo.
• O JSP (Java Server Pages) pode entendido por ser um arquivo que possui
conteúdo HTML, scriptlet (código na linguagem de programação Java), além
de CSS e Javascript, permitindo a desenvolvimento de páginas web dinâmicas.
• O JSP é executado no servidor de aplicação, sendo gerado o HTML, e este é

enviado para o cliente (navegador de internet ou browser).
• Existem vários servidores de aplicação que suportam o JSP, como Tomcat,

GlassFish e Jboss.
• No JSP, o código Java é implementado entre as tags <% e %>.
• A compilação do conteúdo JSP é realizada em bytecodes.
• Servlet é um objeto (classe instanciada) em Java, armazenada em um servidor,

considerada um pequeno servidor.
• Servlets precisam ser executados em um servidor de aplicação.
• Uma classe Servlet pode receber dados de um formulário HTML, invocar

métodos de outras classes para realizar regras de negócio com os dados
recebidos, ou ainda atualizar dados um banco de dados.
266
• Servlet e JSP possuem funcionalidades parecidas, mas existem algumas
diferenças, como: a extensão dos arquivos; Servlet é uma classe Java e possui
somente código Java, enquanto JSP pode ter código Java, HTML, Javascript e
CSS; Servlets são indicadas para controlar aplicações, e JSPs são mais indicadas
para ter conteúdo HTML, e, neste caso, deve ser evitado utilização de código-
fonte Java dentro do JSP, tornando o código mais legível, e todas as regras de
negócios devem ser feitas em Servlets.
• Uma Servlet pode ter um método doGet (método GET do HTTP), o qual recebe
requisições para envio de dados e um método doPost (método POST do HTTP),
o qual recebe dados de formulários.
CHAMADA

267
AUTOATIVIDADE
1 Desenvolvimento web pode ser descrito pelo desenvolvimento de

aplicações web, isto é, sistemas que podem ser acessados através da internet
ou intranet. Neste sentido, o desenvolvimento web pode ser constituído
apenas por simples páginas estáticas ou ainda páginas dinâmicas. Referente
ao JSP (Java Server Pages), assinale a alternativa CORRETA:
a) ( ) JSP é uma linguagem de programação que permite a geração de páginas

web.
b) ( ) JSP é um tipo de arquivo que pode gerar apenas páginas web estáticas.
c) ( ) JSP é um tipo de arquivo que pode gerar apenas páginas web dinâmicas.
d) ( ) JSP é um tipo de arquivo que pode gerar páginas web estáticas ou
dinâmicas.
2 Um sistema web permite que, por exemplo, um usuário possa realizar suas
operações dentro do sistema, em uma filial da empresa em que ele trabalha,
por exemplo. Além disso, outro tipo de aplicação web muito utilizado
atualmente são sites de e-commerce, os quais permitem a venda direta a
consumidores finais pela internet, tornando o negócio mais abrangente.
Referente à tecnologia JSP (Java Server Pages), assinale a alternativa
CORRETA:
a) ( ) Dentro de um arquivo do tipo JSP, é possível criar código-fonte Java,

HTML, Javascript e CSS.
b) ( ) Dentro de um arquivo do tipo JSP, é possível criar apenas código-fonte
HTML, Javascript e CSS, pois serve para a criação de página web.
c) ( ) Dentro de um arquivo do tipo JSP, é possível criar apenas código-fonte
Java e HTML.
d) ( ) Dentro de um arquivo do tipo JSP, o código-fonte Java deve ficar entre
os caracteres “!=” e “=!”.
3 Dentre as teconologias da plataforma Java para desenvolvimento de

aplicações web, podem ser citados o JSP e Servlets, sendo que ambos
permitem a geração de páginas web dinâmicas, havendo algumas diferenças
entre as duas. Referente ao JSP e ao Servlet, assinale a alternativa CORRETA:
a) ( ) Servlets, quando no servidor, são arquivos na extensão .java, enquanto

que uma página JSP, sempre quando for acessada, é gerada uma nova
Servlet correspondente.
b) ( ) Servlet é uma classe Java que permite o controle de aplicações web,
enquanto que JSP é um tipo de arquivo onde a página pode ser criada
utilizando código Java, HTML, CSS e Javascript.
c) ( ) Uma classe Servlet é o local mais apropriado para conter código-fonte
HTML, Javascript e CSS, pois esta é solicitada pelo cliente (navegador
de internet), o qual receberá a página web dinâmica.
268
d) ( ) Um arquivo JSP é o local mais apropriado para conter código-fonte
HTML, Javascript e CSS, pois esta é solicitada pelo cliente (navegador
de internet), o qual receberá a página web dinâmica, e é neste arquivo
que devem ser implementadas as regras de negócios de uma aplicação.
4 Um navegador de internet pode realizar requisições HTTP do tipo GET e

POST para um sistema web a fim de realizar suas operações. Referente às
tecnologias JSP e Servlet, assinale a alternativa CORRETA:
a) ( ) JSP (Java Server Pages) e Servlets são a mesma tecnologia, não havendo
diferenças entre elas, pois ambas permitem a geração de páginas web
dinâmicas, utilizando código Java, HTML, Javascript e CSS.
b) ( ) Servlet pode ser descrita por ser uma classe Java que permite o controle
de aplicações web, recebendo requisições HTTP do tipo GET e POST.
c) ( ) Servlet pode ser entendida por ser um objeto Java que permite o controle
de aplicações web, recebendo apenas requisições HTTP do tipo GET.
d) ( ) Servlet pode ser entendida por ser um objeto Java que permite o controle
de aplicações web, recebendo apenas requisições HTTP do tipo POST.
5 A tecnologia Servlet, assim como a JSP, permite a geração de aplicações

web com páginas dinâmicas, e inclusive, o ideal é utilizar ambas na mesma
aplicação, sendo a Servlet para controle das requisições da aplicação, e JSP
para o desenvolvimento das páginas dinâmicas. Referente à classe Servlet
apresentada, assinale a alternativa CORRETA:
a) ( ) Sendo o nome da aplicação “CadastroClienteWeb”, a porta 8080 sendo

utilizada em um ambiente local de desenvolvimento, para invocar o
método doGet da classe apresentada, deve ser utilizada a URL “http://
localhost:8080/CadastroClienteWeb/ExemploServlet”.
b) ( ) Na classe apresentada não existe característica de herança de classe.
c) ( ) A anotação @WebServlet define como a Servlet será chamada pelo
cliente sendo case sentitive, isto é, diferencia maiúsculas de minúsculas.
d) ( ) Se invocado o método doPost da classe Servlet apresentada, ocorrerá
um erro na execução, pois não existe implementação para este.
269
REFERÊNCIAS
ALLAN, A. Aprendendo Programação IOS. São Paulo: Novatec, 2013.
ANJOU, J. D’. et al. The Java Developer’s Guide to Eclipse. Boston, MA:
Pearson Education, 2005.
BONDREAU, T. et al. NetBeans: The Definitive Guide. Sebastopo, CA: O'Relly

& Associates, 2003.
BRITO, M. Entendendo o que é um servidor de aplicação e um

servlet container na programação Java para Web. 2016. Disponível
em: https://medium.com/@michellibrito/entendendo-o-que-%C3%A9-
um-servidor-de-aplica%C3%A7%C3%A3o-e-um-servlet-container-na-
programa%C3%A7%C3%A3o-java-para-web-d2146a4958ea. Acesso em: 17 jul.
2019.
BRITTAIN, J.; DARWIN, I. F. Tomcat: The Definitive Guide. 2. ed. Sebastopol,

CA: O’Reilly Media, 2008.
BROOKSHEAR, J. G. Ciência da computação: uma visão abrangente. Porto

Alegre: Bookman, 2013.
BUELL, D. A. Data Strutuctures Using Java. Burlington: Jones & Barlett

Learning, 2013.
BURD, B. Começando a programar em Java para leigos. Rio de Janeiro: Alta

Books, 2014.
BURNETTE, E. Eclipse IDE Pocket Guide. Sebastopol, CA: O’Reilly Media,

2005.
CADENHEAD, R. Sams Teach yourself Java in 24 Hours. 7. ed. Indianapolis,

USA: Pearson Education, 2014.
CADENHEAD, R.; LEMAY, L. Aprenda em 21 Dias Java 2. Rio de Janeiro:

Elsevier, 2005.
CAMBRIDGE.ORG. Pattern: meaning in the Cambridge English Dictionary.

2018. Disponível em: https://dictionary.cambridge.org/dictionary/english/
pattern. Acesso em: 17 dez. 2018.
270
CAMPOS, A. L. N.; CAMPOS, A. F. Java Start. Rio de Janeiro: Digitaliza, 2018.
eBook. Disponível em: https://www.amazon.com.br/Java-Start-Andr%C3%A9-
Campos-ebook/dp/B07D5LDT85. Acesso em: 9 nov. 2019.
CARVALHO, V. MySQL: comece com o principal banco de dados open source

do mercado. São Paulo: Casa do Código, 2015. eBook. Disponível em: https://
www.amazon.com.br/MySQL-Comece-principal-source-mercado-ebook/dp/
B019P83LYY. Acesso em: 9 nov. 2019.
CIRILO, C. E. Computação ubíqua: definição, princípios e tecnologias. 2006.

Disponível em: https://docplayer.com.br/2317000-Computacao-ubiqua-
definicao-principios-e-tecnologias.html. Acesso em: 27 dez. 2018.
COOPER, K. D. Construindo compiladores. 2. ed. Rio de Janeiro: Elsevier, 2014.
DEITEL, H. M.; DEITEL, P. J. Java como programar. 4. ed. Porto Alegre:

Artmed, 2003.
DIMES, T. Programação Java. [s.L.]: Babelcube Inc., 2015.
FAIN, Y. Java Programming 24-Hour Trainer. Indianapolis: Wiley Publishing,

2011.
FINEGAN, E.; LIGUORI, R. OCA Java SE 8: guia de estudos para o exame 1Z0-
808. Porto Alegre: Bookman, 2018.
FRIESEN, J. Java I/O, NIO and NIO 2.0. New York: Apress, 2015.
FRIESEN, J. Learn java for Android Development. New York: Apress, 2010.
FURGERI, S. Java 8 – Ensino didático: desenvolvimento e implementação de

aplicações. São Paulo: Érica, 2015.
HUNTER, J.; CRAWFORD, W. Java Servlet Programming, Second Edition.

Sebastopol: O’Relly, 2001.
JANA, D. Java and Object-Oriented Programming Paradigm. New Delhi:

Prentice-Hall of India, 2005.
JOBSTRAIBIZER, F. Criação de Banco de Dados com MySQL. São Paulo:

Digerati Books, 2010.
LUCKOW, D. H.; MELO, A. A. Programação Java para a Web. São Paulo:

Noovatec Editora, 2010.
271
MATTOS, É. C. T de. Programação de Software em Java. São Paulo: Digetati
Books, 2007.
MILANI, A. MySQL: guia do programador. São Paulo: Novatec, 2006.
MYATT, A. Pro NetBeans IDE 5.5 Enterprise Edition. New York: Apress, 2007.
NARTOVICH, A. et al. IBM Technology FOR Java Virtual Machine in IBM i5/
OS. New York: International Business Machines Corporation, 2008.
NETO, O. M. Entendendo e dominando o Java. São Paulo: Digerati Books, 2009.
RICARTE, I. Introdução à compilação. Rio de Janeiro: Elsevier, 2008.
SANTOS, R. Introdução à programação orientada a objetos usando Java. 2. ed.

Rio de Janeiro: Elsevier, 2013.
SCHILDT, H. Java para iniciantes. Porto Alegre: Bookman, 2015.
SERSON, R. R. Programação orientada a objetos com Java. Rio de Janeiro:

Brasport, 2007.
SIAHAAN, V.; SIANIPAR, R. H. JAVA GUI WITH MYSQL: A Practical

Approach to Build Database Project for Students and Programmers. Indonesia:
SPARTA Publishing, 2019.
SOMERA, G. Treinamento profissional em Java. São Paulo: Digerati Books,

2006.
SONI, R. K. Learning Spring Application Development. Birmingham: Packt

Publishing Ltd, 2015.
272

Programação de Computadores

Enviado por

Dados do documento

Direitos autorais

Formatos disponíveis

Compartilhar este documento

Compartilhar ou incorporar documento

Opções de compartilhamento

Você considera este documento útil?

Este conteúdo é inapropriado?

Direitos autorais:

Formatos disponíveis

Programação de Computadores

Enviado por

Direitos autorais:

Formatos disponíveis

Programação de

Revisão, Diagramação e Produção:

Ficha catalográfica elaborada na fonte pela Biblioteca Dante Alighieri

Programação de computadores. / Marcio Poffo. – Indaial:

272 p.; il.

1. Programação (Computadores). - Brasil. 2. Linguagem de

Com isso, a linguagem de programação Java permite o

Para isso, o desenvolvimento de software utilizando a tecnologia

Contudo, não é possível apresentarmos todos os recursos da

Nesse sentido, com o objetivo de apresentarmos algumas das

Outra grande vantagem ao desenvolver softwares utilizando a

Para compreender todos os conteúdos deste livro, você precisará ter

Lembre-se de que neste livro você aprenderá desde o básico da

Bons estudos e boa programação!

Prof. Me. Marcio Poffo

Na Educação a Distância, o livro impresso, entregue a todos os acadêmicos desde 2005, é

Assim, a UNIASSELVI, preocupando-se com o impacto de nossas ações sobre o ambiente,

Aproveito o momento para convidá-lo para um bate-papo sobre o Exame Nacional de

Olá, acadêmico! Iniciamos agora mais uma disciplina e com ela

Com o objetivo de enriquecer seu conhecimento, construímos, além do livro

Conte conosco, estaremos juntos nesta caminhada!

TÓPICO 1 – APRESENTAÇÃO DA LINGUAGEM DE PROGRAMAÇÃO JAVA.......................3

TÓPICO 2 – INSTALAÇÃO E CONFIGURAÇÃO DO AMBIENTE DE

TÓPICO 3 – CASTING, CONTROLE DE FLUXO E LAÇOS DE REPETIÇÃO...........................69

UNIDADE 2 – CONCEITOS DE ORIENTAÇÃO A OBJETOS, PACOTES JAVA.LANG

TÓPICO 1 – CONCEITOS DE ORIENTAÇÃO A OBJETOS...........................................................93

TÓPICO 2 – EXCEÇÕES E CONTROLE DE ERROS......................................................................113

TÓPICO 3 – PACOTES JAVA.LANG, JAVA.IO E VETORES........................................................137

UNIDADE 3 – TECNOLOGIAS DE DESENVOLVIMENTO JAVA.............................................169

TÓPICO 1 – INTERFACES GRÁFICAS.............................................................................................171

TÓPICO 2 – MANIPULAÇÃO DE DADOS: UTILIZANDO JDBC PARA DESKTOP............205

LINGUAGEM DE PROGRAMAÇÃO JAVA

• conhecer a linguagem de programação Java;

• compreender os componentes básicos da linguagem;

• aprender a configurar o ambiente de desenvolvimento do Java, incluindo

• aprender a desenvolver pequenos algoritmos nesta linguagem.

TÓPICO 1 – APRESENTAÇÃO DA LINGUAGEM DE PROGRAMAÇÃO

TÓPICO 2 – INSTALAÇÃO E CONFIGURAÇÃO DO AMBIENTE DE

TÓPICO 3 – CASTING, CONTROLE DE FLUXO E LAÇOS DE

Preparado para ampliar seus conhecimentos? Respire e vamos

APRESENTAÇÃO DA LINGUAGEM DE PROGRAMAÇÃO JAVA

Na época do desenvolvimento de software com linguagens antigas havia

Neste sentido, a linguagem de programação Java resolve todos esses

Com o tempo, o Java passou a ser a tecnologia utilizada para

Com o surgimento da internet em 1990, a qual começou a aparecer aos

3 MÁQUINA VIRTUAL DO JAVA (JAVA VIRTUAL MACHINE –

FIGURA 1 – COMPILAÇÃO DE CÓDIGO-FONTE

Código-Fonte em Pascal Código Binário Gerado

O compilador pode ser entendido como um programa que realiza

Neste sentido, com o código-fonte compilado é gerado um código de

Então, neste caso, muitas das linguagens de programação funcionam para

Os arquivos binários do Java são independentes de plataforma, o que

Segundo Somera (2006, p. 7), “bytecodes são um conjunto de instruções

Ainda de acordo com Somera (2006), o ambiente de desenvolvimento do

• Compilador: não gera código-fonte de máquina, mas sim um bytecode.

FIGURA 2 – PROCESSO DE COMPILAÇÃO

FONTE: Somera (2006, p. 8)

Além disso, quando o código-fonte desenvolvido na linguagem de

Outro exemplo da importância da JVM, a fim de evitar desenvolver um

Neste sentido, o Java utiliza o conceito de máquina virtual, conforme já

FIGURA 3 – PROCESSO DE EXECUÇÃO DE APLICAÇÃO JAVA

FONTE: Nartovich et al. (2008, p. 4)

Conforme a Figura 3, não é possível executar os bytecodes gerados,

Em síntese, com a utilização da JVM, obtém-se a independência de