Programação de Computadores

Prévia do material em texto

Indaial – 2020
Programação de 
ComPutadores
Prof. Marcio Poffo
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.
Impresso por:
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
III
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 
IV
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
V
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!
NOTA
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!
LEMBRETE
VI
VII
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
sumário
VIII
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, LAÇOS DE REPETIÇÃO E 
CONCEITOS DA ORIENTAÇÃO A OBJETOS .........................................................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 ...................................................................................................................814.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
IX
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 ........................................................................................2084 PADRÃO DAO ....................................................................................................................................215
5 APLICAÇÃO DESKTOP (SWING) COM BANCO DE DADOS ..............................................223
RESUMO DO TÓPICO 2......................................................................................................................233
AUTOATIVIDADE ...............................................................................................................................235
X
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
1
UNIDADE 1
LINGUAGEM DE PROGRAMAÇÃO JAVA
OBJETIVOS DE APRENDIZAGEM
PLANO DE ESTUDOS
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.
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, LAÇOS DE REPETIÇÃO 
E CONCEITOS DA ORIENTAÇÃO A OBJETOS
Preparado para ampliar seus conhecimentos? Respire e vamos 
em frente! Procure um ambiente que facilite a concentração, assim absorverá 
melhor as informações.
CHAMADA
2
3
TÓPICO 1
UNIDADE 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.
UNIDADE 1 | LINGUAGEM DE PROGRAMAÇÃO JAVA
4
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
FONTE: O autor
Código-Fonte em Pascal Código Binário Gerado
TÓPICO 1 | APRESENTAÇÃO DA LINGUAGEM DE PROGRAMAÇÃO JAVA
5
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 possuioutra 
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)
UNIDADE 1 | LINGUAGEM DE PROGRAMAÇÃO JAVA
6
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)
TÓPICO 1 | APRESENTAÇÃO DA LINGUAGEM DE PROGRAMAÇÃO JAVA
7
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).
Acesse o vídeo https://www.youtube.com/watch?v=sR_OXvuJIyA para entender 
melhor este conceito.
DICAS
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.
UNIDADE 1 | LINGUAGEM DE PROGRAMAÇÃO JAVA
8
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.
TÓPICO 1 | APRESENTAÇÃO DA LINGUAGEM DE PROGRAMAÇÃO JAVA
9
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.
NOTA
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.
UNIDADE 1 | LINGUAGEM DE PROGRAMAÇÃO JAVA
10
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 notasem 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
TÓPICO 1 | APRESENTAÇÃO DA LINGUAGEM DE PROGRAMAÇÃO JAVA
11
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.
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.
IMPORTANT
E
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
UNIDADE 1 | LINGUAGEM DE PROGRAMAÇÃO JAVA
12
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
TÓPICO 1 | APRESENTAÇÃO DA LINGUAGEM DE PROGRAMAÇÃO JAVA
13
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
UNIDADE 1 | LINGUAGEM DE PROGRAMAÇÃO JAVA
14
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.
TÓPICO 1 | APRESENTAÇÃO DA LINGUAGEM DE PROGRAMAÇÃO JAVA
15
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 
UNIDADE 1 | LINGUAGEM DE PROGRAMAÇÃO JAVA
16
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
FONTE: O autor
Tipode
Dado
Memória 
Consumida Valor Mínimo Valor Máximo
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
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.
TÓPICO 1 | APRESENTAÇÃO DA LINGUAGEM DE PROGRAMAÇÃO JAVA
17
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.
UNIDADE 1 | LINGUAGEM DE PROGRAMAÇÃO JAVA
18
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.
TÓPICO 1 | APRESENTAÇÃO DA LINGUAGEM DE PROGRAMAÇÃO JAVA
19
FIGURA 17 – COMPILAÇÃO E EXECUÇÃO DE CLASSE TESTE UTILIZANDO JOPTIONPANE
FONTE: O autor
Para saber mais sobre o JoptionPane, acesse o link https://www.tutorialspoint.
com/swing/swing_joptionpane.htm.
DICAS
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
UNIDADE 1 | LINGUAGEM DE PROGRAMAÇÃO JAVA
20
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.
TÓPICO 1 | APRESENTAÇÃO DA LINGUAGEM DE PROGRAMAÇÃO JAVA
21
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.
UNIDADE1 | LINGUAGEM DE PROGRAMAÇÃO JAVA
22
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.
Caso ainda não tenha instalado o editor Notepad++, você pode baixá-lo em 
https://notepad-plus-plus.org/downloads/.
ATENCAO
TÓPICO 1 | APRESENTAÇÃO DA LINGUAGEM DE PROGRAMAÇÃO JAVA
23
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).
UNIDADE 1 | LINGUAGEM DE PROGRAMAÇÃO JAVA
24
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
FONTE: O autor
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) %
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
TÓPICO 1 | APRESENTAÇÃO DA LINGUAGEM DE PROGRAMAÇÃO JAVA
25
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
FONTE: O autor
Descrição Operador
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) !=
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 ||.
UNIDADE 1 | LINGUAGEM DE PROGRAMAÇÃO JAVA
26
QUADRO 3 – OPERADORES LÓGICOS
FONTE: O autor
Descrição Operador
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 ||
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
27
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 deincremento 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.
RESUMO DO TÓPICO 1
28
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:
AUTOATIVIDADE
29
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.
30
31
TÓPICO 2
INSTALAÇÃO E CONFIGURAÇÃO DO AMBIENTE DE 
DESENVOLVIMENTO
UNIDADE 1
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.
UNIDADE 1 | LINGUAGEM DE PROGRAMAÇÃO JAVA
32
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.
NOTA
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 funcionamentodas aplicações, motivando seu 
uso em projetos de pequeno, médio e grande porte, auxiliando a produtividade.
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.
IMPORTANT
E
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 Envoronment) 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 
TÓPICO 2 | INSTALAÇÃO E CONFIGURAÇÃO DO AMBIENTE DE DESENVOLVIMENTO
33
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.
UNIDADE 1 | LINGUAGEM DE PROGRAMAÇÃO JAVA
34
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:
TÓPICO 2 | INSTALAÇÃO E CONFIGURAÇÃO DO AMBIENTE DE DESENVOLVIMENTO
35
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
UNIDADE 1 | LINGUAGEM DE PROGRAMAÇÃO JAVA
36
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.
TÓPICO 2 | INSTALAÇÃO E CONFIGURAÇÃO DO AMBIENTE DE DESENVOLVIMENTO
37
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).
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.
DICAS
3.1 CONHECENDO O MYSQL
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.
ESTUDOS FU
TUROS
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.
UNIDADE 1 | LINGUAGEM DE PROGRAMAÇÃO JAVA
38
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