Apostila java

ESCOLA TÉCNICA ESTADUAL
MONTEIRO LOBATO
Programação Java
Curso Técnico em Informática

______________________________________________________________________________________________
Curso Técnico em Informática 2 Programação Java
1 Introdução ...................................................................................................................................8
1.1 Padronização .................................................................................................................9
1.2 Características...............................................................................................................9
1.3 Licença.........................................................................................................................10
1.4 Máquina Virtual............................................................................................................10
1.5 Garbage Collection...................................................................................................... 11
1.6 Estrutura de um código em Java ............................................................................... 11
1.7 Instalação e configuração do java .............................................................................13
1.7.1 Requisitos do Sistema Java 8..........................................................................13
1.7.2 Download e Instalação.....................................................................................13
1.8 Ferramentas.................................................................................................................24
1.8.1 Eclipse .............................................................................................................24
1.8.2 NetBeans .........................................................................................................25
1.8.3 Jcreator............................................................................................................25
1.8.4 BlueJ................................................................................................................26
1.9 IDE Netbeans ...............................................................................................................26
2 Linguagem Java............................................................................................................28
2.1 Sintaxe Java ....................................................................................................................29
2.1.1 Delimitadores em Java...............................................................................................29
2.1.2 Identificadores e palavras reservadas........................................................................30
2.1.3 Declaração de Variáveis.............................................................................................31
2.1.4 Tipos primitivos...........................................................................................................32
2.1.4.1 Tipos lógicos: boolean ..................................................................................32
2.1.4.2 Tipos textuais: char e String..........................................................................32
2.1.4.3 Tipos numéricos inteiros: byte, short, int e long ............................................33
2.1.4.4 Tipos numéricos de ponto flutuante: float e double.......................................33
2.2 Convenções de codificação .......................................................................................33
3 Expressões....................................................................................................................34
3.1 Operadores ..................................................................................................................34
3.1.1 Operadores Delimitadores............................................................................ 34
Sumário

______________________________________________________________________________________________
3.1.2 Operadores Aritméticos ...................................................................................34
3.1.3 Operadores de Atribuição ................................................................................35
3.1.4 Operadores Unários.........................................................................................35
3.1.5 Operadores de Incremento e Decremento.......................................................35
3.1.6 Operadores Relacionais ..................................................................................35
3.1.7 Operadores Lógicos.........................................................................................35
3.1.8 Operador de concatenação .............................................................................36
3.1.9 Operadores de deslocamento..........................................................................36
3.2 Casting .........................................................................................................................37
3.3 Recebendo dados do usuário ....................................................................................38
4 Controle de Fluxo......................................................................................................................39
4.1 Execução Condicional....................................................................................................40
4.1.1 Comando if ......................................................................................................40
4.1.2 Comando if-else...............................................................................................41
4.1.3 Condicional ternário.........................................................................................42
4.1.4 Comando If-else Aninhados.............................................................................42
4.1.5 Comando switch .............................................................................................44
4.2 Laços de Repetição ........................................................................................................48
4.2.1 Comando While ...............................................................................................48
4.2.2 Comando do-while...........................................................................................49
4.2.3 Comando for ....................................................................................................50
4.2.4 Comandos de desvio .......................................................................................51
4.3 Recursividade..............................................................................................................54
5 Estrutura de dados.................................................................................................................56
5.1 Vetores .........................................................................................................................56
5.1.1 Inicialização de vetores....................................................................................61
5.1.2 Estrutura for aprimorada ..................................................................................62
5.2 Matrizes........................................................................................................................64
6 Programação Orientada a Objetos....................................................................................... 68
6.1 Introdução....................................................................................................................68
6.2 Ideias básicas da POO................................................................................................69
6.3 Classes.........................................................................................................................69
6.4 Objetos.........................................................................................................................70
6.5 Mensagens...................................................................................................................71
6.6 Métodos........................................................................................................................71

______________________________________________________________________________________________
6.7 Abstração.....................................................................................................................73
6.8 Encapsulamento..........................................................................................................73
6.9 Herança ........................................................................................................................76
6.10 Classes abstratas......................................................................................................79
6.11 Polimorfismo..............................................................................................................82
7 Documentação – JavaDoc.....................................................................................................86
8 Interface Gráfica.....................................................................................................................91
8.1 Componentes Swing .....................................................................................................91
8.1.1 Hierarquia das Classes dos Componentes......................................................92
8.1.2 Portabilidade....................................................................................................93
8.1.3 Look And Feel..................................................................................................93
8.1.4 Bases de Estruturação das Interfaces Gráficas...............................................93
8.1.4.1 Conteiners..........................................................................................94
8.1.4.2 Swing - Mensagens............................................................................94
8.1.4.3 Componentes: JFrame, JPanel e JButton..........................................95
8.1.4.4 JFrame ...............................................................................................95
8.1.4.5 JDesktopPane e JInternalFrame ........................................................97
8.1.4.6 JDialog ...............................................................................................97
8.1.4.7 Componentes Atômicos......................................................................98
8.1.4.7.1 JLabel ...................................................................................98
8.1.4.7.2 Botões...................................................................................98
8.1.4.7.3 JButton..................................................................................99
8.1.4.7.4 JCheckBox............................................................................99
8.1.4.7.5 JRadioButton ......................................................................100
8.1.4.7.6 JTextField............................................................................100
8.1.4.7.7 JPasswordField...................................................................101
8.1.4.7.8 JTextArea............................................................................101
8.1.4.7.9 JScrollPane.........................................................................102
8.1.4.7.10 JSlider...............................................................................102
8.1.4.7.11 JComboBox.......................................................................103
8.1.4.7.12 JList ..................................................................................103
8.1.4.7.13 JPopupMenus...................................................................104
8.1.4.7.14 Menus...............................................................................104
8.2 Eventos ......................................................................................................................105
8.2.1 Tratamento de Eventos..................................................................................105

______________________________________________________________________________________________
8.2.1.1 A Origem do Evento .........................................................................105
8.2.1.2 O Objeto Evento...............................................................................105
8.2.1.3 Ouvinte do Evento............................................................................106
8.2.2 Tratadores de Eventos ou Ouvintes (Listeners).............................................106
8.2.2.1 ActionListener...................................................................................106
8.2.2.2 FocusListener...................................................................................106
8.2.2.3 ItemListener......................................................................................107
8.2.2.4 KeyListener ......................................................................................107
8.2.2.5 MouseListener..................................................................................107
8.2.2.6 MouseMotionListener .......................................................................108
8.2.2.7 WindowListener................................................................................108
8.3 Classes Adaptadoras ................................................................................................108
8.4 JavaFX........................................................................................................................109
8.4.1 Introdução......................................................................................................109
8.4.2 Aplicação de internet rica (RICH INTERNET APPLICATION – RIA)..............109
8.4.3 Sobre JAVAFX ............................................................................................... 110
8.4.4 Características............................................................................................... 111
8.4.5 À linguagem JavaFX script ............................................................................ 113
8.4.5.1 Tipos de variáveis............................................................................. 115
8.4.5.2 Características especiais.................................................................. 115
8.4.5.3 Ambiente web................................................................................... 117
8.4.5.4 A aplicação JXplayer ........................................................................ 118
8.4.5.4.1 Características da aplicação JXPlayer................................ 118
8.4.5.4.2 Ferramentas de apoio ao desenvolvimento ........................ 118
8.4.6 Interface e efeitos gráficos............................................................................. 119
8.4.7 Suporte a áudio e vídeo................................................................................. 119
9 Expressões Regulares – Java..........................................................................................120
10 Tratando exceções em Java...........................................................................................124
10.1 Entendendo as exceções........................................................................................124
11 Conexão com banco de dados ............................................................................................131
12 Java Persistence API - JPA ..................................................................................................134
12.1 Entity ........................................................................................................................135
12.1.1 Anotações para Entity..................................................................................136
12.1.1.1 javax.persistence.Entity..................................................................136
12.1.1.2 javax.persistence.Table ..................................................................136

______________________________________________________________________________________________
12.1.1.3 javax.persistence.Id........................................................................137
12.1.1.4 javax.persistence.Column ..............................................................137
12.1.1.5 javax.persistence.SequenceGenerator ..........................................138
12.1.1.6 javax.persistence.GeneratedValue.................................................138
12.1.1.7 javax.persistence.Temporal............................................................139
12.1.1.8 javax.persistence.Transient............................................................139
12.2 EntityManager..........................................................................................................141
12.3 Unidade de Persistência .........................................................................................141
12.4 Criando uma unidade de persistência no NetBeans ............................................142
12.5 EntityManager gerenciado pela Aplicação............................................................147
12.6 EntityManager gerenciado pelo Container............................................................148
12.7 Interface EntityManager..........................................................................................149
12.7.1 Ciclo de vida da Entity .................................................................................150
12.8 DAO (CRUD) utilizando JPA ...................................................................................150
12.9 Estratégia de SEQUENCE para gerar ID................................................................156
12.10 Utilizando chave composta ..................................................................................158
12.11 Relacionamento entre entidades..........................................................................168
12.12 Os quatro tipos de cardinalidade.........................................................................168
12.13 Cascade Type.........................................................................................................189
12.14 FetchType...............................................................................................................189
12.15 Consultas com JPAQL ..........................................................................................199
12.15.1 Interface Query .............................................................................................203
13 Relatórios ..............................................................................................................................207
13.1 Acesso ao banco de Dados....................................................................................213
13.2 iReport Wizard .......................................................................................................2130
13.3 Modelo Relatório iReport........................................................................................213
13.3.1 Estrutura de um relatório .............................................................................213
13.3.2 Variáveis, Parâmetros e campos ...............................................................2134
13.3.3 Arquivos gerados pelo iReport.....................................................................216
14 Threads em Java...................................................................................................................223
14.1 Thread em Java .......................................................................................................224
14.2 Criando Threads em Java.......................................................................................225
14.2.1 Implementando o Comportamento de uma Thread .....................................226
14.2.2 Criando uma subclasse de Thread ..............................................................226
14.2.3 Implementando a Interface Runnable ..........................................................226
14.2.4 Escolhendo entre os dois métodos de criação de threads...........................227

______________________________________________________________________________________________
14.2.5 O ciclo de vida de uma Thread ....................................................................230
14.2.6 Criando Threads ..........................................................................................230
14.2.7 Iniciando Threads ........................................................................................230
14.2.8 Fazendo Thread Esperar .............................................................................231
14.2.9 Finalizando Threads ....................................................................................231
14.2.9.1 Verificando se Threads estão Executando/Pronta/Esperando ou
Novas/Mortas...............................................................................................................................231
14.10 Threads Daemon .................................................................................................2341
14.11 Escalonamento de Threads ................................................................................2342
14.12 Sincronizando Threads (Concorrência) ...........................................................2343
14.13 Implementando Exclusão Mútua de Regiões Críticas......................................2343
14.14 Comunicação Entre Threads................................................................................234
14.15 Evitando Starvation e Deadlock...........................................................................234

______________________________________________________________________________________________
Java é uma linguagem de programação orientada a objetos desenvolvida no início
da década de 90, pela Sun Microsystems1. Diferentemente das linguagens convencionais, que
são compiladas para código nativo, a linguagem Java é compilada para um bytecode2 que é
executado por uma máquina virtual.
Em 1991, a Sun Microsystems, deu início ao Green Project, a origem do Java,
uma linguagem de programação orientada a objetos. Os idealizadores do projeto eram Patrick
Naughton, Mike Sheridan, e James Gosling. Eles acreditavam que, em breve, haveria uma
convergência dos computadores com os equipamentos e eletrodomésticos utilizados no dia-a-dia.
Para provar a viabilidade desta ideia, 13 pessoas trabalharam durante 18 meses. No verão
de 1992 foi apresentado uma demonstração funcional da ideia inicial. O protótipo se
chamava *7 (lê-se “Star Seven”), um controle remoto com uma interface gráfica touchscreen. Para
o *7, foi criado um mascote, hoje amplamente conhecido no mundo Java, o Duke. O trabalho do
Duke no *7 era ser um guia virtual ajudando e ensinando o usuário a utilizar o equipamento. O *7
tinha a habilidade de controlar diversos dispositivos e aplicações. James Gosling especificou uma
nova linguagem de programação para o *7. Gosling decidiu batizá-la de “Oak”, que quer
dizer carvalho, uma árvore que ele podia observar quando olhava através da sua janela.
O próximo passo era encontrar um mercado para o *7. A equipe achava que uma boa ideia
seria controlar televisões e vídeo por demanda com o equipamento. Eles construíram uma
demonstração chamada de MovieWood, mas infelizmente era muito cedo para que o vídeo por
demanda bem como as empresas de TV a cabo pudessem viabilizar o negócio. A ideia que o *7
tentava vender, hoje já é realidade em programas interativos e também na televisão digital. Permitir
ao telespectador interagir com a emissora e com a programação em uma grande rede de cabos,
era algo muito visionário e estava muito longe do que as empresas de TV a cabo tinham capacidade
de entender e comprar. A ideia certa, na época errada.
Entretanto, o estouro da internet aconteceu e rapidamente uma grande rede interativa
estava se estabelecendo. Era este tipo de rede interativa que a equipe do *7 estava tentando vender
para as empresas de TV a cabo. E, da noite para o dia, não era mais necessário construir a
infraestrutura para a rede, ela simplesmente estava lá. Gosling foi incumbido de adaptar o Oak para
a internet e em janeiro 1995 foi lançada uma nova versão do Oak que foi rebatizada para Java. A
tecnologia Java tinha sido projetada para se mover por meio das redes de dispositivos
heterogêneos, redes como a internet. Agora aplicações poderiam ser executadas dentro
dos navegadores nos Applets Java e tudo seria disponibilizado pela internet instantaneamente. Foi
o estático HTML dos navegadores que promoveu a rápida disseminação da dinâmica tecnologia
Java. A velocidade dos acontecimentos seguintes foi assustadora, o número de usuários cresceu
rapidamente, grandes fornecedores de tecnologia, como a IBM anunciaram suporte para a
tecnologia Java.
Desde seu lançamento, em maio de 1995, a plataforma Java foi adotada mais rapidamente
do que qualquer outra linguagem de programação na história da computação. Em 2004 Java
1
Sun Microsistens : É uma subsidiária da Oracle Corporation fabricante de computadores, semicondutores e
software com sede em Santa Clara, Califórnia, no Silicon Valley.
2
Bytecode : É a forma intermediária de código, resultante da compilação de um código escrita na linguagem Java.
Introdução 1

______________________________________________________________________________________________
atingiu a marca de 3 milhões de desenvolvedores em todo mundo. Java continuou crescendo e
hoje é uma referência no mercado de desenvolvimento de software. Java tornou-se popular pelo
seu uso na internet e hoje possui seu ambiente de execução presente
em navegadores, mainframes, sistemas operacionais, celulares, palmtops, cartões inteligentes etc.
1.1 Padronização
Em 1997 a Sun Microsystems tentou submeter a linguagem a padronização pelos
órgãos ISO/IEC e ECMA, mas acabou desistindo.3 4 5 Java ainda é um padrão de fato, que é
controlada através da JCP Java Community Process.6. Em 13 de novembro de 2006, a Sun lançou
a maior parte do Java como Software Livre sob os termos da GNU General Public License (GPL).
Em 8 de maio de 2007 a Sun finalizou o processo, tornando praticamente todo o código Java como
software de código aberto, menos uma pequena porção da qual a Sun não possui copyright.7
1.2 Características
A tecnologia Java é composta basicamente de uma linguagem de programação, um
ambiente de desenvolvimento, um ambiente de distribuição e uma Java Virtual Machine (Máquina
virtual Java), responsável pela execução das aplicações (SANTOS, pág. 13, 2010).
A linguagem Java foi projetada tendo em vista os seguintes objetivos:
 Orientação a objetos - Baseado no modelo de simular;
 Portabilidade - Independência de plataforma - "escreva uma vez, execute em qualquer lugar"
("write once, run anywhere");
 Recursos de Rede - Possui extensa biblioteca de rotinas que facilitam a cooperação com
protocolos TCP/IP, como HTTP e FTP;
 Segurança - Pode executar programas via rede com restrições de execução;
Além disso, podem-se destacar outras vantagens apresentadas pela linguagem:
 Sintaxe similar a C/C++;
 Facilidades de Internacionalização - Suporta nativamente caracteres Unicode;
 Simplicidade na especificação, tanto da linguagem como do "ambiente" de execução (JVM);
 É distribuída com um vasto conjunto de bibliotecas (ou APIs);
 Possui facilidades para criação de programas distribuídos e multitarefa (múltiplas linhas de
execução num mesmo programa);
 Deslocação de memória automática por processo de coletor de lixo;
 Carga Dinâmica de Código - Programas em Java são formados por uma coleção de classes
armazenadas independentemente e que podem ser carregadas no momento de utilização;
De acordo com Santos (pág. 14, 2010), um programa feito em Java é composto de classes que
possuem atributos e métodos. Os atributos em uma classe são variáveis que podem ser
modificadas ao longo da execução do programa, os métodos por sua vez, executam determinadas
tarefas e retornam respostas.
Ainda de acordo com Santos (pág. 14, 2010), Java é totalmente orientada a objetos, possui
suporte para threads3, ou seja, garante que o programa rode vários processos ao mesmo tempo
3
thread : Um fluxo de controle sequencial isolado dentro de um programa.

______________________________________________________________________________________________
(multitarefa), possuí tratamento de erros (exceptions), coletor de lixo (Garbage Colector). Possui
também um conjunto de bibliotecas de classes (API) prontas, que diminuem o trabalho do
programador, é multiplataforma, enfim são essas, e outras características que fazem do Java uma
das linguagens mais populares do mundo.
1.3 Licença
A Sun disponibiliza a maioria das distribuições Java gratuitamente e obtém receita com
programas mais especializados como o Java Enterprise System. Em 13 de novembro de 2006, a
Sun liberou partes do Java como software livre, sob a licença GNU General Public License. A
liberação completa do código fonte sob a GPL ocorreu em maio de 2007.
1.4 Máquina Virtual
Quando um programa Java é compilado, gera-se um código intermediário, o bytecode, que
é interpretado pela máquina virtual Java, que por sua vez traduz os bytecodes para a linguagem de
máquina nativa do processador. Desta forma, a tecnologia Java é multiplataforma, ou seja, um
programa em Java rodará em qualquer plataforma que possua um JVM (SANTOS, pág. 3, 2010).
De acordo com a especificação da SUN, a máquina virtual do Java pode ser vista como:
 Uma máquina imaginária que é implementada via software ou hardware;
 Um código a ser executado por essa máquina deve ser gravado em um arquivo com
extensão .class. e possuir um código compatível com as instruções Java.
Para um programa Java ser executado, ele precisa passar pelo processo ilustrado na figura a
seguir:
O código é compilado, gerando um conjunto de instruções chamado de byte-code. Esse
byte-code é aplicado à Máquina Virtual Java ( JVM ) que se encarrega de interpretar os comandos
para o sistema operacional onde o programa está rodando, ou seja, a máquina virtual traduz as
instruções do código Java para instruções válidas no sistema operacional em que está rodando.
Se essa portabilidade fosse requerida em C, o código deveria ser compilado várias vezes – uma
para cada sistema operacional desejado. No caso do Java, o código é compilado apenas uma vez,
gerando o byte-code. Esse byte-code poderá então ser interpretado por qualquer máquina virtual
Java, rodando em Linux, Windows, Palm OS, Solaris ou qualquer outro sistema operacional que
possua uma máquina virtual Java implementada.
Uma JVM possui definições concretas para a implementação dos seguintes itens:
 Conjunto de instruções (equivalentes às instruções da CPU);

______________________________________________________________________________________________
 Conjunto de registradores;
 Formato padrão de classes;
 Pilha de memória;
 Pilha de objetos coletados pelo garbage-collector;
 Área de memória.
IMPORTANTE: a JVM não permite que um programa Java acesse recursos de hardware
diretamente, protegendo o computador de operações perigosas, como acesso a regiões protegidas
da memória ou formatação física do disco rígido. Um programa Java só é executado caso o seu
byte-code passe pela verificação de segurança da JVM, que consiste em dizer que:
 O programa foi escrito utilizando-se a sintaxe e semântica da linguagem Java;
 Não existem violações de áreas restritas de memória no código;
 O código não gera Stack Overflow;
 Os tipos de parâmetros dos métodos são corretos;
 Não existe nenhuma conversão ilegal entre dados do programa, como a tentativa de
conversão de inteiros em ponteiros;
 O acesso a objetos está corretamente declarado;
 Caso alguma das condições acima não seja satisfeita, a máquina virtual Java causará um
erro de execução (runtime error).
1.5 Garbage Collection
Durante a execução de um programa de computador, ocorre a alocação e liberação dinâmica
de memória RAM. Dados são escritos e lidos da memória do computador satisfazendo os requisitos
de cada programa. Em linguagens tradicionais como Pascal, Basic e C/C++, o programador é
responsável por controlar essa alocação, impedindo o estouro de memória (stack overflow) e outros
problemas, como o acesso indevido a áreas reservadas de memória. Para facilitar a vida dos
programadores, e evitar os erros comuns associados à alocação de memória, a linguagem Java
introduziu um novo conceito: o garbage-collection.
Garbage-collection é um mecanismo de controle automático de alocação e liberação de
memória. Quando uma variável é declarada em um código de computador, a JVM cria um ponteiro
para uma área de memória equivalente ao tamanho do tipo de dado utilizado por essa variável.
Quando essa variável é associada a outra região de memória, a JVM coloca o espaço alocado
anteriormente em uma pilha de objetos em desuso. Caso o computador fique com pouca memória
disponível, a JVM remove objetos dessa pilha, permitindo que esse espaço de memória seja
realocado.
O processo de garbage-collection ocorre automaticamente durante a execução de um
programa Java. O programador não precisa se preocupar com aritmética de ponteiros (grande
dificuldade em linguagens como C e Pascal).
1.6 Estrutura de um código em Java
Como todas as outras linguagens de programação, Java possui um formato básico para a

______________________________________________________________________________________________
escrita de códigos. Tal formato é demonstrado a seguir:
1. // Duas barras significam comentário
2. /* comentários também podem seguir o formato de C++ */
3.
4. public class NomeDoPrograma
5. {
6. // O método main sempre deve estar presente para que um código Java possa ser
executado:
7. static public void main(String[] args)
8. {
9. // aqui virão os comandos, que são parecidos com C++
10. }
11. }
Compreendendo o código Java:
 linhas 1 e 2: representam comentários. Um comentário pode conter qualquer informação
relevante ao comportamento do programa, autor, versão, etc.;
 linha 3: está em branco, pois Java permite linhas em branco entre os comandos;
 linha 4: é a declaração do "nome do programa", que é case-sensitive (existe diferença entre
maiúsculas e minúsculas). O arquivo que contém o código Java deve ser salvo com o mesmo
nome que aparece após a declaração public class e mais a extensão .java (o exemplo acima
deveria ser salvo como NomeDoPrograma.java);
 linha 5 e 8: a abertura de chave { indica início de bloco;
 linha 7: essa linha deve aparecer em todos os códigos Java. Quando um programa Java é
executado, o interpretador da JVM executa os comandos que estiverem dentro do bloco
indicado pelo método "static public void main(String)";
 Linha 9: aqui seria escrito o código propriamente dito. Instruções como for-next, print, etc.;
 Linha 10 e 11: o fechamento de chave } indica fim de bloco;

______________________________________________________________________________________________
Exemplo de código Java:
Como rodar o programa:
1. Salvar o código acima em um arquivo nomeado: OlaMundo.java (não esqueça o case-sensitive);
2. Digite no console:
a. C:exercicio-java>javac AloMundo.java;
3. Caso não ocorra nenhuma mensagem de erro, digite:
a. C:exercicio-java>java AloMundo
Obs: Caso os procedimentos acima não funcionarem deve ser verificado se o Java está instalado
na máquina, ou o JDK (Kit de Desenvolvimento Java), ou ainda se as configurações estão corretas.
1.7 Instalação e configuração do java
As instruções aqui contidas referem-se ao sistema operacional Windows 7.
1.7.1 Requisitos do Sistema Java 8
 Windows 10 (8u51 e versões posteriores);
 Windows 8.x (Desktop);
 Windows 7 SP1;
 Windows Vista SP2;
 Windows Server 2008 R2 SP1 (64 bits);
 Windows Server 2012 e 2012 R2 (64 bits);
 RAM: 128 MB;
 Espaço em disco: 124 MB para JRE; 2 MB para Java Update;
 Processador: no mínimo, um processador Pentium 2 de 266 MHz;
 Browsers: Internet Explorer 9 e versão mais recente, Firefox, Chrome;
1.7.2 Download e Instalação
É recomendável a desativação do firewall da Internet antes de continuar com a instalação
on-line. Em alguns casos, as configurações padrão do firewall estão definidas para rejeitar
instalações automáticas ou on-line, como a do Java. Se o firewall não estiver configurado
corretamente, talvez ele atrase a operação de download/instalação do Java sob certas condições.

______________________________________________________________________________________________
Consulte o seu manual específico para obter instruções sobre como desativar seu firewall da
Internet.
 Acessar a página de download: manual:https://www.java.com/pt_BR/download/manual.jsp
 Clicar em Windows Online.
 A caixa de diálogo Download de Arquivo é exibida, solicitando que execute ou salve o
arquivo do download.
 Para executar o instalador, clique em Executar.
 Para salvar o arquivo para instalação posterior, clicar em Salvar.
 Selecione a localização da pasta e salve o arquivo no sistema local.
Dica: salvar o arquivo em um local do computador que seja fácil de acessar, como a área de
trabalho.
Para iniciar o processo de instalação, clicar duas vezes no arquivo salvo.
 O processo de instalação será iniciado. Clicar no botão Instalar para aceitar os termos de
licença e continuar com a instalação.
 A Oracle é parceira de algumas empresas que oferecem diversos produtos. O instalador poderá
apresentar uma opção para instalar esses programas quando você instalar o Java. Depois de
verificar se os programas desejados foram selecionados, clique no botão Avançar para
continuar com a instalação;
 Algumas caixas de diálogo confirmam as últimas etapas do processo de instalação. Clique em
Fechar na última caixa de diálogo. Isso concluirá o processo de instalação do Java.

______________________________________________________________________________________________
Remover versões mais antigas (8u20 e versões posteriores). A partir do Java 8 Update 20
(8u20), nos sistemas Windows, a ferramenta de desinstalação do Java é integrada com o instalador
para fornecer uma opção para remover do sistema as versões mais antigas do Java. A alteração
se aplica a plataformas Windows de 32 bits e de 64 bits.
Notificações sobre Java desativado e restauração de prompts. O instalador avisa caso o
conteúdo Java esteja desativado nos Web browsers e fornece instruções para ativá-lo. Se você
tiver optado por ocultar alguns prompts de segurança para applets e aplicações Java Web Start, o
instalador fornecerá uma opção para restaurar os prompts. O instalador pode solicitar que o
computador seja reiniciado se você tiver optado por não reiniciar um Internet browser quando foi
solicitado a fazê-lo.
Após a instalação do Java (JRE) o sistema está pronto para executar aplicações construídas
utilizando a linguagem. Porém, para que se possa criar novos programas não é o suficiente. Para
tanto é necessário ter instalado no computador o JDK (Kit de Desenvolvimento Java).
Instalação do JDK
O JDK (Java Development Kit) possui todo o ambiente necessário para desenvolver e
executar aplicativos em Java, contendo uma cópia do JRE que pode ser distribuído junto com sua
aplicação em algum tipo de instalador ou CD, por exemplo, para os clientes não precisarem baixar
e/ou instalar o Java pessoalmente.
A seguir o endereço para o obter a versão 8 do JDK:
http://www.oracle.com/technetwork/java/javase/downloads/jdk8-downloads-2133151.html
Um ponto bastante importante é sempre escolher o tipo do sistema operacional, este exemplo de
instalação é para versões Windows (x86).

______________________________________________________________________________________________
Página para download do JDK 8.
Após ter baixado o instalador da JDK, execute o instalador e avance nas telas a seguir:

______________________________________________________________________________________________
Opções de instalação:
Status de instalação e pasta de destino:

______________________________________________________________________________________________
Progresso da instalação JDK:
Local da instalação do JRE:
Browser que irá possuir o plugin do Java
Progresso da instalação do JRE:

______________________________________________________________________________________________
Finalização da Instalação:
Após o término da instalação vamos configurar as variáveis do ambiente, abaixo estão os passos
a serem seguidos.
1. Clique com o botão direito em cima do ícone “Meu Computador”;
2. Vá em “Propriedades”;
3. Selecione a aba “Avançado” (Windows XP) ou “Configurações avançadas do sistema”, depois
na aba “Avançado” (Windows 7);
4. Clique no botão “Variáveis de ambiente”;
5. Clique no botão “Nova” em “Variáveis do sistema”;
5.1. Nome da variável: JAVA_HOME
5.2. Valor da variável: coloque aqui o endereço de instalação (o caminho tem que ser o
mesmo especificado na figura a seguir) “C:Arquivos de programasJavajdk1.5.0_05”
5.3. Clique em OK

______________________________________________________________________________________________
6. Clique novamente no botão “Nova” em “Variáveis do sistema”;
6.1. Nome da variável: CLASSPATH
6.2. Os valores da variável encontram-se abaixo, sempre insira um do lado outro sem
espaços e com o ; (ponto e vírgula) no final.
Listagem 1: Valor da variável
CLASSPATH ;%JAVA_HOME%lib;%JAVA_HOME%libtools.jar;%JAVA_HOME%libdt.jar;%JAVA
_HOME%libhtmlconverter.jar;%JAVA_HOME%jrelib;%JAVA_HOME%jrelibrt.jar;
6.3. Clique em OK
7. Selecione a variável PATH em “Variáveis do sistema” e clique no botão “Editar”;
7.1. Defina o valor dessa variável com o caminho da pasta Bin. No caso, pode-se utilizar a
variável JAVA_HOME previamente definida.
Listagem 2: Valor da variável de ambiente PATH;%JAVA_HOME%bin

______________________________________________________________________________________________
7.3. Então confirma-se todas as telas no botão Ok.
Logo após ter realizado a configuração acima emula-se um programa em Java.
Testando o Programa em Java
Abra o programa de bloco de notas do Windows (Iniciar > Programas > Acessórios > Bloco de
Notas.
Digite as seguintes linhas:
Listagem 3: Código de um programa Java para teste
public class Ola{
public static void main(String[] args){
System.out.println("Bem Vindo ao Mundo Java!");
}
}

______________________________________________________________________________________________
Salvamento do arquivo Ola.java:
Depois de salvar abra o Prompt do Dos para testar a saída desse sistema.
1. Iniciar
2. Windows XP - Executar e digitar a palavra cmd
3. Windows 7 apenas digite cmd e aperte Enter
Prompt do DOS
Digite a seguinte linha abaixo, para testar se o java está tendo retorno da sua máquina. Deve ser
retornado uma mensagem conforme a figura a seguir.
Verificando a versão do Java
java -version

______________________________________________________________________________________________
Versão do Java instalada no computador
Após obter o retorno da versão estamos prontos para compilar nosso primeiro programa em
Java. Para efetuar a ação seguinte irá ser preciso entrar em modo DOS na pasta em que foi salvo
o arquivo “Ola.java”, como nesse exemplo foi salvo dentro da pasta que já iniciou o Prompt do Dos
(c:UsersThiago), apenas vamos digitar a seguinte linha.
Compilando um programa Java pelo prompt
javac Ola.java
Ao efetuar esse processo é criado na nossa pasta mais um arquivo “Ola.class”, que nada
mais é que os bytecodes gerados pela JVM, quando compilado o arquivo “Ola.java”.
Os arquivos .java são os nossos códigos fontes e os .class são a execução deles, sendo que
se tentarmos abrir um arquivo .class irá aparecer vários caracteres especiais, sendo ilegível, ou
seja, ele transforma o código fonte para código de máquina sendo este independente de plataforma.
Agora, para finalizarmos, vamos ver a saída do programa digitando a linha abaixo:
java Ola

______________________________________________________________________________________________
O resultado deverá possuir a saída “Bem Vindo ao Mundo Java”.
1.8 Ferramentas
O desenvolvimento de software é uma das áreas que mais recursos livres possui,
frameworks multiplataforma, IDE4´s livres de alta qualidade, bancos de dados, entre outros. Nesta
apostila é apresentado algumas ferramentas que proporcionam maior qualidade no processo de
desenvolvimento de software, na linguagem Java, totalmente livres.
A seguir é apresentado um algumas das principais IDEs, de para desenvolvimento em Java.
Na área de desenvolvimento de software, muitos programadores (principalmente aqueles
que iniciam) possuem certo grau de indecisão sobre qual IDE utilizar. Atualmente, as duas IDEs
mais conhecidas e utilizadas para o desenvolvimento de software em Java são o Eclipse e o
NetBeans, sendo ótimas opções aos desenvolvedores, que muitas vezes se deparam com a dúvida
de qual escolher. Estes dois ambientes possuem código aberto e são gratuitos, podendo ser
utilizados para o desenvolvimento de aplicações em outras linguagens, além de Java, podendo
também serem executados em diversas plataformas, além do Windows.
Existem ainda outras IDEs, gratuítas, para o desenvolvimento de aplicações java, como o
JCreator, CodeBlock, BlueJ e outros.
1.8.1 Eclipse
O Eclipse é uma ferramenta IDE que compreende vários tipos de linguagem e que aceita a
instalação de plugins para emular o desenvolvimento da plataforma.
O projeto Eclipse foi iniciado pela IBM, que doou como software livre para a comunidade a
primeira versão do produto. Os autores que criam plug-ins para Eclipse ou que o usam como base
para um aplicativo de desenvolvimento de software são obrigados a liberar qualquer código ou
modificação do Eclipse que usarem de acordo com os termos da EPL, mas podem licenciar suas
próprias adições da maneira que desejarem.
Com o Eclipse boa parte da dificuldade em compilar o programa é descartada, pois, seu
editor de códigos possui muitas funcionalidades e ferramentas, facilitando o desenvolvimento da
aplicação.
Como desvantagem pode-se citar a falta de funcionalidades essenciais para o
desenvolvimento, como criação de telas GUI (Graphic User Interface) que são janelas de
4
IDE : IDE é uma ferramenta que reúne recursos para que o desenvolvimento de software fique mais ágil e fácil,
possibilitando assim maior produtividade ao desenvolvedor.

______________________________________________________________________________________________
programas e sistemas comerciais, como as do Windows e do Linux) e design de páginas web.
1.8.2 NetBeans
O NetBeans é uma ferramenta IDE que permite o desenvolvimento rápido e fácil de
aplicações desktop Java, móveis e Web e também aplicações HTML5 com HTML, JavaScript e
CSS. O IDE também fornece um grande conjunto de ferramentas para desenvolvedores de PHP e
C/C++. Ela é gratuita e tem código-fonte aberto, além de uma grande comunidade de usuários e
desenvolvedores em todo o mundo.
O Netbeans foi desenvolvido por dois estudantes tchecos na Universidade de Charles,
em Praga, quando a linguagem de programação Java ainda não era tão popular como atualmente.
Primeiramente o nome do projeto era Xelfi, em alusão ao Delphi, pois a pretensão deste
projeto era ter funcionalidades semelhantes aos IDEs tão populares do Delphi, que eram mais atra-
tivas por serem ferramentas visuais e mais fáceis de usar, porém com o intuito de ser totalmente
desenvolvido em Java.
Em 1999 o projeto já havia evoluído para uma IDE proprietário, com o nome de NetBeans
DeveloperX2, nome que veio da ideia de reutilização de componentes que era a base do Java.
Nessa época a empresa Sun Microsystems havia desistido de sua IDE Java Workshop e, procu-
rando por novas iniciativas, adquiriu o projeto NetBeans DeveloperX2 incorporando-o a sua linha
de softwares.
Como uma das vantagens do NetBeans ele é 100% java, feito em Swing, portanto roda onde
houver uma JRE 1.3 compatível (Java Runtime Environment), suporta 'out-of-the-box' (sem plugins
extras) J2EE (EJBs, WebServices, JSP, etc), design visual de telas Swing. Versão 4.1 é uma versão
mais rápida e possui menos memória
Como desvantagens ele fica um pouco atrás nas funcionalidades na compilação de progra-
mas, poucos templates de código, pouco controle no código da aplicação por parte do desenvolve-
dor. A IDE gera código automaticamente sem que o desenvolvedor o conheça.
1.8.3 Jcreator
JCreator é um IDE Ambiente de Desenvolvimento Integrado criado pela Xinox Software
tendo as versões Pro e LE (Learn Edition) que suporta o desenvolvimento em Java,JavaS-
cript,XML,HTML.
JCreator é uma poderosa e interativa ferramenta de desenvolvimento (IDE) para JAVA que
com as seguintes características:
 Manipulação de projetos em uma interface semelhante à do Microsoft Visual Studio;
 Definição de esquemas de cor XML;
 Reutilização de código de projetos existentes usando diferentes versões do JDK;
 Modelos pré-definidos;
 Permite manusear e intercambiar código com sua integração entre Ant e CVS.
 Personalização da interface do usuário.
Como vantagem pode-se citar o uso dele pela web, incorpora Framework, desvantagens perde um
pouco em agilidade.

______________________________________________________________________________________________
1.8.4 BlueJ
O BlueJ é um ambiente gratuito de desenvolvimento de aplicações orientadas a objetos
utilizando a linguagem de programação Java. Uma de suas características principais é a facilidade
de aprendizagem de programação OO, através de recursos visuais interativos. Por exemplo,
classes e relacionamentos podem ser definidos visualmente, e é possível verificar o comportamento
dos objetos em memória durante a execução.
O BlueJ é resultado de um projeto de pesquisa voltado ao ensino de orientação a objetos
para iniciantes, desenvolvido pela Deakin University (Austrália) e University of Kent (Inglaterra),
com contribuições de diversos outros grupos. É também suportado pela Sun Microsystems. O
projeto "NetBeans BlueJ Edition", que recentemente liberou sua primeira versão beta, permite a
migração suave de iniciantes utilizando do BlueJ para um IDE profissional.
1.9 IDE Netbeans
Os exemplos apresentados doravante serão construídos utilizando a IDE NetBeans.
Portanto faz-se necessário uma apresentação mais detalhada desta ferramenta. A seguir é
apresentado os recursos mais utilizados desta ferramenta.
Criação de Projeto:
1 – Abrir a ferramenta NetBeans, clicar em “Arquivo”, “Novo Projeto”.
2- Em “Novo Projeto”, selecionar a opção “aplicação JAVA”, então “Próximo”.

______________________________________________________________________________________________
Criando classe:

______________________________________________________________________________________________
Criando primeiro programa em Java
Execução do Programa:
Antes de apresentar a sintaxe da linguagem Java, é importante apresentar alguns conceitos
básicos e essenciais para a programação, utilizando como ferramenta a linguagem Java, que se
baseia nas linguagens C e C++.
Um programa escrito em Java é composto de classes que possuem atributos e métodos. Os
atributos em uma classe são variáveis que podem ser modificadas ao longo da execução do
programa, já os métodos, executam determinadas tarefas a partir de informações de entrada,
retornando ou não, respostas.
Java é totalmente orientada a objetos, ...
Linguagem Java 2

______________________________________________________________________________________________
2.1 Sintaxe Java
O formato de codificação da linguagem Java deve seguir uma serie de diretrizes para que
os algoritmos possam ser implementados. Um algoritmo é um procedimento para resolver um
problema em um número finito de passos, que frequentemente envolve a repetição de operações.
2.1.1 Delimitadores em Java
Em um código-fonte Java, alguns símbolos são utilizados pelo compilador para diferenciar
comandos, blocos de comandos, métodos, classes, etc. Tais símbolos, chamados de delimitadores,
são enumerados a seguir:
2.1.1.1 Comentários
Comentários servem para identificar a função de um comando, um trecho de código, ou um
método.
Além disso, os comentários podem ser utilizados para documentar aspectos de
desenvolvimento de um programa: como o nome da empresa que o desenvolveu, nome dos
programadores, versão, etc. Existem dois tipos de comentário: o simples e o de documentação.
O comentário simples é delimitado por duas barras // e termina ao final de uma linha. O
comentário de documentação é iniciado pelo símbolo /** e encerrado pelo símbolo */, podendo
conter várias linhas de texto e linhas em branco.
2.1.1.2 Blocos
Um bloco é formado por um conjunto de instruções delimitadas por chaves, como no
exemplo abaixo:
Ponto e vírgula, blocos e espaços em branco: em Java, todo comando é terminado por um ponto
e vírgula (;). Exemplo: System.out.println("note o ponto e vírgula no final ");
Espaço em branco, quebra de linha e caracteres de tabulação são permitidos em qualquer

______________________________________________________________________________________________
trecho do código-fonte, devendo ser utilizados para realçar o aspecto visual de seu código. Apesar
do aspecto visual do código-fonte não ter nenhum impacto no desempenho de um programa Java,
o uso de endentação é uma característica de bons códigos-fonte. Um único programador não será
o único a ler o código-fonte de seus programas, portanto o programa deve ser escrito da maneira
mais organizada e legível possível.
2.1.2 Identificadores e palavras reservadas
Em Java, um identificador é uma sequência de símbolos UNICODE (64K símbolos) que
começa com uma letra, um símbolo subscrito _, ou o caractere $. Os demais símbolos de um
identificador podem conter também números. Identificadores são case-sensitive e não tem um
tamanho máximo estabelecido. Apesar da tabela UNICODE ser bastante extensa, um bom hábito
de programação é utilizar somente letras do alfabeto (a-Z) e números para nomear identificadores.
Exemplo de identificadores Válidos:
data
_data
$data
data_do_mês
data1
uma_variável_pode_SER_bastante_extensa_e_conter_Numeros234876238476
data_public_class_NoteQueEsseIdentificadorContemPalavrasReservadas
Apesar desta "liberdade" de opções para nomes de identificadores, algumas palavras não
são permitidas. Tais palavras são ditas palavras reservadas, e representam o conjunto de
comandos que forma a sintaxe da linguagem Java. O conjunto de palavras reservadas em Java é
o seguinte:
abstract
boolean
break
byte
case
catch
char
class
const
continue
default
double
else
extends
final
finally
float
for
goto
if
implements
import
int
interface
long
native
new
package
private
protected
public
return
short
strictfp
super
switch
synchronized
this
throw

______________________________________________________________________________________________
throws
transient
try
void
volatile
static
while
Não é preciso se preocupar em memorizar o nome das palavras reservadas em Java. À
medida que se pratica a programação em Java, isso se tornará natural. Além disso, o compilador
acusa um erro de nomenclatura quando se tenta utilizar uma palavra reservada para nomear uma
variável, um método ou uma classe.
2.1.3 Declaração de Variáveis
Uma variável é sempre declarada seguindo do seguinte esquema:
<tipo> + <espaço> + identificador + ;
ou
<tipo> + <espaço> + identificador + = + valor + ;
onde:
<tipo> é um tipo primitivo de dados ou o nome de uma classe ou interface
identificador é o nome da variável
valor é o valor atribuído à variável. No caso de uma variável ser declarada sem atribuir um valor,
ela não poderá ser utilizada em um código Java, a tentativa de utilizar uma variável não inicializada
em Java gerará um erro de compilação. Exemplos:
Posteriormente será visto que Java possui um mecanismo de inicialização de variáveis de
seus tipos primitivos, mas o aluno deve evitar considerar essa inicialização como prática de
programação. De fato, esta inicialização automática não funciona para variáveis de tipos agregados
ou abstratos de dados e também que o escopo das variáveis, de classe ou de instância, tem
influência na sua inicialização. O aluno é fortemente recomendado a pensar em variáveis como
espaços alocados na memória RAM, inicialmente podendo conter qualquer valor (conhecido como
lixo na memória).

______________________________________________________________________________________________
2.1.4 Tipos primitivos
A linguagem Java utiliza oito tipos primitivos de dados e um tipo especial. Esses tipos
primitivos podem ser utilizados para declarar constantes ou variáveis utilizadas em programas Java.
Os tipos primitivos estão divididos em quatro categorias: lógicos, textuais, numéricos inteiros e
numéricos de ponto flutuante.
2.1.4.1 Tipos lógicos: boolean
Valores lógicos possuem dois estados, normalmente ditos verdadeiro/falso, sim/não e ligado/
desligado. Em Java um tipo lógico é definido pela palavra boolean, e pode assumir dois valores:
true ou false.
2.1.4.2 Tipos textuais: char e String
Caracteres simples são representados pelo tipo char. Um char representa um caracter
UNICODE, ou seja, um número inteiro sem sinal de 16 bits, no intervalo de 0 até 216 -1. O valor de
um literal char deve ser delimitado por aspas simples:
Palavras são representadas por uma sequência de dados do tipo char, agrupadas em um
tipo especial de dados: a classe String. Apesar de ser uma classe, uma variável do tipo String

______________________________________________________________________________________________
suporta operações como se fosse um tipo primitivo de dados. O valor de uma variável String deve
ser delimitado por aspas duplas "valor". A concatenação de qualquer tipo de dado com um dado do
tipo String resulta em um novo dado do tipo String.
2.1.4.3 Tipos numéricos inteiros: byte, short, int e long
Existem quatro tipos primitivos de números em Java. Além disso, os valores numéricos
podem ser representados de forma decimal, octal ou hexadecimal:
Valores numéricos inteiros em Java:
2 decimal
077 um número que começa com zero está representado de forma octal
0xBABE representação hexadecimal
Todos os valores numéricos em Java têm sinal positivo ou negativo. Um valor numérico é
sempre considerado do tipo int, a menos que seja acompanhado do sufixo L, que representa um
valor do tipo long. A diferença de um inteiro para um longo é a capacidade de dígitos que podem
ser representados, conforme aparece no quadro abaixo.
Valores numéricos em Java, representados como long:
2L decimal
077L um número que começa com zero está representado de forma octal
0xBABEL representação hexadecimal
2.1.4.4 Tipos numéricos de ponto flutuante: float e double
Um valor fracionário pode ser representado em Java através dos tipos float e double. A
diferença entre esses dois tipos é o tamanho da mantissa:
float 32 bits
double 64 bits
Para um número ser considerado do tipo ponto flutuante, é necessário a inclusão de um ponto, do
caractere E (de expoente) ou do sufixo D ou F, conforme mostra o quadro abaixo:
// Representação de valores numéricos de ponto flutuante
float pi = 3.141516;
float taxa = 6.02E23;
double valor= 123.4E+306D;
Todo o valor numérico de ponto flutuante é considerado do tipo double, a menos que o programador
o declare explicitamente como float.
2.2 Convenções de codificação
Durante os estudos realizados a partir desta disciplina, será adotada a seguinte convenção

______________________________________________________________________________________________
de codificação:
 Classes: as classes devem ser designadas por nomes, começando por uma letra maiúscula
e depois minúsculas. Cada nova palavra que formar o nome da classe deve ser capitalizada.
Ex: class Calculadora, class CalculadoraCientifica, ...
 Interfaces: igual às classes. Ex: interface Calculo, interface EquacaoLogaritmica, ...
 Métodos: métodos devem ser nomeados por verbos, seguindo o mesmo formato de
capitalização das classes. Entretanto, um método sempre deve começar com letra
minúscula. Ex: public void calcular(int numero), public void extrairRaiz(int numero), ...
 Constantes: constantes devem ter todas as suas letras em maiúsculo, com o símbolo de
subscrito para separa as palavras. Ex: final int ANO = 2002, final boolean VERDADE =
true, ...
 Variáveis: tal qual os métodos, as variáveis devem começar com uma letra minúscula e
depois alternar a cada palavra. Procure usar nomes significativos para variáveis. Evite
declarar variáveis usando apenas um a letra.
Através de expressões é implementado a manipulação de variáveis e implementação de
tomada de decisões em programas Java.
3.1 Operadores
Os operadores Java são similares em estilo e função aos operadores da linguagem C/C++.
A tabela abaixo enumera esses operadores em ordem de precedência:
3.1.1 Operadores Delimitadores
. [] () ; , Servem para delimitar partes distintas de um comando, método ou classe.
3.1.2 Operadores Aritméticos
+ Adição
- Subtração
* Multiplicação
/ Divisão
% Resto (Modulo)
Expressões 3

______________________________________________________________________________________________
3.1.3 Operadores de Atribuição
+= x += y → x=x + y
-= x -= y → x=x - y
*= x *= y → x=x * y
/= x /= y → x=x / y
%= x %= y → x=x % y
3.1.4 Operadores Unários
+ e - Para mudar o sinal do operando.
3.1.5 Operadores de Incremento e Decremento
++ Incremento Ex: x++ → x=x+1
-- Decremento Ex: x-- → x=x-1
3.1.6 Operadores Relacionais
> Maior que
< Menor que
== Igual a
!= Diferente de
>= Maior ou igual
<= Menor ou igual
3.1.7 Operadores Lógicos
&& Devolve true se ambos operandos forem true.
||
!
Esses operadores permitem a representação de expressões booleanas, que formam o argumento
para comandos de decisão (IF), seguindo a seguinte tabela:
AND
true && true = true;
false && false = false;
false && true = false;
true && false = false;
OR
true || true = true
false || false = false
false || true = true
true || false = true
Os comandos de controle (if, while, switch) utilizam o valor de expressões booleanas para guiar o
fluxo de controle de um programa, como no exemplo a seguir:

______________________________________________________________________________________________
3.1.8 Operador de concatenação
+ Concatena (junta) dados do tipo string
Quando o operador + é aplicado a dados do tipo String, ele cria um novo dado do tipo String,
concatenando os dois operandos:
/**
* Concatenação de Strings
*/
String sigla = "CIMOL";
String nome = "Escola Estadual Monteiro Lobato";
String titulo = sigla + " - " + nome;
// Esse comando imprimirá na tela a frase:
// SOO-I – Sistemas Orientados a Objetos I
System.out.prinln(titulo);
int i = 10;
String legenda = "valor = ";
// campo é uma variável do tipo String
String campo = legenda + i;
3.1.9 Operadores de deslocamento
>> É usado para deslocar o padrão de bits para a direita respeitando o bit do
sinal, ou seja, tudo é deslocado, menos o primeiro bit.
<< É usado para deslocar os bits para a esquerda.
>>> Não respeita o sinal, ou seja, realmente todo mundo é deslocado para
direita, e é colocado um bit com valor 0 à esquerda do padrão.
O operador de deslocamento aritmético >> executa um deslocamento de um bit para a direita
de um número (na prática, o primeiro argumento desse operador é dividido por dois 'n' vezes –
onde n é o segundo argumento do operador):
8 >> 2 = 2

______________________________________________________________________________________________
128 >> 1 = 64
256 >> 4 = 16
 Notação em complemento de dois: o operador >> mantém o sinal do bit mais significativo
durante o deslocamento.
O operador de deslocamento lógico >>> executa um deslocamento no padrão dos bits ao
invés do significado aritmético de um valor numérico. Esse operador sempre adiciona o valor 0 ao
bit mais significativo:
1010 ... >> 2 = 111010 ...
1010 ... >>> 2 = 001010 …
 Os operadores de deslocamento reduzem seus operandos à direita módulo 32 para um valor
do tipo int e módulo 64 para um tipo long. Dessa forma, para qualquer valor do tipo int:
int x
x >>> 32 = x
O operador de deslocamento lógico >>> só pode ser aplicado a valores inteiros, e não é
efetivo em valores int e long. Se for aplicado a valor short ou byte, o valor será promovido a um int
antes da aplicação do operador. Por isso, um deslocamento sem sinal acaba se tornando um
deslocamento com sinal.
3.2 Casting
A linguagem Java não suporta atribuições arbitrárias entre variáveis de tipos diferentes. Por
exemplo, você não pode inicializar uma variável inteira com um valor de ponto flutuante sem
explicitar isso através de um processo que chamamos de casting.
Quando atribuímos um valor a uma variável, e esse valor é incompatível com o tipo de dado
definido para a variável, ocorrerá uma conversão. Em alguns casos, essa conversão será
automática, em outros o programador deve indicar de que forma o valor será convertido ao tipo de
dado da variável.
Quando o processo de conversão for automático, dizemos que ocorreu uma promoção, ou
seja, um valor com um tipo de dado foi promovido a outro tipo de dado. Veja no exemplo abaixo:
// Promoção entre valores de tipos de dados distintos
// Apesar 6 ser um inteiro, o valor da variável grande
// continua sendo do tipo long
long grande = 6;
// Uma variável do tipo inteiro não possui
// espaço para armazenar um valor longo.
// A instrução abaixo é ilegal, e causará um erro de compilação.
int pequeno = 99L;
float a = 12.121F;
float b = 12.121;
// correto
// 12.121 é um double - incorreto
Como visto acima, algumas conversões não podem ser realizadas de forma automática, pois

______________________________________________________________________________________________
o compilador não pode assumir que tipo de conversão ele deve realizar (o tamanho do tipo de dado
a ser recebido por uma variável é maior que o tamanho pré-definido para o tipo dessa variável, logo
o compilador não sabe como "ajustar" os bits excedentes). Nesse caso, o programador deve indicar
ao compilador que tipo de conversão deverá ocorrer, digitando o tipo de dado que o valor deverá
assumir entre parênteses:
// Casting entre valores de tipos de dados distintos
// Apesar 6 ser um inteiro, o valor da variável grande
// continua sendo do tipo long
long grande = 6;
int pequeno = (int)99L; // sem problemas
float a = 12.121F;
float b = (float)a;
// sem problemas
3.3 Recebendo dados do usuário
Até este momento as variáveis estão sendo definidas juntamente com seus valores durante
a programação. Mas e se for necessário obter essa informação do usuário? Por exemplo, para
perguntar a idade ou para criar uma calculadora? Depende do que for digitado.
De agora em diante será utilizado a classe Scanner para realizar a leitura de dados a partir do
teclado.
3.3.1 Importando (import) classes (class) e pacotes (packages)
Existem milhares de funcionalidades no Java. Essas classes foram agrupadas em pacotes,
os packages.
E pacotes para a mesma funcionalidade são chamados de API (Application Programming
Interface). Por exemplo, tem uma seção sobre a API Java 2D, para fazer desenhos em 2D. Ou seja,
são uma série de pacotes para desenhar.
Porém, todos esses pacotes não estão simplesmente prontos para serem utilizados, pois
são muitos.
Inclusive, pode ser criado pacotes customizados, pode baixar, reutilizar, compartilhar, vender
etc.
Se todos estes estivessem prontos para utilização, demoraria MUITO para rodar um
programa em Java.
Para solucionar este problema, diz ao Java quais funcionalidades pretende-se usar. Pra isso,
usa-se a função 'import':
Import pacote_que_quer_importar;
Por exemplo: para usar print, printf e println, não precisa dizer nada ao Java. São métodos
tão comuns que podem ser usados automaticamente em qualquer aplicação. Esses métodos fazem
parte de um pacote chamado 'java.lang'.
Para receber dados do usuário, utiliza-se a classe Scanner, que faz parte do pacote 'java.util'.
Diz ao Java que essa classe será utilizada na aplicação. Para isso, adiciona-se essa linha no
começo do programa:

______________________________________________________________________________________________
import java.util.Scanner;
O próximo passo é declarar objeto do tipo Scanner. Chamá-lo de 'entrada'. Sua declaração
é feita da seguinte maneira:
Scanner entrada = new Scanner(System.in);
Agora, o objeto 'entrada' será usado para ler entradas do sistema.
Para o Java, há muita diferença entre inteiros, float, doubles e outros tipos. Portanto, é
necessário ser bem claro quanto ao tipo de dado que vai ser lido. Assim, a entrada será bem tipada.
Para receber um número inteiro do usuário, com nosso objeto 'entrada', usaremos a seguinte
sintaxe: inteiro = entrada.nextInt();
Esse é um exemplo bem simples que pergunta a idade do usuário, espera ele digitar (e teclar enter)
e exibe essa mensagem na tela:
No exemplo anterior foi realizado a leitura de um número inteiro. Caso o tipo de dados a ser lido
seja diferente de inteiro, deverá ser utilizado outro método, equivalente ao tipo de dados a ser
lido. Ex: Tipo double → entrada.nextDouble()
Mais informações sobre os métodos da classe Scanner pode ser encontrada na
documentação do Java: https://docs.oracle.com/javase/7/docs/api/java/util/Scanner.html.
De acordo com Santos (2010), no desenvolvimento de um programa, muitas vezes se faz
necessário o conhecimento de uma resposta para se possa decidir qual bloco de comando será
executado. Isto é alcançado através dos comandos de controle de fluxo disponibilizados pela
linguagem de programação. Desta forma, os comandos de controle de fluxo de uma linguagem de
programação especificam a ordem em que processamento é feito.
Controle de fluxo é a habilidade de ajustar a maneira como um programa realiza suas tarefas.
Por meio de instruções especiais, chamadas comandos. Essas tarefas podem ser executadas
seletivamente, repetidamente ou excepcionalmente. Não fosse o controle de fluxo, um programa
Controle de Fluxo 4

______________________________________________________________________________________________
poderia executar apenas uma única sequência de tarefas, perdendo completamente uma das
características mais interessantes da programação: a dinâmica.
Pode-se classificar os comandos aceitos pela linguagem Java em basicamente quatro categorias:
Comando Palavra Chave
Tomada de decisões if-else, switch-case
Laços ou repetições for, while, do-while
Apontamento e tratamento de
exceções
try-catch-finally, throw
outros break, continue, label:, return
4.1 Execução Condicional
4.1.1 Comando if
A forma mais simples de controle de fluxo é o comando if. Ele é empregado para executar
seletivamente ou condicionalmente um outro comando mediante um critério de seleção. Esse
critério é dado por uma expressão, cujo valor resultante deve ser um dado do tipo booleano, isto
é, true ou false. Se esse valor for true, então o outro comando é executado; se for false, a
execução do programa segue adiante. A sintaxe para esse comando é:
if ([condição])
[comando] // Executado se a condição for true
Exemplo:
Exercícios:
1) Crie um programa em que o usuário informa o nome de um mês (ex: janeiro) e o programa exibe
o número correspondente a esse mesmo mês (ex: 1);
2) Faça um programa que para n==5 exiba uma mensagem de parabéns;
3) Crie um menu de uma biblioteca da seguinte maneira: 1. Retirar um livro; 2. Devolver um livro e
3. Renovar a retirada de um livro. Em seguida, conforme a opção digitada pelo usuário, mostrar as
mensagens: 1. Livro retirado com sucesso! 2. Livro devolvido com sucesso e 3. Livro renovado.

______________________________________________________________________________________________
4) Faça um programa usando o desvio condicional "IF", que leia o nome e a idade de 1 nadador e
exiba na tela o nome da categoria a qual este nadador pertence. A categoria dos nadadores é dada
pela seguinte tabela:
5) Usando o comando de desvio condicional simples “IF”, faça um programa que leia uma senha
de 8 caracteres inteiros e verifique se a senha informada equivale a senha predefinida no programa.
Se for válida informe na tela "Acesso Autorizado. Caso a senha não estiver correta informe "Acesso
negado".
4.1.2 Comando if-else
Uma variação do comando if, e o if-else que permitem escolher alternadamente entre dois
outros comandos a executar. Nesse caso, se o valor da expressão condicional que define o critério
de seleção for true, então o primeiro dos outros dois comandos é executado, do contrário, o
segundo.
if([condição])
[comando 1] // Executado se a condição for true
else
[comando 2] // Executado se a condição for false
Exemplo:
O if-else compacto não é propriamente um comando, mas um operador que realiza
avaliação seletiva de seus operandos, mediante o valor de uma expressão booleana semelhante à
do comando if-else. Se essa expressão for true, então um primeiro operando é avaliado; se for
false então o segundo operando é avaliado. A sua sintaxe é:
[expressão condicional] ? [expressão 1] : [expressão 2]
onde [condição condicional] deve resultar em true ou false,[expressão1] e [expressão 2] são
os operandos, que podem ser expressões quaisquer. O valor resultante da aplicação do operador
if-else compacto é obviamente igual ao valor do operando que tiver sido avaliado. O tipo desse
valor obedece às regras de conversão de tipos de dados discutida anteriormente.
Para melhor ilustrar o if-else compacto, considera-se o seguinte comando:
y = x < 1 ? x*x : 2-x;

______________________________________________________________________________________________
Este é logicamente equivalente à seguinte sequência de comandos:
if (x<1) then
y = x*x;
else
y = 2-x;
4.1.3 Condicional ternário
O operador condicional ternário, também chamado de if-else compacto, é uma forma
composta de expressar uma instrução if-else:
(condição)? “Operação caso verdadeiro” : “operação caso falso”;
Exemplo:
int m = x < y ? x : y
Na instrução anterior é testado a condição, e caso, for verdadeira atribui x para m, senão
atribui y para m.
É importante notar que o operador condicional ternário é de baixa precedência, logo o uso
de parênteses para separar seus operandos não é necessário (a menos que mais de um desses
operadores esteja presente na mesma expressão). Porém há casos em que o uso de parênteses
para definir claramente os operandos é essencial. Por exemplo, y = |x|*sin(x), pode ser codificado
como:
y = ( x<0 ? -x : x ) * Math.sin(x); // aqui os parenteses são essenciais.
Sem os parênteses, x * Math.sin(x) seria visto pelo operador if-else compacto como se fosse um
único operando, devido à alta precedência do operador multiplicação.
4.1.4 Comando If-else Aninhados
No comando utilizando if-else aninhado o else é sempre associado ao if mais interno (mais
próximo). Frequentemente, deseja-se que um único comando (ou único bloco de comandos) de
uma lista seja executado mediante um dado critério. Isso pode ser feito através do aninhamento ou
acoplamento de vários comandos if-else, do seguinte modo:
if ([condição 1])
[comando 1]
else if ([condição 2])
[comandos 2])
else if ([condição 3])
[comando 3]
....
else
[comando n]
A presença do último else, juntamente com seu comando, é opcional. Neste código,
o [comando 1] será executado (e os demais saltados) caso a primeira condição seja true,
o [comando 2] será executado (e os demais saltados) caso a primeira condição seja false e a
segunda condição seja true, e assim sucessivamente. O [comando n] (se houver) somente será
executado (e os demais saltados) caso todas as condições sejam false.

______________________________________________________________________________________________
Exemplo:
Exercícios:
1) Escreva um programa em Java que recebe um inteiro e diga se é par ou ímpar.
Use o operador matemático % (resto da divisão ou módulo) e o teste condicional if
2) Crie um programa que teste se o valor que usuário digitou está entre 10 e 15 e exiba alguma
mensagem na tela.
3) Faça um programa que solicite ao usuário digitar dois valores, em seguida, exiba na tela qual
dos dois é o maior. OBS: o usuário poderá informar valores iguais, logo, o sistema deve dizer que
foram digitados valores iguais.
4) Crie um algoritmo que pergunte ao usuário se ele deseja converter uma temperatura de graus
Celsius em graus Fahrenheit ou Fahrenheit em Celsius. Em seguida mostre na tela o valor final
correspondente a opção escolhida pelo usuário. F = 1.8 * C + 32 | C = (F – 32) / 1.8;
5) A calculadora de Luciana pifou, justo quando ela precisa fazer vários cálculos. Ela tem um
computador, mas não sabe que um dos acessórios do Windows é uma calculadora. Sendo
estudante de programação, Luciana resolveu fazer um programa. A especificação que bolou prevê
que programa leia dois números inteiros (o que atende suas necessidades) e em seguida um
símbolo de operação. Se este for '+', o programa soma os números, se '-', subtrai, se '*' multiplica
e se '/' divide. Se o símbolo for diferente desses, é mostrada uma mensagem de erro. O programa,
antes de dividir, critica se o divisor é zero e mostra uma mensagem de erro neste caso. Implemente
um programa que construa essa calculadora para Luciana, utilizando o desvio condicional "IF" e
“ELSE”. Crie também procedimentos para executar cada uma das funções da calculadora.
6) Receba três valores fornecidos pelo usuário que representarão os lados de um triângulo.

______________________________________________________________________________________________
Verifique se os valores formam um triângulo e classifique esse triângulo como:
a) Equilátero: três lados iguais.
b) Isósceles: dois lados iguais.
c) Escaleno: três lados diferentes.
Lembre-se de que, para formar um triângulo, nenhum dos lados pode ser igual a zero, um lado não
pode ser maior do que a soma dos outros dois.
7) A partir de 3 notas fornecidas de um aluno, informe se ele foi aprovado, ficou de recuperação ou
foi reprovado. A média de aprovação é >= 7.0; a média de recuperação é >= 5.0 e < 7.0; e a média
do reprovado é < 5.0
8) Solicite o nome e a idade de duas pessoas. Em seguida exiba o nome da pessoa mais velha e
o nome da pessoa mais nova.
9) Verifique quem entre duas pessoas faz aniversário primeiro. Exiba o nome do primeiro aniversa-
riante considerando que estamos no dia 1 de janeiro. Use como entrada o nome, o dia e o mês de
nascimento de cada pessoa.
10) Receba 2 horários e exiba a diferença entre eles em segundos. A entrada destes horários pode
ocorrer em qualquer ordem.
Dica: transforme os dois horários para segundos.
4.1.5 Comando switch
Assim como no caso da execução seletiva de múltiplos comandos, utilizando if-else
aninhados, há situações em que se sabe de antemão que as condições assumem o valor true de
forma mutuamente exclusiva, isto é, apenas uma entre as condições sendo testadas assume o
valor true num mesmo momento. Nesses casos, a linguagem Java (como também as linguagem
C, C++ e Pascal) provê um comando de controle de fluxo bastante poderoso. Trata-se do
comando swich, cuja sintaxe é a seguinte:
switch([expressão]) {
case [constante 1]:
[comando 1]
break;
case [constante 2]:
[comando 2]
break;
.
.
.
case [constante n]:
[de comando n]
break;
default:
[comando]
}

______________________________________________________________________________________________
A [expressão] pode ser qualquer expressão válida. Esta é avaliada e o seu valor resultante
é comparado com as constantes distintas [constante 1],[constante 2], ..., [constante n]. Caso
esse valor seja igual a uma dessas constantes, o respectivo comando é executado (e todos os
demais são saltados). Se o valor for diferente de todas essas constantes, então o comando
presente sob o rótulo default: é executado (e todos os demais são saltados), caso este esteja
presente.
Exemplo:
A opção default, é opcional, caso nenhuma das opções for executada, o switch não executará
nada. Somente serão aceitos valores int e char.
Exercícios:
1) Crie um programa que exibe se um dia é dia útil, fim de semana ou dia inválido dado o número
referente ao dia. Considere que domingo é o dia 1 e sábado é o dia 7.
2) Ler o código de um produto e exibir seu nome de acordo com a tabela a seguir:
3) Criar um programa para identificar o valor a ser pago por um plano de saúde dada a idade do
conveniado considerando que todos pagam R$ 100 mais um adicional conforme os seguintes
dados:
a) crianças com menos de 10 anos pagam R$80;
b) conveniados com idade entre 10 e 30 anos pagam R$50;
c) conveniados com idade entre 40 e 60 anos pagam R$ 95;
d) conveniados com mais de 60 anos pagam R$130.

______________________________________________________________________________________________
Exercícios:
1) Faça um programa que transforme um número Racional (formado por numerador e
denominador) para um número Real. Antes de dividir, verifique se o denominador é diferente de
zero. Emita uma mensagem de alerta ao usuário se for zero.
3) Um banco concede empréstimo a seus clientes no valor máximo de 30% do valor do seu salário
líquido. Receba o valor do salário bruto, o valor dos descontos e o valor do possível empréstimo de
um cliente, em seguida avise se ele poderá ou não fazer o empréstimo.
4) Escreva um programa que a partir de 3 notas fornecidas de um aluno, informe se ele foi aprovado,
ficou de recuperação ou foi reprovado. A média de aprovação é >= 7.0; a média de recuperação
é >= 5.0 e < 7.0; e a média do reprovado é < 5.0
5) Faça um programa que receba do usuário o nome de um mês. Exiba o número equivalente deste
mês. Caso seja informado um mês que não existe, deve ser informado ao usuário.
6) Faça um programa que verifique a validade de uma data de aniversário (solicite apenas o número
do dia e do mês). Além de falar se a data está ok, informe também o nome do mês. Dica: meses
com 30 dias: abril, junho, setembro e novembro.
7) Faça um programa que receba três valores inteiros, e exiba estes números em ordem crescente.
8) Faça um programa que solicite o nome e a idade de 2 pessoas. Em seguida exiba o nome da
pessoa mais velha e o nome da pessoa mais nova.
9) Escreva um programa que receba 2 horários e exiba a diferença entre eles em segundos.
10) Elaborar um programa que verifique quem entre duas pessoas faz aniversário primeiro. Exiba
o nome do primeiro aniversariante considerando que estamos no dia 1 de janeiro. Use como
entrada o nome, o dia e o mês de nascimento de cada pessoa.
11) As Organizações Tabajara resolveram dar um aumento de salário aos seus colaboradores e lhe
contrataram para desenvolver o programa que calculará os reajustes.
Faça um programa que recebe o salário de um colaborador e o reajuste segundo o seguinte critério,
baseado no salário atual:
 Salários até R$ 280,00 (incluindo) : aumento de 20%;
 Salários entre R$ 280,00 e R$ 700,00 : aumento de 15%;
 Salários entre R$ 700,00 e R$ 1500,00 : aumento de 10%;
 Salários de R$ 1500,00 em diante : aumento de 5% Após o aumento ser realizado, informe
na tela: O salário antes do reajuste;
 O percentual de aumento aplicado;
 O valor do aumento;
 O novo salário, após o aumento.

______________________________________________________________________________________________
12) Faça um programa que calcule as raízes de uma equação do segundo grau, na forma ax2 + bx
+ c. O programa deverá pedir os valores de a, b e c e fazer as consistências, informando ao usuário
nas seguintes situações:
a) Se o usuário informar o valor de A igual a zero, a equação não é do segundo grau e o
programa não deve fazer pedir os demais valores, sendo encerrado;
b) Se o delta calculado for negativo, a equação não possui raízes reais. Informe ao usuário
e encerre o programa;
c) Se o delta calculado for igual a zero a equação possui apenas uma raiz real; informe-a ao
usuário;
d) Se o delta for positivo, a equação possui duas raízes reais; informe-as ao usuário;
13) Chaves foi ao Paraguai e realizou a compra de alguns artigos lá. Com base na tabela abaixo
informe a porcentagem do imposto a ser pago e o valor total.
VALOR IMPOSTO %
Até R$10 3%
De R$10,01 a
R$99,99
5%
De R$100 a
R$299,99
10%
Acima de R$300 30%
14) Faça um programa onde o operador de distribuição dos correios digite o código de destino
impresso nas caixas e o sistema exibe o local para onde a encomenda se destina.
CÓDIGO
DESTINO
DESTINO
1 a 5 BRASIL
6 A 9 EUA
10, 11 e 12 RÚSSIA
De 15 a 20 ou de
30 a 35
SUÍCA
13 a 14 AFEGANISTÃO
21 a 29 FRANÇA
15) Um posto está vendendo combustíveis conforme os seguintes descontos:
Álcool:

______________________________________________________________________________________________
a. até 20 litros, desconto de 3% por litro
b. acima de 20 litros, desconto de 5% por litro
Gasolina:
c. até 20 litros, desconto de 4% por litro
d. acima de 20 litros, desconto de 6% por litro
Escreva um algoritmo que leia o número de litros vendidos, o tipo de combustível (codificado da
seguinte forma: A-álcool, G- gasolina), calcule e imprima o valor a ser pago pelo cliente sabendo-
se que o preço do litro da gasolina é R$ 2,50 o preço do litro do álcool é R$ 1,90.
4.2 Laços de Repetição
Frequentemente em aplicações é preciso repetir a execução de um bloco de códigos do
programa até que determinada condição seja verdadeira, ou senão até uma quantidade de vezes
seja satisfeita. Para que essas repetições sejam possíveis, utiliza-se os laços de repetições.
A condição a ser analisada para a execução do laço de repetição deverá retornar um valor
booleano. Podendo acontecer de maneira pré definida como acontece no laço for, ou com o final
aberto como ocorre com os laços while e do-while.
4.2.1 Comando While
Esta instrução é usada quando não se sabe quantas vezes um determinado bloco de
instruções precisa ser repetido. Com ele, a execução das instruções vai continuar até que uma
condição seja verdadeira.
Na estrutura while pode ter uma condição de termino definida já no início ou não.
Necessariamente ele testa a condição e se caso for verdadeiro executa o bloco, caso seja falso ele
vai para a próxima instrução fora do laço.
While (Condição)
{
Comandos;
}
Uma condição deve ser qualquer expressão valida que tenha como resultado true ou false.
Somente se a condição for verdadeira o corpo do laço de repetição, com seus respectivos
comandos, serão executados. Portanto, o conteúdo será repetido até que esta condição não seja
mais verdadeira.
Exemplo:
Pode ocorrer casos em que o laço de repetição while pode não ser executado. Isso pode
ocorrer quando, na primeira verificação da condição, ela for falsa. Neste cenário, o programa
simplesmente irá “pular” para a execução da próxima instrução após o laço.
Exercícios:
1) Escreva um aplicativo em Java que mostra todos os números ímpares de 1 até 100.

______________________________________________________________________________________________
2) Escreva um programa que pergunte ao usuário quantos alunos tem na sala dele.
Em seguida, através de um laço while, peça ao usuário para que entre com as notas de todos os
alunos da sala, um por vez. Por fim, o programa deve mostrar a média, aritmética, da turma.
3) Escreva um programa que pergunta um número ao usuário, e mostra sua tabuada completa (de
1 até 10).
4) Faça um programa que, para um número indeterminado de pessoas: leia a idade de cada uma,
sendo que a idade 0 (zero) indica o fim da leitura e não deve ser considerada. A seguir calcule:
 o número de pessoas;
 a idade média do grupo;
 a menor idade e a maior idade.
5) Crie um programa simulando o acesso a uma conta bancária, onde ele tenha 3 chances para
acertar a senha. Se na quarta vez ele errar, o programa exibe a mensagem de “conta bloqueada”
e, se ele digitar a senha correta exiba a mensagem “bem vindo usuário”.
4.2.2 Comando do-while
Com a estrutura do while, as instruções que estiverem dentro do bloco do{} serão
executadas e, logo depois, a condição será testada. Com do while, mesmo que a condição nunca
seja verdadeira, as instruções sempre serão executadas pelo menos uma vez, pois o teste da
condição ocorre no final do laço.
do{
instruções
}while(condição);
O comando do-while deve ser usado quando não se sabe exatamente quantas vezes o
laço deve se repetir, e o bloco de comandos deve ser executado pelo menos uma vez.
Exemplos:

______________________________________________________________________________________________
Exercícios:
1) Faça um programa que leia dois números inteiros, o primeiro é o valor inicial de um contador, e
o segundo é o valor final do contador (testar se o valor inicial fornecido é inferior ao valor final).
Usando o comando do-while, escreva na tela uma contagem que comece no primeiro número lido,
escreva os números seguintes colocando sempre apenas um número em cada nova linha da tela,
e terminando a contagem quando chegar ao valor final indicado.
2) Apresentar na tela a tabuada de multiplicação dos números de 1 até 10. O programa deve exibir
o resultado das multiplicações de 1x1, 1x2, ... até 1x10, pedir para o usuário pressionar uma tecla,
e recomeçar com 2x1, 2x2, ... até 2x10, pedir novamente para teclar algo e seguir assim
sucessivamente até chegar em 10x10. Use o comando do-while.
3) Faça um programa para ler 10 valores reais, armazenando estes valores em uma tabela (vetor).
Exibir na tela a média simples dos 10 valores lidos. Faça uma primeira versão deste programa
usando apenas comandos while (faça um laço de leitura de dados e um outro laço para o cálculo
da média). Faça uma segunda versão deste programa usando apenas comandos do-while.
Exemplo de tela de saída:
4.2.3 Comando for
O comando for permite que um certo trecho de programa seja executado um determinado
número de vezes. O laço for pode receber três argumentos, separados por ponto e vírgula e
executa as instruções dentro do bloco {}. Incremente a variável de teste, enquanto a condição for
verdadeira.

______________________________________________________________________________________________
Os argumentos são opcionais. Se o teste lógico estiver ausente, e assumido o padrão true,
você pode inicializar mais uma variável, desde que seja do mesmo tipo. O terceiro argumento será
executado ao fim de cada laço e pode ter mais de uma instrução.
O comando for deve ser usado sempre que se souber exatamente quantas vezes o laço
deve ser repetido.
A forma do comando for é a seguinte:
for (comandos de inicialização;condição de teste; incremento/decremento )
{
// comandos a serem repetidos
// comandos a serem repetidos
}
// comandos após o 'for'
Exemplos:
No exemplo a seguir, é testado a condição e após a execução das instruções incrementa x.
No próximo exemplo não apresenta o primeiro e terceiro argumentos, o incremento é feito dentro
do laço for.
Exercícios:
1) Exiba todos os números pares de 10 a 200.
2) Exiba todos os números ímpares existentes entre dois números informados pelo usuário. Dica:
use o operador % para calcular o resto da divisão entre dois números.
3) Escrever um algoritmo que lê 10 valores, um de cada vez, e conta quantos deles estão no inter-
valo [10,20] e quantos deles estão fora do intervalo, escrevendo estas informações.
4.2.4 Comandos de desvio
Os laços em Java, assim como a maioria das linguagens de programação, possuem dois
comandos de desvios: break e continue. Estes comandos funcionam com todos os comandos de
repetição.
O comando break encerra o laço no ponto em que for executado.

______________________________________________________________________________________________
Exemplo:
O comando continue desvia o fluxo para o início do laço.
Exemplo:
Obs: Deve-se evitar o comando continue e break, pois seu uso dificulta a legibilidade do código.
O código a seguir cria um laço de repetição entre 0 e 11, através do comando
if(i%2==1)continue, seleciona os valores impares para não serem impressos e finaliza a execução
do comando if(i==12)break.
Exercícios:
1) Crie um programa que se inicia em 1 e deve terminar em mil (1.000), mas dentro desta estrutura
há uma condição: se a variável for igual a 10 ela sai da estrutura de repetição.
2) Uma academia deseja fazer um senso entre seus clientes para descobrir o mais alto, o mais
baixo, o mais gordo e o mais magro, para isto você deve fazer um programa que pergunte a cada
um dos clientes da academia seu código, sua altura e seu peso. O final da digitação de dados deve
ser dado quando o usuário digitar 0 (zero) no campo código. Ao encerrar o programa também de-
vem ser informados os códigos e valores do cliente mais alto, do mais baixo, do mais gordo e do
mais magro, além da média das alturas e dos pesos dos clientes

______________________________________________________________________________________________
3) Escreva um programa contendo uma estrutura de repetição que irá contar de 1 a 100, mas
sempre que o número não for múltiplo de 5, o código para apresentar o número na tela será
ignorado e a repetição continuará com o número seguinte, ou seja, apenas os múltiplos de 5 entre
1 e 100 aparecem na tela.
Exercícios:
1) Faça um programa que exiba na tela todos os números entre 50 (inclusive) e 200 (inclusive).
Pode ser utilizado qualquer estrutura de repetição.
2) Faça um programa que exiba na tela todos os números pares existentes entre 1 e 100.
3) Faça um programa que exiba todos os números divisíveis por 5 no intervalo de 1 a 500.
4) Faça um programa que mostre a quantidade de números divisíveis por 3 encontrados no intervalo
de 1 a 1000.
5) Faça um programa que exiba na tela todos os números primos encontrados no intervalo entre 1
e 2000.
6) Faça um programa que solicite ao usuário um número inteiro. Analise este número e informe se
o mesmo par ou ímpar.
7) Faça um programa que solicite ao usuário um número inteiro. Analise este número e informe se
o mesmo primo ou não.
8) Faça um programa que solicite ao usuário um número inteiro. Exiba a raiz quadrada deste
número. Evite utilizar a classe Math ou outra classe ou método especializado nesta operação.
9) Escreva um programa que mostre os números impares e divisíveis por 3 e 5 encontrados no
intervalo de 1 a 1000.
10) Elaborar um programa de solicite ao usuário diversos números inteiros. O usuário irá parar de
informar números inteiros, quando digitar 0 (zero). No final deverá ser exibido a soma dos números
informados.
11) Dado um número inteiro positivo n, imprimir os n primeiros naturais ímpares.
Exemplo: Para n=4 a saída deverá ser 1,3,5,7.
12) Dado o número n de alunos de uma Programação II e suas notas da primeira prova, determinar
a maior e a menor nota obtidas por essa turma (Nota máxima = 100 e nota mínima = 0).
13) Dado um inteiro não-negativo n, informado pelo usuário, determinar n!
14) Dado um inteiro não-negativo n, informado pelo usuário, determinar se este número é primo.
15) Crie um programa que o usuário entre com 2 números, faça a soma entre eles e mostre o

Apostila java

Recomendados

Recomendados

Más contenido relacionado

La actualidad más candente

La actualidad más candente (18)

Destacado

Destacado (17)

Similar a Apostila java

Similar a Apostila java (20)

Apostila java